Introduction to Game Programming Autumn Game Programming Patterns and Techniques

Transcription

1 Introduction to Game Programming Autumn Game Programming Patterns and Techniques Juha Vihavainen University of Helsinki Background literature Erich Gamma et al. (1994), Design Patterns: Elements of Reusable Object-Oriented Software. Addison Wesley. The original source on design patterns. Vlissides John (1998), Pattern Hatching : Design Patterns Applied. Addison-Wesley. Eric Freeman (2004), Head First Design Patterns: A Brain- Friendly Guide. O'Reilly Media. Judith Bishop (2007), C# 3.0 Design Patterns. O Reilly Media. "An introduction to the classic object-oriented design patterns, and how to use C# to code them Robert Nystrom (2014), Game Programming Patterns. Genever Benning. "A book for programming in general, not just for games" Juha Vihavainen / University of Helsinki 2

2 Source of Design Patterns In software projects, we have concrete problems, e.g.: how to provide access to the elements of an aggregate without revealing any knowledge about its organization (impl.) how to represent a shared global resource as an object a way to provide for theundoing of actions how to provide a unified interface to a set of services Design patterns are solutions to such common problems (1) the name of the pattern, (2) the problem and its context (circumstances, forces) (3) the solution, often as a set of collaborating objects (4) the consequences (pros and cons) of using the pattern Provides vocabulary: identify, understand, document, communicate Plus: sample code, implementation tips, related patterns, actual systems ("at least two"), etc Juha Vihavainen / University of Helsinki 3 Classic Design Patterns (Gamma et al, 1994) + Typed Message [Vlissides, 1998]

3 Design patterns vs. idioms vs. frameworks (1) Idioms - describe techniques for expressing low-level, mostly language-dependent ideas (e.g., reference counts in C++) (2) Designpatterns - medium-scale, mostly language-independent abstractions (solution "ideas") usually depend on object-oriented mechanisms, and essential features can often be described with a simple UML class diagram (3) Software frameworks use patterns but consist of actual code with variant parts, into which the user can plug-in specific code to provide the required structure and behavior with their Hollywood principle: use callbacks for example, GUI libraries in object-oriented languages game engines, too Juha Vihavainen / University of Helsinki 5 The original uses a pointer variable to store the singleton object As a language-specific solution, use C++ static local variables class Singleton { public: static Singleton& instance ();... ;... // implementation file: Singleton& Singleton::instance () { // reference static Singleton instance; // created at first call of this routine return instance; Singleton (in C++) // and destructed after main Returns a reference: harder to destroy accidentally Need to disable constructors. In C#, can use a static class Juha Vihavainen / University of Helsinki 6

4 Goals of software development (Nystrom, 2014) We want a nice and clean architecture so the code is easier to understand over the lifetime of the project e.g., changes/updates and consequences should be local We want fast run-time performance We want to get today s features done quickly These goals are at least partially in opposition There is no one right answer, just different flavors of wrong (i.e., often many conflicting trade-offs) Use simplicity as a major decisive objective often less code means easier to understand and maintain notnecessarilyeasyto achieve (at thefirsttry) Juha Vihavainen / University of Helsinki 7 Game programming patterns by (Nystrom, 2014) I. Introduction On architecture, performance, and games (see the previous slide) II. Design Patterns revisited for game programming Command: a request as an object, to queue or to support undo Flyweight: share common immutable data with similar objects Observer: list of observers to be notified of changes Prototype: an archetypical instance cloned to produce new objects Singleton: only one single instance, and a way to access it State: an object alters its behavior by delegating requests to an object that represents its current state (and which can be replaced) Juha Vihavainen / University of Helsinki 8

5 Sequencing and behavioral game patterns III. Sequencing Patterns More: Coroutine pattern (p. 143); Pipeline pattern/architecture Game Loop: any game/engine for sequencing & timing tasks) Update Method: any game/engine for requesting updates) DoubleBuffer: used by GPU for its frame buffer IV. Behavioral Patterns More: Pipeline pattern/architecture (p.281)? Customized metaobject Bytecode: code as data, and scripting for flexible behaviour SubclassSandbox: define behavior in a subclass using a special set of protected operations provided by its base class TypeObject: an object stores a reference to a type object that describes its inherent (and usually invariant) shared characteristics (data and behaviour) replaces ( static ) class Juha Vihavainen / University of Helsinki 9 Decoupling and optimization game patterns V. Decoupling Patterns More: Hierarchical Machine (layered / multitier architecture); Model-View; Typedmessage Component: a game entity is a container of components, each one defined by its own component class (e.g., in Unity) Event Queue: decouple when an event is send and processed Service Locator: provide a global point of access to a service (w/o binding to a specific implementation class, or way of access) VI. Optimization Patterns More: Pipeline pattern/architecture (p.281) Data Locality: prefer contiguous memory blocks (for cache) Object Pool: reuse objects from a pool of (ready-made) instances Spatial Partition: store objects in a data structure organized by their positions; used for spatial queries, collision detection, and view frustum culling (here we utilize locality, too) Dirty Flag: use cached data until base data is marked changed (..) Juha Vihavainen / University of Helsinki 10

