Game Loop - Revision history

Winkio at 14:37, 16 June 2024

2024-06-16T14:37:41Z

← Older revision		Revision as of 10:37, 16 June 2024
Line 2:		Line 2:

	==Simple Game Loop==		==Simple Game Loop==
	In the simplest example of a game loop, the game updates and ~~draws~~ at the same rate.		In the simplest example of a game loop, the game updates and renders at the same rate.

	<syntaxhighlight lang="cs">		<syntaxhighlight lang="cs">
Line 10:		Line 10:
	{		{
	Update(); // updates game logic (handle input, physics, collision, interaction, etc.)		Update(); // updates game logic (handle input, physics, collision, interaction, etc.)
	~~Draw~~(); // renders game to player (images, sounds, 3d models, text, etc.)		Render(); // renders game to player (images, sounds, 3d models, text, etc.)
	}		}
	}		}
Line 20:		Line 20:
	**Even when the game slows down, physics and game logic are still processed in a consistent manner.		**Even when the game slows down, physics and game logic are still processed in a consistent manner.
	*Cons		*Cons
	**If either the <code>Update()</code> or the <code>~~Draw~~()</code> take too much time, the game will slow down.		**If either the <code>Update()</code> or the <code>Render()</code> take too much time, the game will slow down.
	**Game may not run at full speed on weaker hardware.		**Game may not run at full speed on weaker hardware.
	**Different versions of the game must be made in order to run at different framerates.		**Different versions of the game must be made in order to run at different framerates.
Line 47:		Line 47:

	Update(dt); // updates game logic (handle input, physics, collision, interaction, etc.)		Update(dt); // updates game logic (handle input, physics, collision, interaction, etc.)
	~~Draw~~(dt); // renders game to player (images, sounds, 3d models, text, etc.)		Render(dt); // renders game to player (images, sounds, 3d models, text, etc.)

	lastTime = time;		lastTime = time;
Line 58:		Line 58:
	*Pros		*Pros
	**Game runs at full speed on weaker hardware.		**Game runs at full speed on weaker hardware.
	**If either the <code>Update()</code> or the <code>~~Draw~~()</code> take too much time, the game keeps running at full speed.		**If either the <code>Update()</code> or the <code>Render()</code> take too much time, the game keeps running at full speed.
	**One version of the game can run on hardware with different framerates.		**One version of the game can run on hardware with different framerates.
	*Cons		*Cons
Line 65:		Line 65:
	***Player inputs may be dropped.		***Player inputs may be dropped.

	==Independent Update and ~~Draw~~==		==Independent Update and Render==
	Ideally game logic should be fixed step for a consistent experience, but game rendering should be able to run independently at the display's refresh rate. To achieve this <code>Update()</code> must be able to run independently of <code>~~Draw~~()</code>, a separation many programmers are familiar with (back end / front end, model / view, etc.).		Ideally game logic should be fixed step for a consistent experience, but game rendering should be able to run independently at the display's refresh rate. To achieve this <code>Update()</code> must be able to run independently of <code>Render()</code>, a separation many programmers are familiar with (back end / front end, model / view, etc.).

	===Frame Interpolation===		===Frame Interpolation===
	The easiest way to implement this separation is with Frame Interpolation. The last two frames of the game state must be stored, and then <code>~~Draw~~()</code> simply interpolates between them based on the current time.		The easiest way to implement this separation is with Frame Interpolation. The last two frames of the game state must be stored, and then <code>Render()</code> simply interpolates between them based on the current time.

	<syntaxhighlight lang="cs">		<syntaxhighlight lang="cs">
Line 105:		Line 105:
	var interp = (time - currentTickTime).TotalSeconds / fixedStep.TotalSeconds;		var interp = (time - currentTickTime).TotalSeconds / fixedStep.TotalSeconds;
	var interpTickData = Interpolate(previousTickData, currentTickData, interp);		var interpTickData = Interpolate(previousTickData, currentTickData, interp);
	~~Draw~~(interpTickData); // renders game to player (images, sounds, 3d models, text, etc.)		Render(interpTickData); // renders game to player (images, sounds, 3d models, text, etc.)
	}		}
	}		}
