CSCE 552 Fall 2012 Language and Programming By Jijun Tang
Data Structures: Array Elements are adjacent in memory (great cache consistency) Requires continuous memory space They never grow or get reallocated Use dynamic incremental array concept GCC has a remalloc function In C++ there's no check for going out of bounds Use vector if possible Keep in mind of checking boundaries Inserting and deleting elements in the middle is expensive
Lists
Hash Table
Stack/Queue/Priority Queue
Bit packing Fold all necessary data into a smaller number of bits Bool in C++ may use up to 4 bytes, thus is very expensive Very useful for storing boolean flags: pack 32 in an integer Possible to apply to numerical values if we can give up range or accuracy Very low level trick Use shifts to handle the operation or use assembly Only use when absolutely necessary
Bits
Inheritance Models “is-a” relationship Extends behavior of existing classes by making minor changes Do not overuse, if possible, use component systerm UML diagram representing inheritance
Component Systems Component system organization
Factory Pattern
Singleton Implements a single instance of a class with global point of creation and access For example, GUI Don't overuse it!!!
Adapter Convert the interface of a class into another interface clients expect. Adapter lets classes work together that couldn't otherwise because of incompatible interfaces Real interface
Observer Allows objects to be notified of specific events with minimal coupling to the source of the event Two parts subject and observer
Composite Allow a group of objects to be treated as a single object Very useful for GUI elements, hierarchical objects, inventory systems, etc
Composite Pattern Example - I Add many more inherited classes
Game Architecture
Overall Architecture The code for modern games is highly complex The Sims: 3 million lines of code Xbox HD DVD player: 4.7 million lines MS Train Simulator has 1GB installed, with only 10MB executable With code bases exceeding a million lines of code, a well-defined architecture is essential
Overall Architecture Main structure Game-specific code Game-engine code Both types of code are often split into modules, which can be static libraries, DLLs, or just subdirectories
Overall Architecture Architecture types Ad-hoc (everything accesses everything) Modular DAG (directed acyclic graph) Layered Options for integrating tools into the architecture Separate code bases (if there's no need to share functionality) Partial use of game-engine functionality Full integration
Ad-hoc
Modular
DAG
Layered
Example
Overview: Initialization/Shutdown The initialization step prepares everything that is necessary to start a part of the game The shutdown step undoes everything the initialization step did, but in reverse order
Initialization/Shutdown Resource Acquisition Is Initialization A useful rule to minimalize mismatch errors in the initialization and shutdown steps Means that creating an object acquires and initializes all the necessary resources, and destroying it destroys and shuts down all those resources Optimizations Fast shutdown Warm reboot
Overview: Main Game Loop Games are driven by a game loop that performs a series of tasks every frame Some games have separate loops for the front and the game itself Other games have a unified main loop Must finish a loop within second
Tasks of Main Game Loop Handling time Gathering player input Networking Simulation Collision detection and response Object updates Rendering Other miscellaneous tasks
Sample Game Loop
private void GameLoop() { frameRate = game.FrameRate(); ticks = Environment.TickCount; lastTime = 0; if (ticks > lastTime + 16) { lastTime = ticks; switch (game.gameState) { case Game.GameStates.STATE_PLAY: game.playScreen.Draw(); break; case Game.GameStates.STATE_LOAD: game.loadScreen.Draw(); break; case Game.GameStates.STATE_PLAYING: doScrolling(); doHero(); doSide(); break; } game.Update(); Application.DoEvents(); } else { System.Threading.Thread.Sleep(1); } }
Main Game Loop Structure Hard-coded loops Multiple game loops: for each major game state Consider steps as tasks to be iterated through Coupling Can decouple the rendering step from simulation and update steps Results in higher frame rate, smoother animation, and greater responsiveness Implementation is tricky and can be error-prone
Execution Order of Main Loop Most of the time it doesn't matter In some situations, execution order is important Can help keep player interaction seamless Can maximize parallelism Exact ordering depends on hardware
static void Start(UserSettings settings, string[] args) { InitSimulator(settings, args); Simulator.Start(); Viewer = new Viewer3D(Simulator); Viewer.Run(); Simulator.Stop(); } [ThreadName( "Render" )] public void Run() { LoaderProcess = new LoaderProcess( this ); UpdaterProcess = new UpdaterProcess( this ); RenderProcess = new RenderProcess( this ); RenderProcess.Run(); }
static void Start(UserSettings settings, string[] args) { InitSimulator(settings, args); Simulator.Start(); Viewer = new Viewer3D(Simulator); Viewer.Run(); Simulator.Stop(); } [ThreadName( "Render" )] public void Run() { LoaderProcess = new LoaderProcess( this ); UpdaterProcess = new UpdaterProcess( this ); RenderProcess = new RenderProcess( this ); RenderProcess.Run(); }
public LoaderProcess(Viewer3D viewer) { Threaded = true; Viewer = viewer; if (Threaded) { State = new ProcessState("Loader"); Thread = new Thread(LoaderThread); Thread.Start(); }
[ThreadName("Loader")] void LoaderThread() { Profiler.SetThread(); while (Thread.CurrentThread.ThreadState == System.Threading.ThreadState.Running) { // Wait for a new Update() command State.WaitTillStarted(); try { if (!DoLoad()) return; } finally { State.SignalFinish(); }
public UpdaterProcess(Viewer3D viewer) { Threaded = System.Environment.ProcessorCount > 1; Viewer = viewer; if (Threaded) { State = new ProcessState("Updater"); Thread = new Thread(UpdaterThread); Thread.Start(); }
[ThreadName("Updater")] void UpdaterThread() { Profiler.SetThread(); while (Thread.CurrentThread.ThreadState == System.Threading.ThreadState.Running) { // Wait for a new Update() command State.WaitTillStarted(); try { if (!DoUpdate()) return; } finally { State.SignalFinish(); }
public UpdaterProcess(Viewer3D viewer) { Threaded = System.Environment.ProcessorCount > 1; Viewer = viewer; if (Threaded) { State = new ProcessState("Updater"); Thread = new Thread(UpdaterThread); Thread.Start(); }
[ThreadName("Updater")] void UpdaterThread() { Profiler.SetThread(); while (Thread.CurrentThread.ThreadState == System.Threading.ThreadState.Running) { // Wait for a new Update() command State.WaitTillStarted(); try { if (!DoUpdate()) return; } finally { State.SignalFinish(); }