View
240
Download
0
Category
Preview:
Citation preview
Object Oriented Analysis & Design
Game Patterns
2
Contents What patterns are Delegation Game Loop Scene Graph Double Buffering Component Object Pool Singleton Decorator Observer Factory Method Decorator Composite
3
What Patterns Are Patterns are good solutions to common
problems Patterns are NOT code
Patterns are ideas about how to solve a problem They are general solutions to a group of closely
related problems Patterns are well-known solutions to problems
You would discover most patterns yourself... eventually
4
Delegation A delegate is someone who you ask to perform a job on
your behalf In programming, a delegate is an object that performs
the work of another object
class Delegator {private:
Delegate *delegate;public:
void doSomething() {delegate->doSomething();
}}
5
Delegation Delegation allows you to change what
doSomething() does by Changing the delegator object
You could create a subclass of Delagator and override doSomething() but You have to create an instance of Degator or
Delegate In order to change the behaviour, you have to
destroy one object and create a new one If you want to add new behaviour, you must derive
a new subclass and code the logic to use this into your game
6
Delegation By using delegation
You can alter behaviour any time by changing the delegate
You can create and use a new delegate any time without changing the code in the delegator
Delegation is more flexible than subclassing Subclassing has early binding
The functionality is bound to the class at compile time
Delegation allows for later binding time The functionality is bound to the delegator at run
time Late binding allows for far more flexibility
7
Game Loop Description
A way to structure games that render frame-by-frame with movement calculated between frames.
Motivation Games involve
handling user input Performing the game logic Rendering the game
It was recognized that this was common to all games and that there was a common way to architect all games
8
Game Loop Solution
Create a loop that repetitively performs the operations in rendering a frame in a game
while(keepRendering){
getUserInput();updateScene();renderFrame();
}
9
Game Loop
10
Scene Graph Description
An organized technique to represent all objects in a scene to make it easier to render the scene
Motivation As games become more complex, the number of
objects grows This makes the rendering of the scene more
difficult It makes sense to automate the rendering of the
scene
11
Scene Graph Solution
Create a data structure which will store A reference to every object in the scene The position, orientation and scale factor of every object
The game loop will now update the position and orientation of objects in the scene graph
The game engine can render the scene by Traversing the scene graph Rendering every object at the indicated position,
orientation and scale
12
Scene Graph Implementation
For a tile-based game The graph could be stored as a 2D array of objects The engine would traverse the array, drawing objects in
the correct position, orientation, and scale
For a non-tile based game or one with complex objects Use a graph structure Each node has
A position, orientation and scale A list of objects at that position A list of child nodes whose position, orientation and scale
are relative to that of the parent node
13
Scene Graph
14
Double Buffering Description
Smooth graphics can be displayed by drawing the frame into an off-screen buffer and swapping it with the frame buffer when the drawing is complete.
Motivation When graphics are drawn directly to the screen
buffer The screen is refreshed before the frame is completely
drawn The screen appears to flicked to the user This is because the user is seeing part of one frame and
part of the next
15
Double Buffering Solution
The solution is to use 2 buffers 1 that is rendered onto the screen 1 into which the next scene is rendered
When the scene is rendered The pointers to the 2 buffers are swapped The next screen refresh will show the new scene The old screen buffer is ready for the next scene to be
rendered into it
16
Implementation Most modern graphics systems have
automated support for double buffering Usually, you just configure your graphics
system to use double buffering
17
Component Description
Complex behaviour of an object is spread over several classes so that a change in one behaviour does not require a change in other behaviour. This also allows common behaviour to be shared among objects.
Motivation When creating a game object it is common to
Place AI logic in the class Place rendering logic in the class Place physics calculations in the class Place update logic in the class
This results in Overly complex classes The combination of separate logic
18
Component Solution
Separate each responsibility into a separate class Build the game object so it refers to the classes
representing each responsibility This has the benefits
The logic for each responsibility is separated Several game objects can now share common
behaviour by referencing the same behaviour class
You can change the logic in one behaviour class without affecting the other behaviour classes
19
Component
20
Object Pool Description
An object pool holds a collection of objects which are expensive to create and destroy.
The pool allows objects to be used and then returned to the pool when they are no longer required. The next time an object is needed, it is take from the pool for use.
Motivation The constant creation and destruction of objects is
a very costly series of operations. When this involves large numbers of objects, as in
a particle system, this can waste a lot of time.
21
Object Pool Solution
Create a pool which will create a large number of objects
Track the objects which are in use and the ones not in use
Provide operations To retrieve an object not in use from the pool To return an object to the pool and mark it available
One of the design goals will be to manage the retrieval and return of objects from and to the pool as efficient as possible
We also need the class stored in the pool to provide a method to allow the objects to be initialized before use
22
Object Pool
23
Object Pool Implementation
24
Singleton Description
Restricting a class so that only one instance of the class can be created
Motivation Many classes only require one instance and more
than that will cause problems for the game. Consider: One game engine One scene graph
We need a way to ensure that only one instance of these classes can be created
25
Singleton Solution
Make the class constructor private Declare a static pointer to the single instance
initialized to NULL. Declare a static method getInstance() which will
build an instance if there is none or return the existing instance if there is one
26
Singleton Implementation
class Singleton {
private:static Singleton *theInstance;Singleton() { ... }public:static Singleton* getInstance() {if(! theInstance) theInstance = new Singleton();return theInstance;}
}
27
Decorator Description
Allows visual decorations to be added or removed from a game object without deleting and recreating the game object
Motivation During a game, the visual appearance of objects
will change A character might appear different due to a power-up A character might glow as a result of a spell
We want to be able to add / remove these decorations Without destroying the original object Without changing the type of the reference to the
original object
28
Decorator Solution
The solution is to Create the GameObject class Make GameDecorator a subclass of GameObject Add a pointer to GameObject within GameDecorator Override the methods in GameDecorator to call the
same methods on the GameObject the decorator has a pointer to
29
Decorator
30
Decoratorclass GameObject {public:
void doSomething() {// code to do something }
void render(){ // code to render game object }
GameObject& decorate(GameObject decoratee&){ return *this;}
GameObject& undecorate() { return *this; }
}
31
Decoratorclass GameDecorator: public GameObject {private:
GameObject *decoratedObject;public:
void doSomething() {decoratedObject->doSomething(); }
void render() { decoratedObject->render();// code to render game object }
GameObject& decorate(GameObject decoratee&) { decoratedObject = &decoratee; return *this;}
GameObject& undecorate() { return *decoratedObject;}
}
32
Decorator
Recommended