Line 156:		Line 156:
	var partialTickData = UpdatePartial(partialStep); // updates game logic (handle input, physics, collision, interaction, etc.)		var partialTickData = UpdatePartial(partialStep); // updates game logic (handle input, physics, collision, interaction, etc.)

	~~Draw~~(partialTickData); // renders game to player (images, sounds, 3d models, text, etc.)		Render(partialTickData); // renders game to player (images, sounds, 3d models, text, etc.)
	}		}
	}		}
Line 174:		Line 174:

	==Multi Threaded==		==Multi Threaded==
	Another important improvement comes from a multi threaded game loop, in which <code>Update()</code> and <code>~~Draw~~()</code> are run on separate threads. This prevents slowdowns on one thread from affecting the other, creating smoother and more consistent gameplay.		Another important improvement comes from a multi threaded game loop, in which <code>Update()</code> and <code>Render()</code> are run on separate threads. This prevents slowdowns on one thread from affecting the other, creating smoother and more consistent gameplay.

	Be Warned! Multi threaded code is difficult to debug and can give rise to many difficult issues. Beginners are recommended to stick with a single threaded game loop, as the problems of multi threading will often outweigh its benefits.		Be Warned! Multi threaded code is difficult to debug and can give rise to many difficult issues. Beginners are recommended to stick with a single threaded game loop, as the problems of multi threading will often outweigh its benefits.
Line 235:		Line 235:
	}		}
	var interpTickData = Interpolate(tickData0, tickData1, interp);		var interpTickData = Interpolate(tickData0, tickData1, interp);
	~~Draw~~(interpTickData); // renders game to player (images, sounds, 3d models, text, etc.)		Render(interpTickData); // renders game to player (images, sounds, 3d models, text, etc.)
	}		}
	}		}
Line 291:		Line 291:
	var partialTickData = UpdatePartial(fixedTickData, partialStep); // updates game logic (handle input, physics, collision, interaction, etc.)		var partialTickData = UpdatePartial(fixedTickData, partialStep); // updates game logic (handle input, physics, collision, interaction, etc.)

	~~Draw~~(partialTickData); // renders game to player (images, sounds, 3d models, text, etc.)		Render(partialTickData); // renders game to player (images, sounds, 3d models, text, etc.)
	}		}
	}		}

Winkio at 02:37, 10 June 2024

2024-06-10T02:37:56Z

← Older revision		Revision as of 22:37, 9 June 2024
Line 104:		Line 104:
	time = GetRealTime();		time = GetRealTime();
	var interp = (time - currentTickTime).TotalSeconds / fixedStep.TotalSeconds;		var interp = (time - currentTickTime).TotalSeconds / fixedStep.TotalSeconds;
	~~Draw~~(previousTickData, currentTickData, interp); // renders game to player (images, sounds, 3d models, text, etc.)		var interpTickData = Interpolate(previousTickData, currentTickData, interp);
			Draw(interpTickData); // renders game to player (images, sounds, 3d models, text, etc.)
	}		}
	}		}
Line 233:		Line 234:
	tickData1 = currentTickData;		tickData1 = currentTickData;
	}		}
	~~Draw~~(tickData0, tickData1, interp); // renders game to player (images, sounds, 3d models, text, etc.)		var interpTickData = Interpolate(tickData0, tickData1, interp);
			Draw(interpTickData); // renders game to player (images, sounds, 3d models, text, etc.)
	}		}
	}		}

Winkio: /* Timesteps */

2024-06-10T02:13:18Z

Timesteps

← Older revision		Revision as of 22:13, 9 June 2024
Line 54:		Line 54:
	</syntaxhighlight>		</syntaxhighlight>

	This solved a few important issues but introduced new ~~issues as well~~:		This solved a few important issues but introduced new ones at the same time:

	*Pros		*Pros
	**Game runs at full speed on weaker hardware.		**Game runs at full speed on weaker hardware.
	**If either the <code>Update()</code> or the <code>Draw()</code> ~~took~~ too much time, the game ~~would keep~~ running at full speed.		**If either the <code>Update()</code> or the <code>Draw()</code> take too much time, the game keeps running at full speed.
	**One version of the game can run at different framerates.		**One version of the game can run on hardware with different framerates.
	*Cons		*Cons
	**When the game slows down		**When the game slows down

