Value of inheritance in Object-oriented programming

External Since: Oct 08, 2006 Posts: 4

I'm wondering what would be a more speed and memory efficient way of
classing objects in RLs like items, monsters, players, and NPCs.

Would an approach that stresses hierarchical inheritance be effective,
like this:

pseudo-code class definitions:

class object:
definitions like location of map...

class item(inheriting object):
definitions like type and inventory...
class actor(inheriting object):
methods like intrinsics, abilities...
class trap(inheriting object):
methods like deal damage...

class monster(inheriting actor):
methods like move, attack, AI
class player (inheriting actor):
definitions and methods unique to player
class shopkeeper(inheriting actor):
special class of actor with different rules

class warrior(inheriting player):
methods describing abilities only warriors can use and mages can't
class mage(inheriting player):
methods describing abilities only mages can use and warriors can't

....But I think what this approach makes up for in initialization speed
and memory allocation, it gains back by spreading out class definitions
over multiple objects, making them less freely accessible to the
processor. I'm kind of new to programming, but I would like to hear
everyone's opinions about this. Also, I'm using Python, so that might
make a difference in the speed of function calls being dealt with, etc.

External Since: Feb 23, 2005 Posts: 577

Pointless wrote:
> I'm wondering what would be a more speed and memory efficient way of
> classing objects in RLs like items, monsters, players, and NPCs.
>
> Would an approach that stresses hierarchical inheritance be effective,
> like this:
>
> pseudo-code class definitions:
>
> class object:
> definitions like location of map...
>
> class item(inheriting object):
> definitions like type and inventory...
> class actor(inheriting object):
> methods like intrinsics, abilities...
> class trap(inheriting object):
> methods like deal damage...
>
> class monster(inheriting actor):
> methods like move, attack, AI
> class player (inheriting actor):
> definitions and methods unique to player
> class shopkeeper(inheriting actor):
> special class of actor with different rules
>
> class warrior(inheriting player):
> methods describing abilities only warriors can use and mages can't
> class mage(inheriting player):
> methods describing abilities only mages can use and warriors can't
>
> ...But I think what this approach makes up for in initialization speed
> and memory allocation, it gains back by spreading out class definitions
> over multiple objects, making them less freely accessible to the
> processor. I'm kind of new to programming, but I would like to hear
> everyone's opinions about this. Also, I'm using Python, so that might
> make a difference in the speed of function calls being dealt with, etc.

I think you'll find issues of performance are not relevant here. The
real performance bottlenecks of your program will not relate to
class/function definitions at all. They will relate to the algorithms
you use for things like LOS, pathfinding, AI, and possibly drawing
graphics if you code it badly.

Forget about initialization speed here; choose an approach that aptly
models your conceptual structure and allows powerful development of
game features.

A.