Wie mache ich etwas, das ich häufiger blinke / blinke, wenn es sich dem Verschwinden nähert?

Wenn du in meinem Spiel einen Feind tötest, kann er so etwas wie ein Gesundheitspaket oder Gold fallen lassen. Ich möchte, dass dies zeitlich begrenzt ist, damit es schließlich verschwindet, wenn Sie es nicht abholen. Ich möchte, dass der Gegenstand häufiger blinkt, je näher der Tropfen dem "Tod" kommt. Wie macht man den "häufiger blinkenden" Algorithmus?

Ich mache mir Sorgen um einen der derzeit angebotenen Ansätze, dass beide zu einem Blinken mit variabler Geschwindigkeit führen, was nicht nur die Spieler ablenken könnte, sondern es auch schwierig macht, genau zu beurteilen, wie lange ein Objekt noch übrig ist, bevor es verschwindet . Stattdessen irgendwo in Ihren Parametern (ob sie für den Renderer oder auf einer pro-Objekt - Basis global sein) würde ich vier Konstanten: slowBlinkTime, slowBlinkRate, fastBlinkTimeund fastBlinkRate. Wenn beim Rendern die Restlebensdauer Ihres Objekts kürzer als ist fastBlinkTime, blinken Sie es an fastBlinkRate. Andernfalls, wenn es kleiner als ist slowBlinkTime, blinken Sie es an slowBlinkRate. Wenn Sie noch einen Schritt weiter gehen möchten, können Sie eine Reihe unterschiedlicher blinkTimes und habenblinkRates und überprüfen Sie sie nacheinander, aber in der Praxis ist das wahrscheinlich übertrieben und es sollte ausreichen, nur "Warn" - und "kritische" Zustände zu haben. Der Code würde ungefähr so ​​aussehen:

float blinkCycle;
if ( entity.timeLeft < fastBlinkTime ) {
  blinkCycle = entity.timeLeft/fastBlinkRate;
} else if ( entity.timeLeft < slowBlinkTime ) {
  blinkCycle = entity.timeLeft/slowBlinkRate;
}
blinkCycle = blinkCycle - floor(blinkCycle); // find blinkCycle 'mod 1'
if ( (entity.timeLeft < slowBlinkTime) && (blinkCycle < 0.5f) ) {
  renderBlinked(entity); // this should be the 'blinked' state, whether flashed or missing
} else {
  renderNormal(entity); // the normal render for the entity
}

Beachten Sie, dass dieser Code einen halben Ein-Aus-Aus-Blinkzyklus voraussetzt (das ist, was der 0.5fTest darstellt), aber leicht für etwa zwei Drittel ein, ein Drittel aus angepasst werden kann, indem nur die entsprechende Konstante angepasst wird. Dies hat auch nichts mit dem "Synchronisieren" des Blinkens zwischen dem schnellen und dem langsamen Zustand zu tun, aber das Polieren ist relativ einfach.

Das Einstecken sollte einfach sein, und es hat meiner Meinung nach den wesentlichen Vorteil, dass die Spieler den Wechsel von "langsam" zu "schnell" blinken sehen und genau wissen, wie lange sie noch übrig sind. Ich würde mit Parameterwerten wie 5s für slowBlinkTimeund 0,5s für slowBlinkRateund 2s / 0,25s für fastBlinkTimeund beginnen fastBlinkRate, aber das hängt definitiv von Ihrem speziellen Spiel ab.

Wenn t von T auf 0 sinkt, können Sie so etwas wie sin ((T - t) ²) verwenden. Wenn die Zahl> 0 ist, zeichnen Sie das Objekt, wenn es <0 ist, tun Sie es nicht

Ich habe das selbst ausprobiert und musste daran basteln. Für mich war T 100. Diese Gleichung ließ die Dinge die ganze Zeit super schnell blinken. Um es zu verlangsamen, habe ich die Gleichung in sin (((T - t) / 10) ²) geändert. Dies geschah, nachdem man mit den Zahlen / 6 und / 7 herumgebastelt hatte.

Ich habe auch Folgendes versucht: sin ((T - t) ² * 1/100)

Und dann gefiel mir nicht, wie der Tropfen fast so unsichtbar schien, wie er sichtbar war. Ich wollte, dass es selten unsichtbar ist. Ich habe dies erreicht, indem ich Folgendes getan habe: sin ((T - t) ² * 1/100) + .5 Das + .5 verschiebt die Sinus- "Linie" nach oben, so dass sie nicht so oft <0 wird.

Nichts davon funktionierte genau so, wie ich es wollte. Das Problem ist, dass das Blinken zu früh beginnen würde. Ich wollte, dass der Tropfen 3 Sekunden lang sichtbar ist und dann anfängt zu blinken. Um das zu erreichen, habe ich so etwas gemacht:

isVisible(drop)
  if drop.t > x
    return true
  else
    sin((T - x - drop.t)² * 1/100) + .5 >= 0

Das xwären die 3 Sekunden.

Erwähnenswert ist auch, dass dies das Werkzeug ist, mit dem ich die ganze Zeit über visualisiert habe, wie das Blinken aussehen würde. Ich denke, dass dies ohne das visuelle Werkzeug 5x länger gedauert hätte.

Vielleicht mit Hilfe einer anderen Variablen?

current_length = 4
length_decrease = 0.5
current_time = current_length

function update(delta_time)
    if current_time > 0 then
        draw()
    end
    current_time -= delta_time
    if current_time < -current_length then
        current_length -= length_decrease -- feel free to get creative here
        if current_length < 0 then
            disable_object()
        end
        current_time += current_length * 2
    end
end

Es ist etwas länger als die von Ihnen vorgeschlagene Lösung, aber Sie sparen sich Kosten sinund powBetriebskosten und haben viel mehr Kontrolle darüber, wie das Blinken schneller abläuft.