Object Composition and Aggregation

Rem
bmax composition example
written by: AlexO (Testing code by ZFP)
End Rem

Global time:Int

Global playerlist:TList = New TList
Global i:Int

' lets make an object that has physics, AND can be controlled by our player.
Print "Adding 1000000 Component Objects"
timer()
For i = 1 To 1000000
Local myPlayer:TBaseObject = TBaseObject.Create("Robot", 40, 40)
'...now to give our new empty object physics and controls we simply add the functionality to them
myPlayer.AddComponent(New TPhysicsComponent)
myPlayer.AddComponent(New TControllerComponent)
myPlayer.Init()
playerlist.addlast(myplayer)
Next
timer()

Print "Doing 1000000 updates"
timer()
For myplayer = EachIn playerlist
myPlayer.Update()
Next
timer()



' now lets make a bullet with laser flight
Local myBullet:TBaseObject = TBaseObject.Create("Laser", 30, 30)
myBullet.AddComponent(New TLaserComponent)
myBullet.AddComponent(New TCollisionComponent) 
myBullet.Init()

myBullet.Update()
' and so on...


Rem
this is our 'container' class.
it provides very basic functionality that we 
determine every 'object' should have.
in this example I've only determined
that each 'object type' should have a name and position
end rem
Type TBaseObject
	Field _name:String
	Field _components:TMap = CreateMap()
	Field _x:Float
	Field _y:Float
	
	' factory method to help create a base object.
	Function Create:TBaseObject(name:String, x:Float, y:Float)
		Local obj:TBaseObject = New TBaseObject
		obj._name = name
		obj._x = x
		obj._y = y
		Return obj
	End Function
	
	' some basic setters/getters
	Method SetPosition(x:Float, y:Float)
		_x = x
		_y = y
	End Method
	
	Method GetX:Float()
		Return _x
	End Method
	
	Method GetY:Float()
		Return _y
	End Method
	
	Method GetName:String()
		Return _name
	End Method
	
	' to provide some coherency
	' we'll add an init() function
	' that we call once all the components
	' for an object have been added
	' and wish to initialize themselves
	Method Init()
		For Local comp:TComponent = EachIn _components.Values()
			comp._OnAdd(Self)
		Next
	End Method
	
	' our update function becomes
	' simplified for this object
	' since all the functionality
	' is tucked away in it's components.
	Method Update()
		For Local comp:TComponent = EachIn _components.Values()
			comp.Update()
		Next
	End Method
	
	' this allows use to search for a particular component
	' and functionality based on name. Since it is 
	' using a tmap, retrevial is fast compared to a linked list.
	' the only downside is 'update' order is not easily determined. a trade-off
	' but could be solved with a more complex solution.
	Method GetComponent:TComponent(componentName:String)
		If _components.Contains(componentName) Then
			Return TComponent(_components.ValueForKey(componentName))
		End If
		Return Null
	End Method
	
	' this adds a new type of component
	' to this object. In this implementation
	'you cannot add, for instance, 2 physics components, as it doesn't make much sense
	Method AddComponent(component:TComponent)
		If Not _components.Contains(component.GetType()) Then
			_components.Insert(component.GetType(), component)
		End If
	End Method
End Type


Rem
our base component class.
each component class _must_ have a way of identifying what type 
of component it is. For this example we will just use a 'type' string. 
This isn't the most 'strongly' typed way to do it, but for simplicity
it will do.
end rem
Type TComponent Abstract
	Field _owner:TBaseObject
	Field _type:String
	
	Method New ()
		_type = "TComponent"
	End Method
	
	Method GetOwner:TBaseObject()
		Return _owner
	End Method
	
	Method GetType:String()
		Return _type
	End Method
	
	Method SetType(typeName:String)
		_type = typeName
	End Method
	
	
	Method OnAdd(owner:TBaseObject) Abstract
	Method OnRemove() Abstract
	Method Update() Abstract
	
	Rem
	this is consider an 'internal' method
	used only by our base component class to help facilitate the aggregation
	end rem
	Method _OnAdd(owner:TBaseObject)
		_owner = owner
		OnAdd(owner)
	End Method
	
	Rem
	another internal method to help facilitate the component structure
	end rem
	Method _OnRemove()
		_owner = Null
		OnRemove()
	End Method
