Difference between revisions of "MindState"

(Source Code)
(Changing to redirect since it's deprecated and points to a specific other library.)
 
(5 intermediate revisions by 3 users not shown)
Line 1: Line 1:
This library complements [[MiddleClass]] by adding states to its objects.
+
#REDIRECT [[stateful.lua]]
 
 
What this library tries to accomplish is the creation of objects that act differently depending on their state.
 
 
 
The code is reasonably commented, so you might want to employ some time in reading through it, in order to gain insight of Lua's amazing flexibility.
 
 
 
MindState was developed as a key part of the [http://love2d.org/forum/viewtopic.php?f=5&t=1039 PÄSSION] lib.
 
 
 
==Table of Contents==
 
 
 
# [[MindState#Questions|Questions]]
 
# [[MindState#Requirements|Requirements]]
 
# [[MindState#Main_Features|Main Features]]
 
# [[MindState#Basic_states_and_callbacks|Basic states and callbacks]]
 
## [[MindState#Another_Example:_Game_controller|Another Example: Game controller]]
 
# [[MindState#State_Inheritance|State Inheritance]]
 
# [[MindState#Stackable_States|Stackable States]]
 
# [[MindState#Source_Code|Source Code]]
 
# [[MindState#Advanced_Features|Advanced Features]]
 
# [[MindState#Advanced Examples|Advanced Examples]]
 
 
 
==Questions==
 
Please refer to the [http://love2d.org/forum/viewtopic.php?f=5&t=1053 forum post] if you have any questions/issues/bugfixes.
 
 
 
==Requirementes==
 
 
 
* [[MiddleClass]] to be installed and available through require('MiddleClass.lua')
 
 
 
==Main Features==
 
 
 
* StatefulObject is the root class for objects with stateful infomation (derived from MiddleClass' root Object)
 
* Subclasses of StatefulObject have a class method called addState. It creates new states.
 
* States redefine functions: Instances on a state will use the state's methods instead of the methods defined on the class.
 
* An instance can "change its state" via the method instance:gotoState('stateName') or instance:gotoState(nil)
 
* There are two callbacks called onEnterState and onExitState, called when instances enter or exit a State
 
* States are be inherited by subclasses (if a parent class has states, then the subclass has the same states, and can modify them)
 
* States are "Stackable"; an object can be on several states at a given moment.
 
 
 
In addition to these main features, the interface is complemented with:
 
* Class.states and instance.states contain the list of all the states available for the class/instance.
 
* instance.currentState returns the current state (or nil).
 
* state.name returns an identifying string
 
 
 
==Basic states and callbacks==
 
Let's say you have an Enemy class that defines only one method, called "speak". It also defines two states, "Alive" and "Dying", and in those states the method speak() is redefined.
 
 
 
Also, there are enterState and exitState callbacks that do stuff when an enemy enters/exits those states (note that these callbacks are not mandatory at all).
 
<source lang="lua">
 
require 'MindState.lua'
 
 
 
Enemy = class('Enemy', StatefulObject)
 
 
 
function Enemy:speak()
 
  print("Well, you can tell by the way I use my walk, I'm a woman's man, no time to talk.") 
 
end
 
 
 
local Alive = Enemy:addState('Alive')
 
function Alive:speak()
 
  print("Ah, ha, ha, ha staying alive, staying alive!")
 
end
 
 
 
local Dying = Enemy:addState('Dying')
 
function Dying:enterState()
 
  print("I've got a bad feeling about this...")
 
end
 
function Dying:speak()
 
  print("I am dying! Noooooooo!")
 
end
 
function Dying:exitState()
 
  print("Few! It seems I did not die after all.")
 
end
 
 
 
local robin = Enemy:new()
 
robin:speak()
 
robin:gotoState('Alive')
 
robin:speak()
 
robin:gotoState('Dying')
 
robin:speak()
 
robin:gotoState(nil)
 
robin:speak()
 
 
 
--[[ output:
 
  Well, you can tell by the way I use my walk, I'm a woman's man, no time to talk.
 
  Ah-ha-ha-ha staying alive, staying alive!
 
  I've got a bad feeling about this...
 
  I am dying! Noooooooo!
 
  Few! It seems I did not die after all.
 
  Well, you can tell by the way I use my walk, I'm a woman's man, no time to talk.
 
]]
 
</source>
 
 
 
===Another Example: Game controller===
 
 
 
Typically, games start with a Main Menu screen. Then they have an options screen (maybe with more screens inside it for input, gameplay, display and sound). Then they have the "real" game. After the "game over" screen the game returns to the Main Menu.
 
 
 
This can be modelled very easily with MindState. For example, this would be the Game.lua file:
 
<source lang="lua">
 
require 'MindState.lua'
 
 
 
Game = class('Game', StatefulObject)
 
 
 
function Game:initialize()
 
  super.initialize(self)
 
  print('Creating global game variables')
 
  self:gotoState('MainMenu')
 
end
 
 
 
local MainMenu = Game:addState('MainMenu')
 
function MainMenu:enterState()
 
  print('Creating the main menu buttons')
 
end
 
function MainMenu:exitState()
 
  print('Destroying the main menu buttons')
 
end
 
 
 
local OptionsMenu = Game:addState('OptionsMenu')
 
function OptionsMenu:enterState()
 
  print('Creating the options menu buttons')
 
end
 
function OptionsMenu:exitState()
 
  print('Destroying the options menu buttons')
 
end
 
 
 
local Play = Game:addState('Play')
 
function Play:enterState()
 
  print('Creating player, world and enemies')
 
end
 
function OptionsMenu:exitState()
 
  print('Destroying the player, world and enemies')
 
end
 
</source>
 
You can then use this Game class by instantiating a global variable (we'll call it "game"). You can create it, for example, on main.lua.
 
<source lang="lua">
 
require 'Game.lua'
 
game = Game:new()
 
--[[ output:
 
  Creating global game variables
 
  Creating the options menu buttons
 
]]
 
</source>
 
It is up to you to create the buttons however you want. At some point, some of those buttons will contain the following call (or equivalent)
 
<source lang="lua">
 
game:gotoState('OptionsMenu')
 
--[[ output:
 
  Destroying the main menu buttons
 
  Creating the main menu buttons
 
]]
 
</source>
 
Similarly, one can change the state back to 'MainMenu', or go to the 'Play' state.
 
 
 
==State Inheritance==
 
States are inherited conveniently.
 
 
 
<source lang="lua">
 
 
 
------------------- Monster.lua:
 
 
 
require 'MindState.lua'
 
 
 
Monster = class('Monster', StatefulObject)
 
function Monster:initialize()
 
  super.initialize(self)
 
  self:gotoState('Idle')
 
end
 
 
 
local Idle = Monster:addState('Idle')
 
function Idle:update(dt)
 
  print('I am a bored')
 
end
 
 
 
local Attacked = Monster:addState('Attacked')
 
function Attacked:update()
 
  print('I am being attacked!')
 
end
 
 
 
------------------- Troll.lua
 
 
 
require 'Monster.lua'
 
 
 
Troll = class('Troll', Monster)
 
 
 
function Troll:initialize()
 
  super.initialize(self)
 
  print('Created Troll')
 
end
 
 
 
local Stone = Monster:addState('Stone')
 
function Stone:enterState()
 
  print('I am turning into stone!')
 
end
 
function Attacked:update()
 
  print('I am all granite now')
 
end
 
 
 
------------------- Goblin.lua
 
 
 
require 'Monster.lua'
 
 
 
function Goblin:initialize()
 
  super.initialize(self)
 
  print('Created Goblin')
 
end
 
 
 
Goblin = class('Goblin', Monster)
 
-- Goblins are coward and run away if attacked
 
function Goblin.states.Attacked:enterState(dt)
 
  print('I am being attacked! I have to run away fast!')
 
  self:gotoState('RunningAway')
 
end
 
 
 
local RunningAway = Goblin:addState('RunningAway')
 
function RunningAway:update(dt)
 
  print('Run, run, run!')
 
end
 
</source>
 
 
 
Now, an example of use:
 
<source lang="lua">
 
require('Troll.lua')
 
require('Goblin.lua')
 
 
 
local terrence = Troll:new()
 
terrence:update()
 
terrence:gotoState('Attacked')
 
terrence:update()
 
terrence:gotoState('Stone')
 
terrence:update()
 
 
 
local gob = Goblin:new()
 
gob:update()
 
gob:gotoState('Attacked')
 
gob:update()
 
 
 
 
 
--[[ output:
 
Created Troll
 
I am bored
 
I am being attacked!
 
I am turning into stone!
 
I am all granite now
 
Created Goblin
 
I am bored
 
I am being attacked! I have to run away fast!
 
Run, run, run!
 
]]
 
</source>
 
 
 
On the previous code, the Monster class has two states, "Idle" and "Attacked". Idle is set by default on the constructor.
 
 
 
On another file, we define a Troll class as a subclass of Monster. Troll inherits all the states from Monster (it can be also Attacked and Idle). But it adds an additional state, called 'Stone'.
 
 
 
Finally, the Goblin class, also a subclass of Monster, defines how Goblins behave: They react cowardly and enter a new state called 'RunningAway' as soon as they get attacked.
 
 
 
==Stackable States==
 
 
 
Stateful Objects have an internal pile, in which they can "push" and "pop" states.
 
 
 
When an object has more than one state on its pile, the methods are searched this way:
 
1. First, look for the method on the state at the top of the pile
 
2. Then look for the method on the second state
 
...
 
N. When there are no states left to look for, look on the class definition.
 
N+1. Look on the superclasses.
 
 
 
In order to use the pile, one has to use the pushState and popState methods (as opposed to gotoState).
 
 
 
In addition to the aforementioned enterState and exitState callbacks, when using the pile there are 4 additional ones: pausedState, pushedState, poppedState and continuedState.
 
 
 
Let's say that an object is on state 'A', and we push state 'B'. Assuming that all the callbacks were defined for states A and B, they would get called on this order:
 
 
 
<source lang="lua">
 
-- object is initially on state 'A'
 
object:pushState('B')
 
  -- A.pausedState(object)
 
  -- B.pushedState(object)
 
  -- B.enterState(object)
 
</source>
 
 
 
Similarly, when the state is popped from the object, this is what happens:
 
<source lang="lua">
 
-- object state pile is [A,B]
 
object:popState()
 
  -- B.exitState(object)
 
  -- B.poppedState(object)
 
  -- A.continuedState(object)
 
</source>
 
 
 
Note that popState accepts a state name as a parameter. If included, the state is removed from the pile, even if it is not on the top. However, this will trigger 'continuedState' on the state at the top of the pile, so be careful!
 
<source lang="lua">
 
-- object state pile is [A,B,C]
 
object:popState('B')
 
  -- B.exitState(object)
 
  -- B.poppedState(object)
 
  -- C.continuedState(object)
 
-- the state pile is now [A,C]
 
</source>
 
 
 
===Example===
 
 
 
Let's say that you have a Soldier class that can be Running and Firing at the same time. You can use the following example as a reference.
 
 
 
Note that we're using enterState and exitState callbacks here- you could use the other callbacks too.
 
<source lang="lua">
 
Soldier = class('Soldier', StatefulObject)
 
function Soldier:initialize()
 
  super.initialize(self)
 
end
 
function Soldier:draw()
 
  print('yes, captain?')
 
end
 
function Soldier:status()
 
  print('in static position')
 
end
 
 
 
Firing = Soldier:addState('Firing')
 
function Firing:enterState()
 
  print('weapon ready')
 
end
 
function Firing:draw()
 
  print('pew pew!')
 
end
 
 
 
Running = Soldier:addState('Running')
 
function Running:draw()
 
  print('1,2,1,2')
 
end
 
function Jumping:status()
 
  print('go go go!')
 
end
 
function Firing:exitState()
 
  print('resting my feet')
 
end
 
 
 
frank = Soldier:new()
 
frank:draw()                -- yes, captain?
 
frank:status()              -- in static position
 
 
 
frank:pushState('Running')
 
frank:draw()                -- 1,2,1,2
 
frank:status()              -- go go go!
 
 
 
frank:pushState('Firing')  -- weapon ready
 
frank:draw()                -- pew pew!
 
frank:status()              -- go go go!
 
 
 
frank:popState('Running')  -- resting my feet
 
frank:draw()                -- pew pew!
 
frank:status()              -- in static position
 
 
 
frank:popState()
 
frank:draw()                -- yes, captain?
 
frank:status()              -- in static position
 
 
 
</source>
 
 
 
==Source Code==
 
MindState is bundled with [[MiddleClass]], which means that it can be found on the [http://github.com/kikito/middleclass MiddleClass github page]
 
* Here's a link to the latest [http://github.com/kikito/middleclass/raw/master/MindState.lua raw file]
 
* And here you have a [http://github.com/kikito/middleclass/blob/master/MindState.lua syntax highlighted version]
 
 
 
==Advanced Features==
 
* States can 'copy' (inherit from) other states.
 
* States work with mixins
 
* States are classes, so if needed they can be initialized on the class initialize() constructor
 
 
 
==Advanced Examples==
 
 
 
===State "Copying"===
 
In reality, States themselves are classes. Nothing stops you from creating a State that is a subclass of another state. This way, it will inherit its methods (which you can then override). The addState method takes a second parameter for specifying a superclass (by default it is Object).
 
 
 
<source lang="lua">
 
require('MindState.lua')
 
 
 
GirlFriend = class('GirlFriend', StatefulObject)
 
 
 
function GirlFriend:getStatus()
 
  print("I'm bored. Entertain me")
 
end
 
 
 
local Angry = GirlFriend:addState('Angry')
 
function Angry:getStatus()
 
  print("I'm angry with you")
 
end
 
function Angry:askWhy()
 
  print("You should know why")
 
end
 
 
 
local AngrySilent = GirlFriend:addState('AngrySilent', Angry) -- AngrySilent "copies" Angry (in reality it is a subclass of Angry)
 
function AngrySilent:askWhy()
 
  print("...")
 
end
 
 
 
gf = GirlFriend:new()
 
gf:getStatus()
 
gf:gotoState('Angry')
 
gf:getStatus()
 
gf:askWhy()
 
gf:gotoState('AngrySilent')
 
gf:getStatus()
 
gf:askWhy()
 
 
 
--[[ output:
 
  I'm bored. Entertain me.
 
  I'm angry with you
 
  You should know why
 
  I'm angry with you
 
  ...
 
]]
 
</source>
 
 
 
On this example how the AngrySilent state inherits the getStatus function from Angry, and then redefines askWhy.
 
 
 
== See also ==
 
 
 
* [[Libraries]]
 
 
 
{{#set:LOVE Version=0.6.1}}
 
{{#set:Description=Stateful information complement for [[MiddleClass]].}}
 
[[Category:Libraries]]
 

Latest revision as of 11:47, 18 January 2017

Redirect to: