Me preguntaba si hay algún daño posible cuando mi ciclo de juego se ejecuta tan rápido como el sistema lo permite.
Actualmente tengo un bucle que, al medir el tiempo transcurrido en nanosegundos, ejecuta la lógica del juego y la lógica de representación a velocidades predefinidas sin ningún problema. De hecho, cualquier lógica que hago en el bucle se sincroniza con una cierta cantidad de llamadas cada segundo.
Sin embargo, el bucle en sí solo funciona tan rápido como le gusta, lo que equivale a alrededor de 11.7 millones de bucles por segundo en mi máquina.
Bucle (pseudocódigo simple):
while(!isGameOver){
if(canPollInputs){
pollInputs()
}
while(canStepLogic){
stepLogic()
}
if(canRender){
render()
}
}Mi pregunta es, básicamente, si ese simple bucle, si no está funcionando a una velocidad controlada, ¿puede causar algún daño a un sistema?
Editar: Eso significa que mi lógica se está ejecutando 30 veces por segundo (30 tps), mi procesador se está ejecutando a 60 fps, estoy sondeando entradas a 100 veces por segundo y también hay algo de lógica para hacer frente a la lógica o hacer que el procesamiento tarde más de lo esperado . Pero el bucle en sí no está estrangulado.
Editar: usar, Thread.sleep()por ejemplo, Acelerar el bucle principal hasta 250 bucles por segundo conduce a una reducción, pero los bucles se ejecutan a alrededor de 570 bucles por segundo en lugar de los 250 deseados (agregaré código cuando estoy en mi máquina de escritorio ...)
Editar: Aquí vamos, un gameloop de Java que funciona para aclarar las cosas. También siéntase libre de usarlo, pero no lo reclame como suyo;)
private void gameLoop() {
// Time that must elapse before a new run
double timePerPoll = 1000000000l / targetPPS;
double timePerTick = 1000000000l / targetTPS;
double timePerFrame = 1000000000l / targetFPS;
int maxFrameSkip = (int) ( (1000000000l / MINIMUM_FPS) / timePerTick);
int achievedPPS = 0;
int achievedFPS = 0;
int achievedTPS = 0;
long timer = TimeUtils.getMillis();
int loops = 0;
int achievedLoops = 0;
long currTime = 0l;
long loopTime = 0l;
long accumulatorPPS = 0l;
long accumulatorTPS = 0l;
long accumulatorFPS = 0l;
long lastTime = TimeUtils.getNano();
while(!isRequestedToStop) {
currTime = TimeUtils.getNano();
loopTime = currTime - lastTime;
lastTime = currTime;
loops = 0;
accumulatorPPS += loopTime;
accumulatorTPS += loopTime;
accumulatorFPS += loopTime;
if(accumulatorPPS >= timePerPoll) {
pollInputs();
playerLogic();
achievedPPS++;
accumulatorPPS -= timePerPoll;
}
while(accumulatorTPS >= timePerTick && loops < maxFrameSkip) {
tick();
achievedTPS++;
accumulatorTPS -= timePerTick;
loops++;
}
// Max 1 render per loop so player movement stays fluent
if(accumulatorFPS >= timePerFrame) {
render();
achievedFPS++;
accumulatorFPS -= timePerFrame;
}
if(TimeUtils.getDeltaMillis(timer) > 1000) {
timer += 1000;
logger.debug(achievedTPS + " TPS, " + achievedFPS + " FPS, "
+ achievedPPS + " Polls, " + achievedLoops + " Loops");
achievedTPS = 0;
achievedFPS = 0;
achievedLoops = 0;
}
achievedLoops++;
}
}Como puede ver, casi no hay código ejecutado en cada ciclo, pero siempre hay una cierta selección basada en la cantidad de tiempo real que ha pasado. La pregunta se refiere a ese "ciclo de trabajo" y cómo influye en el sistema.