An Introduction to Game Programming with Flash: Design Patterns
1 like1,548 views
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.
An Introduction to Game Programming with Flash: Design Patterns
- 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
- 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
- 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
- 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