Multiple Inheritance

SynapticBytes

So I'm wanting to use pseudo multiple class inheritance to derive my Player class from the Sprite class, but then extend it with a generic Actor class, which contains common attributes for players and enemies, and after that, add some of my own specific functions. I'd rather just have my Actor class as a map which I can add, instead of having to manually go through and define additional attributes and methods, so I was using something like the following code

Actor = {"lives":3,"speed":0,...}
Player = new Sprite
Player = Player + Actor
Player.status = function()
if self.speed == 0 then
return 'You can't move"
else
return "Keep on movin'"
end function
player = new Player

I just wonder what I am losing doing it this way and if there is a better way to do it? I know doing it this way I won't be able to test if Player isa Actor since I'm not adding the extra class with a "new" command.

Should I instead be doing the following? If so, can I put that Player function in a PlayerPrototype and add it that way instead? I just like the idea of keeping my prototypes nice and compact in a map line rather than spreading it out over a bunch of code lines. Or I suppose you can add a Prototype function which does all the setup to compartmentalise the code a bit more?

ActorPrototype = {"lives":3,"speed":0,...}
Actor= new Sprite
Actor = Actor + ActorPrototype
Player = new Actor
Player.status = function()
if self.speed == 0 then
return 'You can't move"
else
return "Keep on movin'"
end function
player = new Player

Also if the above is valid, how do I use .super to access base methods of either the Sprite or the Actor?

SynapticBytes

Sometimes I just have to write down the questions before the answers come to me. I made this sample code

// Class properties to add into classes when defined
GenericProperties = {"x":2, "y":3}
ActorProperties = {"energy":2}
PlayerProperties = {"score":100}
Generic = {}
Generic = Generic + GenericProperties
Generic.method = function()
print "generic"
return self.x*self.y
end function
Actor = new Generic
Actor = Actor + ActorProperties
Actor.method = function()
print "Actor"
return super.method * self.energy
end function
Player = new Actor
Player = Player + PlayerProperties
Player.method = function()
print "Player"
return super.method * self.score
end function
clear
player = new Player
actor = new Actor
generic = new Generic
print player.method
print actor.method
print generic.method

Which clears up most of my questions, with the result being

The only question remaining is, can I access the Generic.method directly from the player instance, or would I have to say create an Actor.superMethod which just passes on Generic.method and call it via player.superMethod?

Russell.

jstrout

Yes, I was going to suggest simply having Actor be a new Sprite, and Player be a new Actor (i.e. the inheritance chain would go Sprite -> Actor -> Player).

Your use of map addition is pretty neat! The only real advantage is that it lets you use the map-literal form for defining the initial property values, but if you prefer that syntax, I'm certainly not going to argue.

The only question remaining is, can I access the Generic.method directly from the player instance, or would I have to say create an Actor.superMethod which just passes on Generic.method and call it via player.superMethod?

Yes. super.method will only invoke the nearest superclass that defines that method. There's no simple way to "skip" a level and call something higher up the chain directly.

However, if you find yourself wanting to do that, I might suggest reexamining your life choices (or at least your code design). It violates standard OOP design principles, and couples your subclass a bit too tightly to the design of the superclasses. The whole point of OOP/encapsulation is to limit how much you have to keep in your head at once... when you start doing stuff like this, you lose much of that benefit.

SynapticBytes

I don’t have a use-case for my super.super method, it was more an academic question wondering if there was anything that would work like you would do in C++ such as player->Generic::method. I have no current desire to do it. Thanks for clarifying.

jstrout

Ah, well there is an equivalent of static methods, if that's what you're after. You can define a method on (say) Generic that is intended to be invoked directly via Generic, i.e., not as an instance method. That method would not use self, but could have whatever explicit parameters you like. Then you could call that from anywhere as Generic.whatever, passing in arguments as needed.