6 Using contiguous layout for Data Locality An optimization pattern for graphics, physics, and other computationally heavy stuff with lots of data Some relevant game data Cache-friendly contiguous memory block Pointer chasing : traversing links in a graph-like structure may cause lots of cache misses Update design pattern The game world maintains a collection of independent objects, and these objects or systems "run" logically simultaneously objects behaviours need to be simulated over time and are mostly independent Each object implements an update method that simulates one "frame" of the object s behavior, and for each frame, the game updates every object splitting code into single-frame slices often makes it more complex for each frame, we need to store states to resume where left off coroutines would help here Be careful of modifying shared data (e.g., the game object list) while processing and updating on it A variable time step means that each update () call needs to know the elapsed time, so often it is passed in as an argument - or can access a global clock Juha Vihavainen / University of Helsinki 12

7 Case: Unity engine and patterns Unity scripting is creating MonoBehaviour subclasses to define components for game objects Update operations implement any kind of game behavior and are always associated with Unity components A selection of Unity game programming patterns and idioms components in Unity how to access other game objects and components? prefabs in Unity (a version of the Prototype design pattern) Unity coroutine facility: an extension of Update pattern In Unity: scene = created level, project = available assets Juha Vihavainen / University of Helsinki 13 Unity game objects, components, variables Components are objects, too other game objects: parents and children Can be configuredat run time Physics materials a force slowing the movement of an object Other components: Camera, Audio Source/ Audio Listener E.g., a rigid body controls a game object's position via physics simulation: will react to gravity ("falls down"), and can strike and bounce off other objects (or at least "staying above the floor") Note. Allgame-specific variables and behaviours are defined via scripts and these are also attached to game objects as components Juha Vihavainen / University of Helsinki 14

