Game architecture is different

Game architecture is different

try { harder } conference 2011 ©Richard Lord 2011 - www.richardlord.net

Is game architecture different?


Asteroids


Conclusion:
Entity systems are better


Why?


Code statistics

Entities (Ember) MVC (Robotlegs)
38 classes 30 classes
1047 lines of code 1092 lines of code
26710 characters of code 25915 characters of code


Robotlegs Mediators
Model Commands AsteroidsMediator

SpaceshipMediator
GameState CreateAsteroid
AsteroidMediator
GameSize CreateBullet
BulletMediator
Spaceship CreateSpaceship

SpaceshipContainer RouteInput Views
Asteroid StartGame
Asteroids
AsteroidContainer StartGame
SpaceshipView
Bullet Update
AsteroidView
BulletContainer
BulletView


Ember
Components
Nodes Systems (Processes)
Spaceship
MotionControlNode ProcessManager
Asteroid
GunControlNode GameManager
Views
Gun
BulletAgeNode MotionControlSystem SpaceshipView
Bullet
MovementNode GunControlSystem AsteroidView
GameState
SpaceshipCollisionNode BulletAgeSystem BulletView
Position
AsteroidCollisionNode MovementSystem
Motion
BulletCollisionNode CollisionSystem
Display
RenderNode RendersSystem
MotionControls

GunControls

Evolution of entity systems


The game loop


function update( time:Number ):void
{
game.update( time );
spaceship.updateInputs( time );
for each( var flyingSaucer:FlyingSaucer in flyingSaucers )
flyingSaucer.updateAI( time );
spaceship.update( time );
flyingSaucer.update( time );
for each( var asteroid:Asteroid in asteroids )
asteroid.update( time );
for each( var bullet:Bullet in bullets )
bullet.update( time );
collisionManager.update( time );
spaceship.render();
flyingSaucer.render();
asteroid.render();
bullet.render();
try { harder } conference 2011 } ©Richard Lord 2011 - www.richardlord.net

Processes & Process Manager


interface IProcess
{
function start():Boolean;
function update( time:Number ):void;
function end():void;
}


class ProcessManager
{
private var processes:PrioritisedList;

public function addProcess( process:IProcess, priority:int ):Boolean {
if( process.start() ) {
processes.add( process, priority );
return true;
}
return false;
}

public function update( time:Number ):void {
for each( var process:IProcess in processes )
process.update( time );
}

public function removeProcess( process:IProcess ):void {
process.end();
processes.remove( process );
}
try { harder } conference 2011
} ©Richard Lord 2011 - www.richardlord.net

class RenderProcess implements iProcess
{
spaceship.render();
flyingSaucer.render();
asteroid.render();
bullet.render();
}
}


interface IRenderable
{
function render();
}

class RenderProcess implements IProcess
{
private var targets:Vector.<IRenderable>;

for each( var target:IRenderable in targets )
target.render();
}
}


class Spaceship implements IRenderable
{
public var view:DisplayObject;
public var position:Point;
public var rotation:Number;

public function render():void {
view.x = position.x;
view.y = position.y;
view.rotation = rotation;
}
}


class Renderable implements IRenderable
{
public var view:DisplayObject;

view.x = position.x;
view.y = position.y;
view.rotation = rotation;
}
}

class Spaceship extends Renderable
{
}


Renderable

Spaceship FlyingSaucer Asteroid Bullet


interface IMoveable
{
function move();
}

class MoveProcess implements IProcess
{
private var targets:Vector.<IMoveable>;

for each( var target:IMoveable in targets )
target.move( time );
}
}


class Moveable implements IMoveable
{
public var velocity:Point;
public var angularVelocity:Number;

public function move( time:Number ):void {
position.x += velocity.x * time;
position.y += velocity.y * time;
rotation += angularVelocity * time;
}
}

class Spaceship extends Moveable
{
}


class Moveable extends Renderable implements IMoveable
{
// public var position:Point;
// public var rotation:Number;
public var velocity:Point;

position.x += velocity.x * time;
position.y += velocity.y * time;
rotation += angularVelocity * time;
}
}

class Spaceship extends Moveable
{
}


Renderable

Moveable



Moveable Renderable



class Renderable implements IRenderable class Moveable implements IMoveable
{ {
public var view:DisplayObject; public var position:Point;
public var position:Point; public var rotation:Number;
public var rotation:Number; public var velocity:Point;
view.x = position.x; public function move( time:Number ):void {
view.y = position.y; position.x += velocity.x * time;
view.rotation = rotation; position.y += velocity.y * time;
} rotation += angularVelocity * time;
} }
}

class Spaceship
{
public var renderData:IRenderable;
public var moveData:IMoveable;
}

interface IRenderable interface IMoveable
{ {
function render(); function move();
} }

