| | 3 | == Introduction == |
| | 4 | |
| | 5 | Pyrogenesis is the game enginefor 0 A.D. Its design goals include cross-platform compatibility (Windows, Linux and Mac OS X), efficiency (including hardware-accelerated 3D graphics), and extensibility through game mods and scripts. The core engine is written in C++. However, much of the high level game logic and user interface is implemented by scripts, which are written in JavaScript. This document focuses on the C++ engine (present in the source folder in SVN). We first describe the "life cycle" of a game and how the different engine modules interact. We then provide an overview of each module in the engine. |
| | 6 | |
| | 7 | == Life of a Game Session == |
| | 8 | |
| | 9 | When you launch 0 A.D, the game first loads from a combination of plain files in binaries/data as well as a ''zip archive'' containing commonly used files. The Virtual File System (VFS) module (implemented in lib/file) makes both files in the archive and regular files look like the same kind of File object to the game. Once the game is loaded, it displays a main menu GUI. The GUI engine is implemented by the gui module. It supports defining a GUI page layout in XML and then responding to events using JavaScript. These files are present in binaries/data/mods/official/gui/test. They interact with the game using the script functions exposed by the various C++ modules, which are generally in scripting/ScriptGlue.cpp. From the main menu, players may either start a single player game, host a multiplayer game, or join a multiplayer game. |
| | 10 | |
| | 11 | The game logic code works the same way whether the game is multiplayer or single player - all that differs is how commands are treated. We'll first describe how the game logic code is organized before explaining the details of setting up multiplayer. The game logic is implemented in the simulation module, most notably in CSimulation, which handles all updates, and CEntity, which represents and updates an in-game object (unit, building, etc). In both multiplayer and single player, the game state is updated in ''turns'', which are about 150 milliseconds each. Each turn, objects move to some new position, units may gather resources or do damage (depending on their gather rates), etc. A turn is handled in the CSimulation::Update method. In addition, between turns, the graphical objects in the game are animated continuously as fast as the frame rate permits by interpolating between their previous turn's position and their next turn's position. This is done by CSimulation::Interpolate. There is a CTurnManager object which says when it is time for a new turn (the simulation queries this object each frame). While the game is running, commands from the player (obtained through the GUI) are queued up using CTurnManager::QueueLocalCommand. Each turn, the turn manager provides a ''batch'' of commands to the simulation based on what was queued up. The only difference between single player and multiplayer is which turn manager is used: The multiplayer turn manager sends commands to the host, which buffers a batch of commands and then broadcasts them to all players, thus making sure that all clients get the same batches of commands. The single player turn manager sends commands directly to the simulation. |
| | 12 | |
| | 13 | = Outline for this document (from Gobby): = |