Winkio at 02:12, 10 June 2024

2024-06-10T02:12:10Z

← Older revision		Revision as of 22:12, 9 June 2024
Line 295:		Line 295:

	Note that the partial update actually occurs on the render thread, not the update thread.		Note that the partial update actually occurs on the render thread, not the update thread.

			==Notes==
			In practice game loops may have a lot more code. They may wait a certain amount of time between passes, do less processing on certain passes than others, contain exit logic, etc.

	[[Category:Game]]		[[Category:Game]]

Winkio at 02:11, 10 June 2024

2024-06-10T02:11:27Z

← Older revision		Revision as of 22:11, 9 June 2024
Line 14:		Line 14:
	}		}
	</syntaxhighlight>		</syntaxhighlight>

	~~In practice game loops may have a lot more code. They may wait a certain amount of time between passes, do less processing on certain passes than others, contain exit logic, etc.~~

	This was a common way to design video games when they were first made, and came with the following pros and cons:		This was a common way to design video games when they were first made, and came with the following pros and cons:

Winkio: /* Partial Step */

2024-06-10T01:26:50Z

Partial Step

← Older revision		Revision as of 21:26, 9 June 2024
Line 296:		Line 296:
	</syntaxhighlight>		</syntaxhighlight>

	Note that the partial update actually occurs on the ~~Render~~ thread, not the update thread.		Note that the partial update actually occurs on the render thread, not the update thread.

	[[Category:Game]]		[[Category:Game]]

Winkio at 23:18, 9 June 2024

2024-06-09T23:18:58Z

← Older revision		Revision as of 19:18, 9 June 2024
Line 298:		Line 298:
	Note that the partial update actually occurs on the Render thread, not the update thread.		Note that the partial update actually occurs on the Render thread, not the update thread.

	[[Category:~~Basics~~]]		[[Category:Game]]

Winkio: /* Simple Game Loop */

2024-06-09T20:54:39Z

Simple Game Loop

← Older revision		Revision as of 16:54, 9 June 2024
Line 22:		Line 22:
	**Even when the game slows down, physics and game logic are still processed in a consistent manner.		**Even when the game slows down, physics and game logic are still processed in a consistent manner.
	*Cons		*Cons
	**If either the <code>Update()</code> or the <code>Draw()</code> ~~took~~ too much time, the game ~~would~~ slow down.		**If either the <code>Update()</code> or the <code>Draw()</code> take too much time, the game will slow down.
	**Game may not run at full speed on weaker hardware.		**Game may not run at full speed on weaker hardware.
	**Different versions of the game must be made in order to run at different framerates.		**Different versions of the game must be made in order to run at different framerates.

Winkio: /* Multi Threaded */

2024-06-09T20:46:36Z

Multi Threaded

← Older revision		Revision as of 16:46, 9 June 2024
Line 175:		Line 175:

	==Multi Threaded==		==Multi Threaded==
	Another important improvement comes from a multi threaded game loop, in which <code>Update()</code> and <code>Draw()</code> are run on separate threads.		Another important improvement comes from a multi threaded game loop, in which <code>Update()</code> and <code>Draw()</code> are run on separate threads. This prevents slowdowns on one thread from affecting the other, creating smoother and more consistent gameplay.

			Be Warned! Multi threaded code is difficult to debug and can give rise to many difficult issues. Beginners are recommended to stick with a single threaded game loop, as the problems of multi threading will often outweigh its benefits.

			Be careful when using async / await! They can lead to many types of bugs and errors when working on a game, and it is generally better to define all the threads/tasks you will need at startup and utilize them as needed.

	===Frame Interpolation===		===Frame Interpolation===

Winkio: /* Partial Step */

2024-06-09T20:37:55Z

Partial Step

← Older revision		Revision as of 16:37, 9 June 2024
Line 291:		Line 291:
	}		}
	</syntaxhighlight>		</syntaxhighlight>

			Note that the partial update actually occurs on the Render thread, not the update thread.

	[[Category:Basics]]		[[Category:Basics]]