La matematica di un salto in un gioco 2D

Question

Sto lavorando in J2ME, ho il mio gameloop che fa quanto segue:

public void run() {
        Graphics g = this.getGraphics();
        while (running) {
            long diff = System.currentTimeMillis() - lastLoop;
            lastLoop = System.currentTimeMillis();
            input();
            this.level.doLogic();
            render(g, diff);
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                stop(e);
            }
        }
    }

Quindi è solo un gameloop di base, il file doLogic() la funzione richiede tutte le funzioni logiche dei personaggi nella scena e render(g, diff) chiama il animateChar funzione di ogni personaggio sulla scena, a seguito di ciò, il animChar La funzione nella classe Character imposta tutto sullo schermo in questo modo:

protected void animChar(long diff) {
        this.checkGravity();
        this.move((int) ((diff * this.dx) / 1000), (int) ((diff * this.dy) / 1000));
        if (this.acumFrame > this.framerate) {
            this.nextFrame();
            this.acumFrame = 0;
        } else {
            this.acumFrame += diff;
        }
    }

Questo mi assicura che tutto deve muoversi in base al tempo che la macchina impiega per passare da un ciclo all'altro (ricordate che è un telefono, non una piattaforma di gioco).Sono sicuro che non sia il modo più efficiente per ottenere questo comportamento, quindi sono totalmente aperto alle critiche sulle mie capacità di programmazione nei commenti, ma qui il mio problema:Quando faccio saltare il mio personaggio, quello che faccio è mettere il suo dy su un valore negativo, diciamo -200 e imposto il valore booleano saltando a true, questo fa salire il carattere, e poi ho chiamato questa funzione checkGravity() che assicurano che tutto ciò che sale debba scendere, checkGravity controlla anche che il personaggio sia su piattaforme, quindi lo ridurrò un po' per il bene del tuo tempo:

public void checkGravity() {
        if (this.jumping) {
            this.jumpSpeed += 10;
            if (this.jumpSpeed > 0) {
                this.jumping = false;
                this.falling = true;
            }
            this.dy = this.jumpSpeed;
        }
        if (this.falling) {
            this.jumpSpeed += 10;
            if (this.jumpSpeed > 200) this.jumpSpeed = 200;
            this.dy = this.jumpSpeed;
            if (this.collidesWithPlatform()) {
                this.falling = false;
                this.standing = true;
                this.jumping = false;
                this.jumpSpeed = 0;
                this.dy = this.jumpSpeed;
            }
        }
    }

Quindi, il problema è che questa funzione aggiorna il file dy indipendentemente da diff, facendo volare i personaggi come Superman su macchine lente, e non ho idea di come implementarlo diff fattore per cui quando un personaggio salta, la sua velocità diminuisce in modo proporzionale alla velocità del gioco.Qualcuno può aiutarmi a risolvere questo problema?Oppure dammi indicazioni su come farlo fai un salto 2D in J2ME nel modo giusto.

Answer 1

Non dovresti regolare la velocità di salto in base al tempo trascorso?Cioè, forse la velocità cambia di -75/sec, quindi la tua differenza dovrebbe essere un peso per la quantità di modifica applicata a jumpSpeed.

Quindi passa in diff per controllareGrav e fai qualcosa del tipo...jumpSpeed ​​+= (diff * (rate_per_second)) / 1000;

(assumendo la differenza in millisecondi)

(Idealmente, questo lo renderebbe proprio come la gravità reale :D)

Answer 2

Perché non ridimensionare semplicemente tutte le costanti in base alle differenze?

A proposito, sono imbarazzato nel dirlo, ma ho lavorato su un gioco commerciale in cui la gravità era due volte più forte sui personaggi che scendevano rispetto a quelli che salivano.Per qualche ragione, la gente lo preferiva.

Answer 3

Questa sembra essere più una questione di progettazione del gioco che la matematica di un salto.È un problema comune che nei giochi eseguiti su processori diversi un gioco verrà eseguito più velocemente e su altri giochi verrà eseguito più lentamente (cambiando così l'intera velocità del gioco).Non sono sicuro di quale sia la pratica comune nei giochi, ma ogni volta che realizzavo giochi 2D fatti in casa (erano divertenti da realizzare) avrei avuto il concetto di game-tick.Su macchine più veloci

long diff = System.currentTimeMillis() - lastLoop;
lastLoop = System.currentTimeMillis();

Sarebbe più basso.Dalla differenza verrebbe derivato un tempo di attesa in modo che il gioco funzioni alla stessa velocità sulla maggior parte delle macchine.Avrei anche il metodo di rendering in un thread separato in modo che la velocità del gioco non dipenda dalla grafica.

Answer 4

Posso dare una formula come questa (la uso ovunque).La X è il parametro che inizia da zero e termina con la lunghezza del salto.se vuoi che qualcuno salti ad una certa altezza (H) e ad una certa lunghezza (L), la funzione del salto sarà simile a questa (e non potrà mai apparire diversa):

y = meno (potenza (x - lunghezza del salto divisa per due) moltiplica per 4 e moltiplica per altezza del salto) dividere per potenza di lunghezza e aggiungere altezza del salto alla fine.

y = -(x-l/2)(x-l/2)*4*h/(l*l) + h

E se vuoi che l'oggetto che salta atterri su qualcosa, puoi controllare ogni nuova X se si trova approssimativamente su una piattaforma e se si trova su qualcosa, allora non farlo semplicemente fermare, rendi la sua posizione Y esattamente uguale a la Y della piattaforma.

Se stai utilizzando qualcosa come Flash o un'altra base che ha l'asse y invertito, moltiplica l'output della funzione per -1;