Come posso fare qualcosa che lampeggio / lampeggio più frequentemente man mano che si avvicina alla scomparsa?

10

Nel mio gioco quando uccidi un nemico possono far cadere qualcosa come un pacchetto sanitario o un oro. Voglio che questo abbia un limite di tempo in modo che alla fine scompaia se non lo raccogli. Voglio che l'oggetto lampeggi più frequentemente più la goccia si avvicina alla "morte". Come si fa l'algoritmo "flashing più frequente"?

algorithm rendering

— Daniel Kaplan
fonte

2

La mia preoccupazione per uno degli approcci attualmente offerti è che entrambi porteranno a lampeggiare a "velocità variabile", il che potrebbe non solo distrarre i giocatori, ma anche rendere difficile valutare con esattezza quanto tempo rimane un oggetto prima che svanisca . Invece, da qualche parte nei vostri parametri (siano esse globale per il rendering o su base per-oggetto) avrei quattro costanti: slowBlinkTime, slowBlinkRate, fastBlinkTimee fastBlinkRate. Durante il rendering, se la vita residua del tuo oggetto è inferiore a fastBlinkTime, allora lampeggia fastBlinkRate; altrimenti se è inferiore a slowBlinkTime, quindi lampeggia slowBlinkRate. Se volessi fare un passo avanti, allora potresti avere una serie di distinti blinkTimes eblinkRatee controllarli uno per uno, ma in pratica è probabile che siano eccessivi e che siano sufficienti stati di "avvertimento" e "critici". Il codice sarebbe simile al seguente:

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
}

Si noti che questo codice presuppone un ciclo di lampeggiamento a metà e metà (questo è ciò che 0.5frappresenta il test), ma potrebbe essere facilmente modificato per qualcosa come due terzi, un terzo spento semplicemente modificando la costante appropriata. Anche questo non fa nulla per "sincronizzare" il lampeggiamento tra gli stati veloce e lento, ma è relativamente semplice da lucidare.

Questo dovrebbe essere semplice da collegare e avrà l'IMHO il sostanziale vantaggio che i giocatori saranno in grado di vedere il passaggio da "lento" a "veloce" lampeggiante e sapere esattamente quanto tempo sono rimasti. Vorrei iniziare con valori di parametro come 5s per slowBlinkTimee 0,5s per slowBlinkRatee 2s / 0,25s per fastBlinkTimee fastBlinkRate, ma questo dipende sicuramente dal tuo gioco particolare.

— Steven Stadnicki
fonte

Non capisco. Se il lampeggiamento diventa sempre più veloce, non sarebbe un indicatore migliore di quanto tempo è rimasto l'oggetto rispetto a solo 2 modalità?

— Daniel Kaplan,

1

@tieTYT Il problema è che, specialmente quando il tasso di lampeggiamento è variabile, è difficile per gli utenti (a) determinare con esattezza la velocità con cui lampeggia un oggetto e (b) correlarlo con quanto tempo deve vivere. Immagina di avere un cursore da 0 a 100 rispetto a un 'interruttore' con posizioni a 0, 50 e 100; le persone potrebbero essere in grado di indovinare il valore del dispositivo di scorrimento entro il 5-10%, ma sapranno esattamente quale valore è l'interruttore - ed è molto più difficile misurare un tasso rispetto a una posizione.

— Steven Stadnicki,

Nonostante ciò che suggeriscono i voti, penso che questa sia la risposta migliore. Inoltre, è molto più semplice da implementare (almeno concettualmente). La mia risposta ha ottenuto più voti, ma non sono ancora soddisfatto visivamente. Il tuo approccio darà uno sguardo soddisfacente.

— Daniel Kaplan,

14

Se t scende da T a 0, potresti usare qualcosa come sin ((T - t) ²) quindi se il numero è> 0 disegna l'oggetto, se è <0 non

L'ho provato da solo e ho dovuto armeggiare. Per me T era 100. Questa equazione ha fatto lampeggiare le cose molto velocemente per tutto il tempo. Quindi per rallentarlo, ho cambiato l'equazione in sin (((T - t) / 10) ²). Questo dopo aver armeggiato con i numeri come / 6 e / 7.

Ho anche provato questo: sin ((T - t) ² * 1/100)

E poi non mi piaceva come la goccia sembrasse invisibile quasi quanto era visibile. Volevo che raramente fosse invisibile. L'ho fatto facendo questo: sin ((T - t) ² * 1/100) + .5 Questo + .5 sposta la "linea" seno in modo che non diventi <0 così spesso.

Niente di tutto questo ha funzionato esattamente come volevo. Il problema è che il lampeggiamento inizierà troppo presto. Volevo che la goccia fosse visibile per 3 secondi e poi iniziassi a lampeggiare. Per riuscirci, ho fatto qualcosa del genere:

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

Che xsarebbero i 3 secondi.

Vale anche la pena notare che questo è lo strumento che ho usato tutto il tempo per visualizzare come apparirebbe il battito di ciglia. Penso che questo avrebbe richiesto 5 volte di più senza lo strumento visivo.

— Daniel Kaplan
fonte

Fantastico, adoro questa soluzione, un altro modo rapido sarebbe faresin(t * pow((t/T), 1.5))

— Gustavo Maciel il

4

Forse con l'aiuto di un'altra variabile?

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

È un po 'più lungo della soluzione che ti sei proposto, ma ti risparmi costoso sine powoperazioni e hai molto più controllo su come il battito delle ciglia va più veloce.

— Panda Pajama
fonte