Introduce
This article is an abstract of a chapter of iOS Swift Game Development Cookbook. The main content is about two ways to lay out the architecture of the game:
- Inheritance-Based
- Component-Based
It is important to find out a best layout for your own game project; because an appropriate architecture will make your works more reasonable and flexible.
Before determine which way should be used, it is better to insight into both Inheritance-Based and Component-Based Game Layout.
Inheritance-Based
In this mode, a class of game objects is needed. All the others classes of your game objects should inherit this base class and add extra functionality according to their needs.
example:
First, define a class called GameObject:
class GameObject:NSObject {
func update(deltaTime: Float){
//do some thing
}
}
When you need to create a new kind of game object, just create a subclass of GameObject class, which inherits all of the behavior of its superclass and can be customized:
class Monster: GameObject {
var hitPoints : Int = 10 // how much health we have
var target : GameObject? // the game object we're attacking
override func update(deltaTime: Float) {
super.update(deltaTime)
// Do some monster-specific updating
}
}
Component-Based
This is a mode that any game object class contains a series of component classes for implementing its features and functionalities.
example:
First, define a Component class. This class represents components that are attached to game objects. And it is a very simple class that, at least initially, just defines a update:method and an instance of GameObject.
class Component: NSObject {
// The game object this component is attached to
var gameObject : GameObject?
func update(deltaTime : Float) {
// Update this component
}
}
Next, define a GameObject class, which represents game objects in your project:
class GameObject: NSObject {
// The collection of Component objects attached to us
var components : [Component] = []
//and some methods to manipulate the components list
func someMethods()
//update this object by updating all components
func update(deltaTime:Float){
for component in self.components {
component.update(deltaTime)
}
}
Advantages
Inheritance-Based
“The advantage of a hierarchy-based layout is that each object is able to stand alone: if you have a Dragon object, you know that all of its behavior is contained inside that single object, and it doesn’t rely on other objects to work.
Component-Based
“A component-based layout means you can be more flexible with your design and not worry about inheritance issues. For example, if you’ve got a bunch of monsters, and you want one specific monster to have some new behavior (such as, say, exploding every five seconds), you just write a new component and add it to that monster. If you later decide that you want other monsters to also have that behavior, you can add that behavior to them, too.”
Disadvantages
Inheritance-Based
"The downside is that you can often end up with a very deep hierarchy of different game object types, which can be tricky to keep in your head as you program.”
Component-Based
“The main problem with component-based architectures is that it’s more laborious to create multiple copies of an object, because you have to create and add the same set of components every time you want a new copy.
”