8 Common Unity script idioms (C#) Accessing the game state of game objects, stored as parts of scripts GetComponent < ScriptId > ().variable = value; GetComponent < ScriptId > ().method (); other.getcomponent < ScriptId >().variable = v; target = anobject.getcomponent < ScriptId > (); // the same object // the same object // another object // cache the target pl = GameObject.FindWithTag ("Player").GetComponent<ScriptId> (); Scripting things to happen in the future: Invoke ("Method", 2.0f); InvokeRepeating ("Heal", 2.0f, 2.0f); void Start () { Destroy (gameobject, 5.0f); For alternative solutions can use Unity coroutines. Note. Names of game objects are not necessarily unique. // call in 2secs // call every 2 secs // will live only 5secs Juha Vihavainen / University of Helsinki 15 Unity prefabs (prefabrications) Prototypedesign pattern (Gamma et al., 1994): specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype Pros/cons? In Unity: A prefab ("ready-made object") is an object created in the scene and stored as an asset in the project, instantiated in Editor or at runtime a prefab is actually a reusableprototype game object to create a prefab, we drag a game object from the hierarchy view (or the scene view) into the project view can then be inserted multiple times into scenes; the instances (clones) are (at least initially) linked back to the original prefab so, making changes to the prototype causes changes to all its instances (unless the binding has been explicitly broken) Juha Vihavainen / University of Helsinki 16

9 (1) Manipulating prefabs in Unity Editor (IDE) To create a new prefab (for a Project), drag a game object in the scene view into the Project view (pane or onto some empty prefab) the game object (and all its children and relevant data) are copied into the prefab object (by Unity) the original game object can now be removed (usually) can appropriately rename the new prefab in the project view To manually create and place prefab instance into the initial scene, drag the prefab from the project view into the scene (or, alternatively, into the hierarchy view) In unity, sometimes refer to an object by the type of one of its scripts; likewise, may refer to a game object by its Transform/RigidBody component. Works OK since components uniquely determine their owner game object Juha Vihavainen / University of Helsinki 17 (2) Instantiating prefabs at run time Of course, we could create and carefully build all needed game objects from scratch using normal script code (e.g., factory methods) Prefabs are prebuilt game objects & their components that are as such reusable throughout the game (and for other games, too) In the UnityEditor: define a variable (say, bullet) in a script to contain a prefab drag the prefab from the project view onto that variable in the inspector In scripts, we can instantiate the prefab with one line of code: (prototypeobject, position, rotation) Instantiate (bullet, Vector3 (x, y, 0), Quaternion.identity); clones the original, places it at the given position, sets its rotation, and then returns the new instance Juha Vihavainen / University of Helsinki 18

10 Drag prefab to a variable, to be instantiated at run time E.g., in Shooter script, a prefab is stored in a variable bullet Juha Vihavainen / University of Helsinki 19 Background on C# iterators and coroutines (1) TheIterator design pattern: C#: var iterator = datasource.getenumerator (); while (iterator.movenext ()) process iterator.current; provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation (2) Coroutines are essentially like non-preemptive threads a coroutine must explicitly give over the execution turn But no stack later, the execution is continued at that same precise point & state C# provides a coroutine facility for its iterator abstraction so that the iteration over all elements can be written as one single routine = algorithm that yields the values one-by-one (in a loop):.. while(morevalues) { value :=producenext; yieldreturnvalue;.. yield return may appear anywhere in the method. May have multiple yield return statements in the method Juha Vihavainen / University of Helsinki 20

11 Iterators in C# Here s a simple example: public class MyCollection: IEnumerable { Producer int[] data = { 1, 2, 3 ; public IEnumerator GetEnumerator() { // a Factory method Consumer foreach(var i in data) yield return i; for more technical details, see: /IteratorBlockImplementation.aspx The actual iterator object A collection that has an iterator // iteration spec. that // generates special // CIL code Notice the "black magic": GetEnumerator doesn t seem to return an enumerator at all! Upon parsing the yield return statement, the compiler generates a (hidden nested state-driven) enumerator class, and modifies GetEnumerator to return an instance of that class. foreach(var i in new MyCollection()) Console.WriteLine(i); // means:.. while(it.movenext()) {.. it.current;.. // implicit Juha Vihavainen / University of Helsinki 21 Example: scripting a sequence of heavy tasks Consider the following Unity C# script, with actions spanning multiple subsequent frames (i.e., multi-frame) Need to check the current state using UnityEngine; using System.Collections; public class Example : MonoBehaviour // script component int state = 0; void Update () if (state == 0) // the current state of computation // called by the game loop // or can use a switch do some calculations; state = 1; // explicit state transfer return; if (state == 1) // resume others do more calculations; state = 2; return; Juha Vihavainen / University of Helsinki 22

12 Multi-frame sequence as a Unity coroutine We may implement the preceding with Unity coroutines using UnityEngine; using System.Collections; public class Example : MonoBehaviour { public int state = 0; IEnumerator MyCoroutine() { while (true) do some calculations;... yield return null; // means: pause until next frame do more calculations;... yield return null; // pause until next frame... A coroutine must be explicitly created and started (see next slide) Juha Vihavainen / University of Helsinki 23 Using coroutines (1/3) Update () is executed each frame (unless the game object is inactive or the script component is disabled) Unity uses the C#'s iterator/coroutine facility to implement multiframe-spanning coroutines for game objects (for their scripts) Now we can have different actions happening at any intervals May improve performance by executing logic as a coroutineless often than each frame, say only every five seconds coroutine private void Start () { StartCoroutine(Calculation ()); IEnumerator Calculation () { while (true) {... run my game logic; yield return new WaitForSeconds(5.0f); Note that it is a call A subclass of YieldInstruction, anything else is mostly ignored Unity calls MoveNext and inspects Current, and performs WaitForSeconds, i.e., doesn't call MoveNext until time has elapsed, etc Juha Vihavainen / University of Helsinki 24

13 Using coroutines (2/3) We can do long computations (AI decisions, path calculations) over several frames with coroutines A call, again void Awake () { StartCoroutine(Calculate ()); IEnumeratorCalculate () { create initial setup for computations; while(not finished) { dosomecalculations; // doherea partialtaskat a time yieldreturnnull; // 0 ornull: skipto thenextframe Debug.Log("Coroutine is completed"); enabled = false; // disable this script Note. Coroutines are always executed only after all the Update functions. Note. The C# yield break statement ends coroutine (e.g., inside a loop). The suspended coroutine is again called by Unity, in the next frame, and the loop continues Juha Vihavainen / University of Helsinki 25 Using coroutines (3/3) void Start () { StartCoroutine(Init()); IEnumerator Init() { Debug.Log("Initializing"); // first state yield return new WaitForSeconds(3.0f);... Debug.Log("Initialization completed"); // initial calculations StartCoroutine(Running()); // goto next state... IEnumerator Running() { Debug.Log("Running"); yield return new WaitForSeconds(5.0f);.. Debug.Log("Running completed"); StartCoroutine(GameOver()); //... "State machines" via coroutines technique/pattern/idiom // more calculations Like the State pattern but instead of a subobject changes active coroutine Juha Vihavainen / University of Helsinki 26