class RenderProcess implements IProcess class MoveProcess implements IProcess
{ {
private var targets:Vector.<IRenderable>; private var targets:Vector.<IMoveable>;

public function update(time:Number):void{ public function update(time:Number):void {
for each(var target:IRenderable in targets) for each(var target:IMoveable in targets)
target.render(); target.move( time );
} }
} }


public function createSpaceship( time:Number ):Spaceship {
var spaceship:Spaceship = new Spaceship();
...
renderProcess.addItem( spaceship.renderData );
moveProcess.addItem( spaceship.moveData );
...
return spaceship;
}


class Renderable implements IRenderable class Moveable implements IMoveable
{ {
public var display:DisplayComponent; public var position:PositionComponent;
public var position:PositionComponent; public var velocity:VelocityComponent;

public function render():void { public function move( time:Number ):void {
display.view.x = position.x; position.x += velocity.velocityX * time;
display.view.y = position.y; position.y += velocity.velocityY * time;
display.view.rotation position.rotation
= position.rotation; += velocity.angularVelocity * time;
} }
} }

class DisplayComponent { class VelocityComponent {
public var view:DisplayObject; public var velocityX:Number;
} public var velocityY:Number;
class PositionComponent {
}
public var x:Number;
public var y:Number;
try { harder } conference 2011
} ©Richard Lord 2011 - www.richardlord.net

class Spaceship
{
public function Spaceship() {
moveData = new MoveData( new PositionComponent(), new VelocityComponent() );
renderData = new RenderData( new DisplayComponent(), moveData.position );
}
}


class Renderable implements IRenderable
{
public var display:DisplayComponent;
public var position:PositionComponent;

display.view.x = position.x;
display.view.y = position.y;
display.view.rotation = position.rotation;
}
}

{
private var targets:Vector.<IRenderable>;

for each( var target:IRenderable in targets )
target.render();
}
}

class RenderData
{
}

{
private var targets:Vector.<RenderData>;

for each( var target:RenderData in targets ) {
target.display.view.x = target.position.x;
target.display.view.y = target.position.y;
target.display.view.rotation = target.position.rotation;
}
}
}

class Moveable implements IMoveable
{
public var velocity:VelocityComponent;

position.x += velocity.velocityX * time;
position.y += velocity.velocityY * time;
position.rotation += velocity.angularVelocity * time;
}
}

{
private var targets:Vector.<IMoveable>;

for each( var target:Moveable in targets )
target.move( time );
}
}

class MoveData
{
}

{
private var targets:Vector.<MoveData>;

for each( var target:MoveData in targets ) {
target.position.x += target.velocity.velocityX * time;
target.position.y += target.velocity.velocityY * time;
target.position.rotation += target.velocity.angularVelocity * time;
}
}
}

class Spaceship {
public var renderData:RenderData;
public var moveData:MoveData;
}


class Spaceship {
public var renderData:RenderData; class RenderData {
public var moveData:MoveData; public var display:DisplayComponent;
} public var position:PositionComponent;
}
class MoveData {
}


class Spaceship {
}
class MoveData {
public var position:PositionComponent; class DisplayComponent {
public var velocity:VelocityComponent; public var view:DisplayObject;
} }

class VelocityComponent { class PositionComponent {
public var velocityX:Number; public var x:Number;
public var velocityY:Number; public var y:Number;
public var angularVelocity:Number; public var rotation:Number;
} }


class Spaceship {
}
class MoveData {
public var position:PositionComponent; class DisplayComponent {
public var velocity:VelocityComponent; public var view:DisplayObject;
} }

} }

class RenderProcess implements IProcess {
class MoveProcess implements IProcess { private var targets:Vector.<RenderData>;
private var targets:Vector.<MoveData>; }
}

class Spaceship {
public var display:DisplayComponent; class DisplayComponent {
public var position:PositionComponent; public var view:DisplayObject;
public var velocity:VelocityComponent; }
}
} }

class RenderData {
class MoveData {
}
}

class RenderProcess implements IProcess {
class MoveProcess implements IProcess { private var targets:Vector.<RenderData>;
private var targets:Vector.<MoveData>; }
}

class Entity { class DisplayComponent {
public var data:Array; public var view:DisplayObject;
} }

class PositionComponent {
public var x:Number;
class VelocityComponent { public var y:Number;
public var velocityX:Number; public var rotation:Number;
public var velocityY:Number; }
} class RenderData {
class MoveData { }
}

class MoveProcess implements IProcess { class RenderProcess implements IProcess {
private var targets:Vector.<MoveData>; private var targets:Vector.<RenderData>;
} }


Entity systems are better
(for games driven by a game loop)


And now I've run out of stuff to say


Game architecture is different

Recomendados

Recomendados

Más contenido relacionado

Último

Último (20)

Destacado

Destacado (20)

Game architecture is different