I wish you all a good and happy new year 2013 and all the best wishes!
As things have been very exciting for those following our development branches
in Git, but outwardly a bit calm for those who don't, let me take the
opportunity for a brief review of recent developments, and an outlook on
upcoming changes:
Better game development
Early in the second half of 2012, we have started to focus our efforts on
improving the experience for game programmers, that is, for those nice folks
who are responsible for the programming part in the development of a new game
that uses the Cafu Engine.
In the past, our game code has grown as the features of the Cafu Engine grew,
and eventually we had to realize that customizing the DeathMatch example code
for other needs, or even adding new features to it, was more complicated than
it should be.
As a result, we started to fix the situation:
Improvements to and a large redesign of our game/entity code was a very
important first step that brought a great relief almost immediately. The
related ticket
#113 is still not closed
however -- we have plans for further changes.
In parallel, we found that the time was ripe for switching our version control
system from Subversion to Git.
The switch turned out to consume a lot of time and efforts, but as I've pointed
out in my migration protocols (
Part 1
and
Part
2), the benefits especially for our users are so great that it was
all worth it -- and such improvements were on our agenda anyways.
Component Systems
And finally, in the midst of all this, our new forum member
midix suggested the introduction of "entity systems" or
"component systems" to the Cafu Engine. I have to admit that I was at first
highly skeptical to the idea, which essentially is a different way to organize
and manage all the features that game entities have:
Previously, the classic class inheritance hierarchy of game entities was the
main place and instrument to organize and implement the features of the game
entities. It turned out however (not only for Cafu, but also for many other
game engines as well), that such class hierarchies are very inflexible when it
comes to reusing or recombining features in circumstances that are even
slightly different than those originally foreseen.
With "component systems", the proposal is to remove the entire game entity
inheritance hierarchy, except for the root class, and instead to implement
features as "components": Each component implements exactly one feature, and
each feature is implemented in exactly one component. A game entity is then
provided with the list of components (or features) that is should have. Of
course, each component can be configured by the user: conveniently with a nice
user interface in the graphical map editor, or with powerful scripting
commands, or an arbitrary mix of both.
As I said, I was very skepical about it, but I could also see how a component
system would improve our situation and help our mission to make game
development and programming with Cafu so much easier and more flexible. And
then I realized that we not only have
game entity hierarchies in Cafu,
but also
GUI window hierarchies in our 2D and 3D GUIs, and I could see
an analogy in both: The GUI windows were a much smaller hierarchy than our
existing hierarchy of game entities, but they too would much benefit from the
perspectives of a component system -- and as the hierarchy was so much smaller,
they were the perfect test case!
So my plan was to try out and implement a component system for our GUI windows
first, gather experience, then evaluate the results. If everything worked well
and our expectations were met, only then implement the component system for the
game entities as well.
Well, today, after only a relatively short while of working on it, and while
still being in the middle of implementing the component system for GUI windows,
I can already say that I'm very very pleased with the intermediate results.
Things look highly promising already, and 95% of the efforts that I've spent so
far will immediately be useful again when we decide to extend the component
system approach to game entities as well! It's really difficult to explain that
all in proper thoroughness right now, bit if you're interested in the details,
check out the
gui-component-system
branch in
our
Git repository.
In summary, I'm very happy with the current perspective, and very much looking
forward to the new year!