[JAVA] Timer videogame

[caralu]

Ciao a tutti!
Devo realizzare una classe di un videoGame per fare apparire gli oggetti bonus all'interno di un labirinto. Vi sono diversi tipi di oggetti che compaiono per un periodo di tempo limitato (proporzionale al "valore" dell'oggetto) e poi spariscono. Volevo chiedervi un consiglio per realizzare il timer, come posso fare?
Stavo pensando di memorizzare l'ora dell'orologio di sistema al momento che compare l'oggetto e fare sparire quest'ultimo al momento:
"oraMemorizzata + intervalloScelto".
Mi potete dare qualche consiglio su come implementarlo?
Grazie

[franksisca]

Originariamente inviato da caralu

Ciao a tutti!
Devo realizzare una classe di un videoGame per fare apparire gli oggetti bonus all'interno di un labirinto. Vi sono diversi tipi di oggetti che compaiono per un periodo di tempo limitato (proporzionale al "valore" dell'oggetto) e poi spariscono. Volevo chiedervi un consiglio per realizzare il timer, come posso fare?
Stavo pensando di memorizzare l'ora dell'orologio di sistema al momento che compare l'oggetto e fare sparire quest'ultimo al momento:
"oraMemorizzata + intervalloScelto".
Mi potete dare qualche consiglio su come implementarlo?
Grazie

potresti "giocare" con i thread.

[caralu]

Originariamente inviato da franksisca

potresti "giocare" con i thread.

Scusa, potresti spiegarti meglio? Intendi creare 1 thread che gestisce il tempo?

[MEMon]

Come l'hai pensata va bene, usa System.nanoTime() per ricavare il tempo in nanosecondi.
Tieni presente però che ad eseguire del codice ci si mette del tempo, quindi inserisci anche quello nel conteggio dell'intervallo!

[caralu]

Originariamente inviato da MEMon

Come l'hai pensata va bene, usa System.nanoTime() per ricavare il tempo in nanosecondi.
Tieni presente però che ad eseguire del codice ci si mette del tempo, quindi inserisci anche quello nel conteggio dell'intervallo!

Ok, grazie 1000 per le dritte! Domani mattina vedo un po csa ne viene fuori!

[caralu]

Ho implementando una variabile static di Tipo timer per ogni oggetto Bonus, in modo che siano indipendenti da loro e possano essere richiamati e bloccati in momenti diversi.
Ora ho un altro problema...Come posso fare a richiamare gli oggetti Bonus in maniera casuale sullo schermo? Io ho pensato ad una soluzione di questo genere:

//Metodo di richiamo del Bonus (all'interno della classe Game):

private void probabilitàPremio()
     {
      //Il numero dei premi visualizzabili deve essere > di quelli visualizzati
      if(MAX_NUM_PREMI > premiVisualizzati)
                {
                    Random rand = new Random();
                    //Genero un numero da 0 a 99
                    probabilità = rand.nextInt(100);
               //Ho il 30% delle probabilità che in un ciclo venga visualizzato 1 Bonus
                    if(probabilità > 70)
                        {
         //I premi sono già memorizzati su un'arrayList e caricati in una mappa
         //ma sono "Invisibili" fino a che non si esegue il metodo eseguiPremio();
         //Scelgo un premio in maniera Random fra quelli esistenti
                            int nPremioRandom = rand.nextInt(premi.size());
                            Bonus bonus = (Bonus) premi.get(nPremioRandom);
                            //Rendo visibile il premio
                            bonus.eseguiPremio();
                            premioEsecuzione = true;
                        }
                }
}
---------------------------------------------------------------------------------------------------
//eseguiPremio (all'interno della classe Bonus) invece è questo:

public void eseguiPremio()
        {
        this.visibile = true;
    
        try {
            Timer timer = new Timer();
            TimerTask task = new MyTask();
            // aspetta 10 secondi prima di sparire
            timer.schedule( task, 10000 );
            }
        catch (Exception e) {}
        
        this.visibile = false;
    }
    
    private class MyTask extends TimerTask
        {
        public void run() {}
        }

Questa è la prima soluzione che mi è venuta in mente ma mi sembra un po grossolana.. Il gioco è diventato molto "pesante" (gli oggetti animati si muovono in maniera meno fluida) e non riesco nemmeno a far comparire i premi! C'è sicuramente qualche soluzione più fine per raggiungere questo scopo, sapete consigliarmi qualcosa? Grazie

[MEMon]

Allora, i timer che usi sono a tutti gli effetti dei thread, e credo proprio che non siano quello che stai cercando! Se crei molti thread concorrenti il gioco diventa pesante ovviamente!Ricorda che nella maggior parte dei casi per avere buone prestazioni occorre fare tutto in un thread.

Visto che abbiamo gli oggetti usiamoli, ti crei una bella classe che si occupa di contare il tempo, ad esempio ad ogni ciclo ti sa dire quanto tempo è passato dal passaggio precedente, ad esempio:

public class ContaTempo{
   
   private static long inizio=0,fine=0;

   public ContaTempo(){
   }

   public static void setInizio(){
        inizio=System.nanoTime();
   }

   public static long tempoTrascorso(){
       fine=System.nanoTime()-inizio;
       setInizio();
       return fine;
   }
}

In questo modo puoi sapere il tempo in nanosecondi per eseguire un determinato blocco di codice.
Ora non ti resta che far sapere questo tempo agli oggetti che vuoi siano soggetti a mutamenti durante il tempo, come nel tuo caso gli oggetti bonus che impigano il tempo per sapere quanto devono restare sullo schermo.

Questa è la parte di codice all'interno della classe bonus:

double tempoTrascorso=0,tempoDiPermanenza=0;

public void eseguiPremio(double tempoDiPermanenza){
   this.tempoDiPermanenza=tempoDiPermanenza;
   this.visibile = true;
}
    
public void tempoChePassa(double delay){
    tempoTrascorso+=delay; //incrementi il tempo trascorso di quanto tempo è effettivamente trascorso!
    if(tempoTrascorso>=tempoDiPermanenza) visible=false;
}

In questo modo la cosa è semplicissima, quando vuoi rendere un oggetto visibile ti basta chiamare il metodo eseguiPremio passandolgi quanto tempo vuoi che resti visibile, e nel tuo ciclo di gioco devi chiamare empre il metodo tempoChePassa passandolgi quanto tempo impieghi a fare un ciclo, ad esempio:

ContaTempo.setInizio();
public void gameLoop(){
     while(loop){
          ----- fai le tue cose----
          bonus.tempoChePassa(delay/1E9);
          delay=ContaTempo.tempoTrascorso(); //delay è in nanosecondi per averlo in secondi fai delay/1E9
     }
}

per quanto riguarda il metodo che usi per decidere quale bnous rendere visibile direi che non va male...di sicuro non è quello a renderti pesanti le cose.

[caralu]

Grazie 1000! Sei stato veramente chiaro e la tua soluzione mi è piaciuta parecchio!
Ora implemento questa variante, se ho qualche problema (ma non penso, visto i tuoi dettagli di spiegazione!) lo posto qua..grazie ancora!