The document discusses several design patterns that are useful for game programming with Flash, including Singleton, Object Pool, Strategy, and Command patterns. It provides examples of how each pattern can be implemented and used, such as the Singleton pattern to store configuration in a single instance, the Object Pool pattern to reuse enemy objects, the Strategy pattern to allow changing an enemy's movement algorithm at runtime, and the Command pattern to encapsulate method calls like playing explosion animations.

1. An Introducton to Game
Programming with Flash
3: Design Patterns

2. Design Patterns
Characteristc
● Universal solutons of common, repeatng problems
● Descripton of a soluton, not an implementaton
● Mainly depends on OOP paradigm
Pros
● Standardises nomenclature
● Standardises structure
● Independent from programming language

3. Design Patterns
● Creatonal
● Builder
● Abstract Factory
● Factory Method
● Singleton
● Object Pool
● Structural
● Decorator
● Adapter
● Bridge
● Behavioural
● Command
● Mediator
● Strategy
● Architectural
● Model-View-Controller

4. Singleton Pattern
● Guarantees creatng only single instance of a class
● Doesn't pollute global namespace
● Overused and treated as new global
● Often used to store configuraton
● Alternatve: Dependency Injecton

5. Singleton Pattern

6. package foo
{
public class Singleton
{
private static var instance:Singleton;
public function Singleton()
{
}
public static function getInstance():Singleton
{
if (!instance)
{
instance = new Singleton();
}
return instance;
}
}
}
1
2
3
Singleton Pattern

7. import foo.Singleton;
var singleton:Singleton = Singleton.getInstance();1
Singleton Pattern

8. Object Pool Pattern
● Creates set of objects ready to use rather then
creatng/removing objects
● Used when creatng new objects is expensive
● You must remember about pool's limit

9. Object Pool Pattern

10. package foo
{
public class EnemyPool
{
private var enemies:Vector.<Enemy>;
public function EnemyPool(count:int)
{
enemies = new Vector.<Enemy>();
while(--count >= 0)
{
enemies.push(new Enemy());
}
}
public function getEnemy():Enemy
{
return enemies.pop();
}
public function returnEnemy(enemy:Enemy):void
{
enemies.push(enemy)
}
}
}
2
3
Object Pool Pattern
1

11. import foo.EnemyPool;
var pool:EnemyPool = new EnemyPool(20);
var enemy:Enemy = pool.getEnemy();
//when we don't need this enemy anymore
pool.returnEnemy(enemy);
2
3
Object Pool Pattern
1

12. Strategy Pattern
● Defines a group of algorithms ready to use
● Allows to change algorithms on runtme
● Helps in proper encapsulaton

13. Strategy Pattern

14. package foo
{
public class Enemy
{
private var moveStrategy:IMoveStrategy;
public function Enemy(movingStrategy:IMoveStrategy)
{
this.moveStrategy = moveStrategy
}
public function update():void
{
moveStrategy.execute(this);
}
}
}
1
Strategy Pattern
3
2

15. var enemy:Enemy = new Enemy(new FastMoveStrategy());
enemy.move();
1
Strategy Pattern

16. Command Pattern
● Encapsulates all data needed to method invocaton later on
● Single Responsibility Principle
● Fire and Forget
● Commonly used for mult-level undo

17. Command Pattern

18. package foo
{
public class CreateEnemyCommand implements ICommand
{
public function execute():void
{
//add enemy & play sound here
}
}
}
1
Command Pattern

19. import foo.CreateNewEnemyCommand;
var command:ICommand = new CreateEnemyCommand();
command.execute();1
Command Pattern

20. Jet&Giant

21. git clone git://github.com/krzysztof-o/epi-
wdpg.git
Jet&Giant

22. Task 1
Game model:
● Create GameModel singleton class responsible for
storing game data:
● Enemies and bullets
● Game object reference
● Giant object reference
enemies bullets game
lives
giant

23. Task 2
Bullet Pool:
● Create pool of 50 bullets using Object Pool Pattern
BulletPool

24. Task 3
Enemies' movement:
● Create strategies FastMoveStrategy and SineWaveMoveStrategy
responsible for moving enemies
enemy_1 enemy_2

25. Task 4
Explosion animaton:
● Create command PlayBoomCommand
● Invoke command with dispatched Event