When i open the example from googleCode. I see actually brackets with codes.
However here they are left out.

Im typing all this stuff over for learning purposes, so I’m confused right now.

I did i missed something i should have read?

greetings,
Sidar

“So say you have two different methods of collision detection. One is for objects moving along a straight path, and one is for objects moving along a sinusoid.”

…I had meant to say:

“So say you have two different methods of collision detection. One is for circular objects, and one is for concave polygon objects.”

Very good question. In response:

1. “Favour composition over inheritance.”
2. “Build to interfaces, not implementations.”

1. We make use of the “Single Responsibility Principle”: A class (and thus it’s instances) has one and only one responsibility. So you create a class Collidable that deals solely with collision detection, and you create a class Living that contains functionality solely pertinent to measuring life remaining. Now you create a third class which is the Entity, and at runtime it instantiates Collidable and Living, and holds references to them. It calls them at the appropriate times to deal with the appropriate logic. So you can see that we are *composing* the object, rather than deriving it’s functionality through inheritance.

2. Interfaces describe the *services which a class provides*, rather than how you implement those services. So say you have two different methods of collision detection. One is for objects moving along a straight path, and one is for objects moving along a sinusoid.
So, let’s say you implement an interface ICollidable (from which your class Collidable will extend) which accurately describes the services a “collision-detectable object” would expose, eg. “checkMyCollisionWith(someOtherObject)”. You can now split your Collidable implementation into two: One that manages collisions for object which need only simple collision detection, and another for objects which require more advanced collision detection (eg. for concave polygons).

This is useful because it means that, at runtime, you can dynamically decide how to compose your object… rather than using inheritance, because inheritance leads to an inflexible hierarchy, as you have realised. This is particularly true in ActionScript, because multiple inheritance is not supported. So you can use the same skeleton, Entity, for all your entities, but you can dynamically decide how to create each individual one according to it’s type, eg. player, AI-controlled, static objects, etc.

DISCLAIMER: The Gang of Four (Gamma, Helm, Johnson, Vlissides) claimed that one should always “Favour composition over inheritance”, but this is not quite true, and they later admitted as much. There are many cases (this article is a perfect example) where it is 100% the best way to go. But in many cases, inheritance is a lot more logical. Example: I’ve recently built a pseudo-3D rendering engine. At each step down the inheritance chain I have extended the functionality a little bit more. So I start out with an abstract renderer, I extend it to a 2d (flat) renderer, and then extend it further to my pseudo3D (perspective-based) renderer. This works because there is no branching of the inheritance chain — just three different classes, each of which does a little more than it’s parent class.

Best regards,

-Nick

public class Unit extends MovingEntity
{
public var maxHealth:Number;
public var health:Number;
public var maxMana:Number;
public var mana:Number;
public var attackPower:Number;

public function Unit( a_params:UnitParams ) : void
{
health = maxHealth = a_params.maxHealth;
_mana = maxMana = a_params.maxMana;
attackPower = a_params.attackPower;
m_armorType = a_params.armorType;
m_armorTable = a_params.armorTable;
}
public function doDamage( a_value:Number ) : void
{
health -= a_value * m_armorTable[ armorType ];
}

private var m_armorType:String;
private var m_armorTable:Dictionary;
}

So now you can use the health properties etc of Unit, and still do the movement of it such as unit.x += SOME_NUMBER;