1. CSCE 552 Spring 2009 Programming Fundamentals By Jijun Tang

2. Homework #1 6 points, due on next Wednesday Turn in hard copy before the class Expected about 1 page Question: Review your popular games (2-3), including game description, features, strength and weakness, etc.

3. C++: Strengths Performance High-level, object-oriented C Heritage Libraries

4. C++: Weaknesses Too low-level Slow iteration Too complicated Lacking features

5. Java Performance Has typically been Java's weak point Has improved in the last few years: still not up to C++ level, but very close Uses Just-In-Time compiling and HotSpot optimizations Now has high-performance libraries Also has access to native functionality

6. Popular scripting languages Python Lua Other off-the-shelf options such as Ruby, Perl, Javascript Custom scripting languages  UnrealScript, QuakeC, NWNScript

7. 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

8. List Very cheap to add/remove elements. Available in the STL (std::list) Every element is allocated separately, not placed contiguously in memory  Lots of little allocations  Bad cache awareness, but can use arrays to hold pre-allocated items Single/Double linked list

9. Lists

10. Dictionaries Maps a set of keys to some data. std::map, std::hash, etc Very fast access to data Perfect for mapping IDs to pointers, or resource handles to objects May waste space, need to design comparison operators

11. Hash Table

12. Others Stacks  First in, last out  std::stack adaptor in STL Queues  First in, first out  std::deque  Priority queue is useful in game to schedule events

13. Stack/Queue/Priority Queue

14. 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

15. Bits

16. Game Architecture and Math

17. 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

18. Polymorphism The ability to refer to an object through a reference (or pointer) of the type of a parent class Key concept of object oriented design C++ implements it using virtual functions

19. Multiple Inheritance Allows a class to have more than one base class Derived class adopts characteristics of all parent classes Huge potential for problems (clashes, casting, dreaded diamond, etc) Multiple inheritance of abstract interfaces is much less error prone (virtual inheritance) Java has no multiple inheritance

20. Dreaded Diamond It is an ambiguity that arises when two classes B and C inherit from A, and class D inherits from both B and C. If a method in D calls a method defined in A (and does not override the method), and B and C have overridden that method differently, then from which class does it inherit: B, or C?

21. Component Systems Component system organization

22. Object Factory Creates objects by name Pluggable factory allows for new object types to be registered at runtime Extremely useful in game development for passing messages, creating new objects, loading games, or instantiating new content after game ships

23. Factory Pattern

24. Simple Sample Factory - I

25. Simple Sample Factory - II

26. Singleton Implements a single instance of a class with global point of creation and access For example, GUI Don't overuse it!!!

27. Singleton Example

28. 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

29. Adapter Pattern

30. Adapter Example - I

31. Adapter Example - II

32. Observer Allows objects to be notified of specific events with minimal coupling to the source of the event Two parts  subject and observer

33. Observer Pattern

34. Composite Allow a group of objects to be treated as a single object Very useful for GUI elements, hierarchical objects, inventory systems, etc

35. Composite Pattern

36. Composite Pattern Example - I Add many more inherited classes

37. The Five Step Debugging Process 1. Reproduce the problem consistently 2. Collect clues 3. Pinpoint the error 4. Repair the problem 5. Test the solution

38. Expert Debugging Tips Question assumptions Minimize interactions and interference Minimize randomness Break complex calculations into steps Check boundary conditions, use assertions Disrupt parallel computations Exploit tools in the debugger (VC is good, purify) Check code that has recently changed Explain the bug to someone else Debug with a partner (A second pair of eyes) Take a break from the problem Get outside help (call people)

39. Game Architecture

40. 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

41. 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

42. 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

43. Ad-hoc

44. Modular

45. DAG

46. Layered

47. 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

48. 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

49. 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 0.017 second

50. Tasks of Main Game Loop Handling time Gathering player input Networking Simulation Collision detection and response Object updates Rendering Other miscellaneous tasks

52. Sample Game Loop

53. 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

54. 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