End Type


'now we will define some custom components to give our container object
' some usability.


' a basic physics component could encapsulate the physics calculations
' and formulas needed to do simulations.
Type TPhysicsComponent Extends TComponent
	Field _velx:Float
	Field _vely:Float
	
	Method New ()
		SetType("TPhysicsComponent")
	End Method
	
	Method OnAdd(owner:TBaseObject)
		' sometimes a component may want to query for other components
		' in the owner to gain access to other data if there are dependencies.
	End Method
	
	Method OnRemove()
		
	End Method
	
	' a trivial example for 'physics' functionality.
	Method Update()
		Local owner:TBaseObject = Self.GetOwner()
		Local x:Float = _velx + 3
		Local y:Float = _vely + 3
		owner.SetPosition(x, y)
		'Print "physics update!"
	End Method
End Type

'one interesting separation to think about is between physics calculations, and collision calculations.
' both are needed for physics simulations. but say you did not want to run physics on an object but wanted to see when it hit something to
' do some other non-physics related action? adding this component allows you to collide this object against others who have collision components installed.
Type TCollisionComponent Extends TComponent

	Method New ()
		SetType("TCollisionComponent")
		
	End Method
	
	Method OnAdd(owner:TBaseObject)
		
	End Method
	
	Method OnRemove()
		
	End Method
	
	Method Update()
		'Print "collision update!"
	End Method
End Type

' now another powerful use is if you wish to encapsulate different AI/input behaviors, you can do so by making separate components.

' a basic controler behavior that could attached.
Type TControllerComponent Extends TComponent
	
	Field _physics:TPhysicsComponent
	
	Method New ()
		SetType("TRobotAIComponent")
	End Method
	
	Method OnAdd(owner:TBaseObject)
		'lets say for example this controller type needs to know the object's velocity to function. lets query for it:
		_physics = TPhysicsComponent(owner.GetComponent("TPhysicsComponent"))
		' now the above is not ideal if you wish to decouple your components. for more information on a solution that'll 
		' solve that look into Data ports:
		' http://www.gamasutra.com/view/feature/1779/implementing_dataports.php
		' these can be easily adapted to the component architecture where the 'baseObject' object is it's own
		' individual data port manager, and components and register/read/write to it's owner's data ports.
	End Method
	
	Method OnRemove()
		
	End Method
	
	Method Update()
		'Print "controller update!"
	End Method
End Type


'lets say your game character can pick up items and store them. this component adds that functionality, by working together
' with the 'collision' component to see if we collided with some type of object. then we can handle the object internally.
Type TInventoryComponent Extends TComponent

	Method New ()
		SetType("TInventoryComponent")
	End Method
	
	Method OnAdd(owner:TBaseObject)
		
	End Method
	
	Method OnRemove()
		
	End Method
	
	Method Update()
		
	End Method
End Type


'what if you have different bullets and wish to have different flight behaviors for each type of bullet?
Type TLaserComponent Extends TComponent
	Method New ()
		SetType("TLaserComponent")
	End Method
	
	Method OnAdd(owner:TBaseObject)
		
	End Method
	
	Method OnRemove()
		
	End Method
	
	Method Update()
		'Print "laser!"
	End Method
End Type

Function timer()
	If time > 0 
		Print "Millisecs elapsed since last call:" + ( MilliSecs()-time)
		time = 0
	Else time = MilliSecs()
	EndIf
End Function

	Method GetComponent:TComponent(componentName:String)
		If _components.Contains(componentName) Then
			Return TComponent(_components.ValueForKey(componentName))
		End If
		Return Null
	End Method
	
	Method AddComponent(component:TComponent)
		If Not _components.Contains(component.GetType()) Then
			_components.Insert(component.GetType(), component)
		End If
	End Method

	Method GetComponent:TComponent(componentName:String)
		Return TComponent(_components.ValueForKey(componentName))
	End Method
	
	Method AddComponent(component:TComponent)
		_components.Insert(component.GetType(), component)
	End Method

Type blubb
...
End Type

Type bla
  field parent:blubb

  Method Run:int(paramParent:blubb)
    paramParent.do()
  End Method

  Method Run2:int()
    parent.do()
  End Method
End Type