+ Typed Message [Vlissides, 1998]

Transcription

1 Background literature Introduction to Game Programming Autumn Game Programming Patterns and Techniques Juha Vihavainen University of Helsinki E. Gamma et al. (1994), Design Patterns: Elements of Reusable Object-Oriented Oriented Software. Addison Wesley. The original source on design patterns. Robert Nystrom (2014), Game Programming Patterns. Genever Benning. "A A book for programming in general, not just for games " 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 oriented design patterns, and how to use C# to code them" Juha Vihavainen / University of Helsinki 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 an implementation how to represent a shared global resource as an object a way to provide for the undoing 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,, usually as a set of collaborating objects (4) the consequences (pros and cons) of using the pattern 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]

2 Design patterns vs. idioms vs. frameworks (1) Idioms - describe techniques for expressing low-level, level, mostly language-dependent ideas (e.g., reference counts in C++) (2) Design patterns - medium-scale, mostly language-independent abstractions (solution "ideas") usually depend on object-oriented oriented mechanisms essential features can often be described with a simple UML class diagram (3) Software frameworks - consist of actual code with variant parts, into which the user can plug-in specific code to provide the required structure and behavior for example, GUI libraries in object-oriented oriented languages (with their Hollywood principle: : use callbacks) The original uses a pointer variable to store the singleton object As one alternative solution, can use C++ static local variables class Singleton { Singleton (in C++) public: static Singleton& instance (); // reference... ;... In C#, can use // implementation file: a static class Singleton& Singleton::instance () { static Singleton instance; // created at first call return instance; // and destructed after main Returns a reference: harder to destroy accidentally Juha Vihavainen / University of Helsinki Juha Vihavainen / University of Helsinki 6 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 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., many conflicting trade-offs) Use simplicity as a major decisive objective often less code means easier to understand and maintain not necessarily easy to achieve Juha Vihavainen / University of Helsinki 7 Game programming patterns by (Nystrom, 2014) I. Introduction On architecture, performance, and games II. Design Patterns revisited for game programming Command: : a request as an object, to queue, or support undo Flyweight: : share common data with similar objects Observer: : list of observers are notified of changes Prototype: : 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 Juha Vihavainen / University of Helsinki 8

3 Sequencing and behavioral game patterns III. Sequencing Patterns Double Buffer (used by GPU for its frame buffer) Game Loop (any game/engine for timing of tasks) Update Method (any game/engine for scheduling updates) IV. Behavioral Patterns Bytecode: : code as data, and scripting for flexible behaviour Subclass Sandbox: : define behavior in a subclass using a special set of protected operations provided by its base class Type Object: an object stores a reference to a type object that describes its inherent (and usually invariant) shared characteristics (data and behaviour) Juha Vihavainen / University of Helsinki 9 Decoupling and optimization game patterns V. Decoupling Patterns 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 (without binding to a specific implementation class or way of access) VI. Optimization Patterns Data Locality: : prefer contiguous memory blocks (for cache) Dirty Flag: defer work until new data are really needed 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 Juha Vihavainen / University of Helsinki 10 Game Loop design pattern (revisited) The main objective is to decouple the progression of game time both from user input and processor speed A game processes user input but doesn t wait for it while (true true) process input; update; render; Frame limiting eliminates the effect of a too-fast CPU speed Separate real time vs. game time to easily scale timing of physics & game logic Physics simulation need more frequent updates and fixed-time delays to achieve accuracy and avoid numerical instabilities need to run physics on its own, faster update loop When updates start lagging behind, use (limited) frame dropping Juha Vihavainen / University of Helsinki 11 Game Loop var phystimesum := 0.0, lasttime := 0.0, dropcount := 0; while game is running do sketch, only //... poll input and receive/deliver any messages... var time := Game.Time; // the wall-clock time var realdeltatime := time - lasttime; lasttime := time; phystimesum += realdeltatime; // accumulate the physics time while phystimesum >= Game.PhysDeltaTime do // play catch up physics steps PhysicsUpdate (Game.PhysDeltaTime * Game.TimeFactor); // fixed delta (?) phystimesum -= Game.PhysDeltaTime; // physics step time decrement for var obj : Updateable in Game.UpdateableObjects do // logic updates obj.update (realdeltatime * Game.TimeFactor); // generate output but only if have time left - or need to force one frame if realdeltatime < Game.TargetDelay or dropcount++ = DropLimit then Render (phystimesum/game.physdeltatime ); // interpolate the last update dropcount = 0; // reset draw-priority if realdeltatime < Game.TargetDelay then // frame limiting Game.Sleep (Game.TargetDelay - realdeltatime);

4 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 each frame, the game updates every object in the collection Splitting code into single-frame slices often makes it more complex For each frame, we need to store states to resume where left off 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 Using contiguous layout for Data Locality Some relevant game data Cache-friendly contiguous memory block Pointer chasing : traversing links in a graph-like structure may cause losts of cache misses Juha Vihavainen / University of Helsinki Juha Vihavainen / University of Helsinki 14 More on Unity scripting Refresh: Unity game objects, components, variables Unity scripting is creating MonoBehaviour subclasses A selection of Unity game programming idioms how to access other game objects and components? prefabs in Unity (a version of the Prototype design pattern) Unity coroutine facility Miscellaneous C# / Unity topics Juha Vihavainen / University of Helsinki 15 Physics materials a force slowing the movement of an object 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 that custom game-specific variables and behaviour are defined via scripts and are also attached to game objects as components Juha Vihavainen / University of Helsinki 16

5 Summary on Unity scripts A Unity game is programmed with scripts Unity scripting system is based on Mono,, an open-source version of.net ( ~ VM) Unity supports C# and UnityScript C# is well documented, is the kind of standard language for.net and Mono, and widely used UnityScript is a Unity dialect of Javascript, compiled into.net bytecode and native code Scripts are derived from MonoBehaviour,, a direct subclass of Behaviour ( => Component => Object = Unity's base class) Scripts are assets (and so put into the Project View), and must be attached to game objects as components (a script defines a class) Many scripts are provided as standard assets Juha Vihavainen / University of Helsinki 17 Some script-component component call-backs/events The Update () function runs every frame to implement logic/behavior The FixedUpdate () function runs as determined by the physics system, independently of frame rate (and more frequently); use for any physics calculations of your own The LateUpdate () function is called after all Update methods (e.g., actions for a 3rd-person camera are done last, after all other updates) The Awake () function is called when the script instance is being loaded; can use e.g. for "internal initialization" " of a component The Start () function is called just before any of the Update methods is called for the first time; e.g., "establish connections and relationships" The OnMouseDown () function is called when the user has pressed the mouse button while over the GUIElement or Collider The OnGUI () function is called for rendering & handling GUI events (called multiple times per a frame to handle GUI events) Juha Vihavainen / University of Helsinki 18 Most important Unity classes MonoBehaviour: : any kind of interactions or control over game objects and their components Transform represents the position, rotation and scale in space (whether 3D or 2D) plus the scene hierarchy; provides helper functions to move, scale, rotate, to organize and manipulate children, as well as converting coordinates from one space to another Rigidbody / Rigidbody2D The physics engine provides the tools for moving objects around, detecting triggers and collisions, and applying forces; to manage velocity, mass, drag, force, torque, collision, etc Juha Vihavainen / University of Helsinki 19 On physics General physics parameters settable in the editor via the Physics Manager (Edit->Project Settings->Physics) The y gravity value is 9.8 meters / second ^ 2 (one unit = 1 meter) Moving colliders need rigidbodies even if not affected by physics If an object is moved by animation or code, set as a kinematic rigidbody Physic materials determine surface properties, e.g, bouncing effects and friction (can use standard assets or create you own) OnMouseEnter,, raycasts, etc. work on colliders For further background and details, see Unity and NVIDIA PhysX documentation Juha Vihavainen / University of Helsinki 20

6 Common Unity script idioms Accessing the game state of game objects, stored as parts of scripts! GetComponent < ScriptId > ().variable = value; // the same object GetComponent < ScriptId > ().method (); // the same object other.getcomponent < ScriptId >().variable = v; // another object target = anobject.getcomponent < ScriptId >; // cache the target pl = GameObject.FindWithTag ("Player").GetComponent<ScriptId> (); Scripting things to happen in the future: Note. Names s of game objects are not necessarily unique. Invoke ("Method", 2.0f); // call in 2 secs InvokeRepeating ("Heal", 2.0f, 2.0f); // call every 2 secs void Start () { Destroy (gameobject, 5.0f); // will live only 5 secs For alternative solutions could use Unity coroutines Juha Vihavainen / University of Helsinki 21 Unity prefabs (prefabrications) Prototype design 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 first created in the scene and then stored in the project, to be instantiated in Editor or at runtime a prefab is a reusable prototype game object to create a prefab, we drag a game object from the game hierarchy view into the project view can 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 22 Manipulating prefabs 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 Drag prefab to a variable to be instantiated at run time E.g., in Shooter script, a prefab is stored in a variable bullet To create and place prefab instance in the current 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 Juha Vihavainen / University of Helsinki Juha Vihavainen / University of Helsinki 24

7 Instantiating prefabs at run time Of course, we could create and carefully build all needed game objects from scratch using normal script code (factory methods) Prefabs are prebuilt game objects & their components that are as such reusable throughout the game (and for other games, too) In the Unity Editor: 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 25 Background on C# iterators and coroutines (1) The Iterator design pattern: 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 later, the execution is continued at that same precise point & state C# provides a built-in in coroutine facility for its iterator abstraction the iteration over all elements can be written as one single routine = algorithm that yields the values one-by-one:.. while (more values) ) { value := produce next; ; yield return value; ;.. yield return may appear anywhere in the code. May have multiple yield return statements in a method Juha Vihavainen / University of Helsinki 26 Iterators in C# Here s a simple example: Producer public class MyCollection : IEnumerable { int [] data = { 1, 2, 3 ; Consumer for more technical details, see: /IteratorBlockImplementation.aspx The actual iterator object A collection that has an iterator public IEnumerator GetEnumerator () { // a Factory method foreach (var i in data) // iteration spec. that yield return i; // 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; Juha Vihavainen / University of Helsinki 27 Example: scripting a sequence of heavy tasks Consider the following C# script, with multi-frame actions using UnityEngine; using System.Collections; public class Example : MonoBehaviour int state = 0; // the current state of computation void Update () // called by the game loop if (state == 0) // or can use a switch do some calculations; ; state = 1; return; // resume others if (state == 1) do more calculations; ; state = 2; return; Juha Vihavainen / University of Helsinki 28

8 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; // pause until next frame do more calculations; ;... yield return null; // pause until next frame Juha Vihavainen / University of Helsinki 29 Unity's coroutines (1/2) Update () is executed each frame (unless the object is inactive or the script is disabled) Unity uses the C#'s iterator/coroutine facility to implement multi- frame-spanning coroutines for game objects (for their scripts) Can have different actions happening at different intervals May improve performance by executing logic as a coroutine less often than each frame, say only every five seconds Note that it is a call coroutine private void Start () { StartCoroutine (Calculation ()); IEnumerator Calculation () { A subclass of YieldInstruction, while (true) { anything else is mostly ignored... run game logic; yield return new WaitForSeconds (5.0f); 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 30 Unity's coroutines (2/2) We can do long computations (AI decisions, path calculations) over several frames with coroutines A call, again void Awake () { StartCoroutine (Calculate ()); IEnumerator Calculate () { create initial setup for computations; while (not finished) ) { Note. The yield break statement ends coroutine (e.g., inside the loop). do some calculations; // do here a partial task at a time yield return null; // 0 or null: skip to the next frame The suspended Debug.Log ("Coroutine is completed"); coroutine is again enabled = false; // disable this script called by Unity, in the next frame. Note.. Coroutines are executed only after all the Update functions Juha Vihavainen / University of Helsinki 31 "State machines" via coroutines technique void Start () { StartCoroutine (Init ());); // start state IEnumerator Init () { Debug.Log ("Initializing"); yield return new WaitForSeconds (3.0f);... Debug.Log ("Initialization completed"); StartCoroutine (Running ()); // goto next state... IEnumerator Running () { Debug.Log ("Running"); yield return new WaitForSeconds (5.0f);... Debug.Log ("Running completed"); StartCoroutine (GameOver ()); //... etc Juha Vihavainen / University of Helsinki 32