284 lines
8.7 KiB
Python
284 lines
8.7 KiB
Python
|
|
"""State module: contains State class"""
|
|
|
|
from direct.showbase.DirectObject import *
|
|
import types
|
|
|
|
# This gets set by a dconfig variable in ShowBase.py
|
|
# We cannot put a dconfig in here because ClassicFSM is not
|
|
# dependent on Panda
|
|
FsmRedefine = 0
|
|
|
|
# Map function pointers back into states so the Finder
|
|
# can find a function and swap a newly redefined function
|
|
# back into the original state
|
|
# The map is keyed off function pointers which map to
|
|
# a list of states that have that function pointer defined
|
|
# as their enter function (or exit function as the case may be)
|
|
EnterFuncRedefineMap = {}
|
|
ExitFuncRedefineMap = {}
|
|
|
|
|
|
def redefineEnterFunc(oldMethod, newFunction):
|
|
import new
|
|
if not FsmRedefine:
|
|
return
|
|
for method in EnterFuncRedefineMap.keys():
|
|
if (type(method) == types.MethodType):
|
|
function = method.im_func
|
|
else:
|
|
function = method
|
|
#print ('function: ' + `function` + '\n' +
|
|
# 'method: ' + `method` + '\n' +
|
|
# 'oldMethod: ' + `oldMethod` + '\n' +
|
|
# 'newFunction: ' + `newFunction` + '\n')
|
|
if (function == oldMethod):
|
|
newMethod = new.instancemethod(newFunction,
|
|
method.im_self,
|
|
method.im_class)
|
|
stateList = EnterFuncRedefineMap[method]
|
|
for state in stateList:
|
|
state.setEnterFunc(newMethod)
|
|
return 1
|
|
return 0
|
|
|
|
|
|
def redefineExitFunc(oldMethod, newFunction):
|
|
import new
|
|
if not FsmRedefine:
|
|
return
|
|
for method in ExitFuncRedefineMap.keys():
|
|
if (type(method) == types.MethodType):
|
|
function = method.im_func
|
|
else:
|
|
function = method
|
|
#print ('function: ' + `function` + '\n' +
|
|
# 'method: ' + `method` + '\n' +
|
|
# 'oldMethod: ' + `oldMethod` + '\n' +
|
|
# 'newFunction: ' + `newFunction` + '\n')
|
|
if (function == oldMethod):
|
|
newMethod = new.instancemethod(newFunction,
|
|
method.im_self,
|
|
method.im_class)
|
|
stateList = ExitFuncRedefineMap[method]
|
|
for state in stateList:
|
|
state.setExitFunc(newMethod)
|
|
return 1
|
|
return 0
|
|
|
|
|
|
class State(DirectObject):
|
|
notify = directNotify.newCategory("State")
|
|
|
|
# this 'constant' can be used to specify that the state
|
|
# can transition to any other state
|
|
Any = 'ANY'
|
|
|
|
def __init__(self, name, enterFunc=None, exitFunc=None,
|
|
transitions=Any, inspectorPos = []):
|
|
"""__init__(self, string, func, func, string[], inspectorPos = [])
|
|
State constructor: takes name, enter func, exit func, and
|
|
a list of states it can transition to (or State.Any)."""
|
|
self.__name = name
|
|
self.__enterFunc = enterFunc
|
|
self.__exitFunc = exitFunc
|
|
self.__transitions = transitions
|
|
self.__FSMList = []
|
|
if __debug__:
|
|
self.setInspectorPos(inspectorPos)
|
|
|
|
# setters and getters
|
|
|
|
def getName(self):
|
|
return(self.__name)
|
|
|
|
def setName(self, stateName):
|
|
self.__name = stateName
|
|
|
|
def getEnterFunc(self):
|
|
return(self.__enterFunc)
|
|
|
|
if __debug__:
|
|
def redefineFunc(self, oldMethod, newMethod, map):
|
|
if not FsmRedefine:
|
|
return
|
|
# Methods are allowed to be None
|
|
if oldMethod is None:
|
|
return
|
|
if map.has_key(oldMethod):
|
|
# Get the list of states for the old function
|
|
stateList = map[oldMethod]
|
|
# Remove this state from that list of states
|
|
stateList.remove(self)
|
|
# If the stateList is now empty, remove this entry altogether
|
|
if not stateList:
|
|
del(map[oldMethod])
|
|
# Now add the new function, creating a starter state list
|
|
# if there is not one already
|
|
stateList = map.get(newMethod, [])
|
|
stateList.append(self)
|
|
map[newMethod] = stateList
|
|
|
|
def setEnterFunc(self, stateEnterFunc):
|
|
if __debug__:
|
|
self.redefineFunc(self.__enterFunc, stateEnterFunc, EnterFuncRedefineMap)
|
|
self.__enterFunc = stateEnterFunc
|
|
|
|
def getExitFunc(self):
|
|
return(self.__exitFunc)
|
|
|
|
def setExitFunc(self, stateExitFunc):
|
|
if __debug__:
|
|
self.redefineFunc(self.__exitFunc, stateExitFunc, ExitFuncRedefineMap)
|
|
self.__exitFunc = stateExitFunc
|
|
|
|
def transitionsToAny(self):
|
|
""" returns true if State defines transitions to any other state """
|
|
return self.__transitions is State.Any
|
|
|
|
def getTransitions(self):
|
|
"""
|
|
warning -- if the state transitions to any other state,
|
|
returns an empty list (falsely implying that the state
|
|
has no transitions)
|
|
see State.transitionsToAny()
|
|
"""
|
|
if self.transitionsToAny():
|
|
return []
|
|
return self.__transitions
|
|
|
|
def isTransitionDefined(self, otherState):
|
|
if self.transitionsToAny():
|
|
return 1
|
|
|
|
# if we're given a state object, get its name instead
|
|
if type(otherState) != type(''):
|
|
otherState = otherState.getName()
|
|
return (otherState in self.__transitions)
|
|
|
|
def setTransitions(self, stateTransitions):
|
|
"""setTransitions(self, string[])"""
|
|
self.__transitions = stateTransitions
|
|
|
|
def addTransition(self, transition):
|
|
"""addTransitions(self, string)"""
|
|
if not self.transitionsToAny():
|
|
self.__transitions.append(transition)
|
|
else:
|
|
State.notify.warning(
|
|
'attempted to add transition %s to state that '
|
|
'transitions to any state')
|
|
|
|
if __debug__:
|
|
def getInspectorPos(self):
|
|
"""getInspectorPos(self)"""
|
|
return(self.__inspectorPos)
|
|
|
|
def setInspectorPos(self, inspectorPos):
|
|
"""setInspectorPos(self, [x, y])"""
|
|
self.__inspectorPos = inspectorPos
|
|
|
|
# support for HFSMs
|
|
|
|
def getChildren(self):
|
|
"""
|
|
Return the list of child FSMs
|
|
"""
|
|
return(self.__FSMList)
|
|
|
|
def setChildren(self, FSMList):
|
|
"""setChildren(self, ClassicFSM[])
|
|
Set the children to given list of FSMs
|
|
"""
|
|
self.__FSMList = FSMList
|
|
|
|
def addChild(self, ClassicFSM):
|
|
"""
|
|
Add the given ClassicFSM to list of child FSMs
|
|
"""
|
|
self.__FSMList.append(ClassicFSM)
|
|
|
|
def removeChild(self, ClassicFSM):
|
|
"""
|
|
Remove the given ClassicFSM from list of child FSMs
|
|
"""
|
|
if ClassicFSM in self.__FSMList:
|
|
self.__FSMList.remove(ClassicFSM)
|
|
|
|
def hasChildren(self):
|
|
"""
|
|
Return true if state has child FSMs
|
|
"""
|
|
return len(self.__FSMList) > 0
|
|
|
|
def __enterChildren(self, argList):
|
|
"""
|
|
Enter all child FSMs
|
|
"""
|
|
for fsm in self.__FSMList:
|
|
# Check to see if the child fsm is already in a state
|
|
# if it is, politely request the initial state
|
|
|
|
if fsm.getCurrentState():
|
|
# made this 'conditional_request()' instead of 'request()' to avoid warning when
|
|
# loading minigames where rules->frameworkInit transition doesnt exist and you
|
|
# dont want to add it since it results in hanging the game
|
|
fsm.conditional_request((fsm.getInitialState()).getName())
|
|
|
|
# If it has no current state, I assume this means it
|
|
# has never entered the initial state, so enter it
|
|
# explicitly
|
|
else:
|
|
fsm.enterInitialState()
|
|
|
|
def __exitChildren(self, argList):
|
|
"""
|
|
Exit all child FSMs
|
|
"""
|
|
for fsm in self.__FSMList:
|
|
fsm.request((fsm.getFinalState()).getName())
|
|
|
|
|
|
# basic State functionality
|
|
|
|
def enter(self, argList=[]):
|
|
"""
|
|
Call the enter function for this state
|
|
"""
|
|
# enter child FSMs first. It is assumed these have a start
|
|
# state that is safe to enter
|
|
self.__enterChildren(argList)
|
|
|
|
if (self.__enterFunc != None):
|
|
apply(self.__enterFunc, argList)
|
|
|
|
def exit(self, argList=[]):
|
|
"""
|
|
Call the exit function for this state
|
|
"""
|
|
# first exit child FSMs
|
|
self.__exitChildren(argList)
|
|
|
|
# call exit function if it exists
|
|
if (self.__exitFunc != None):
|
|
apply(self.__exitFunc, argList)
|
|
|
|
def __str__(self):
|
|
return "State: name = %s, enter = %s, exit = %s, trans = %s, children = %s" %\
|
|
(self.__name, self.__enterFunc, self.__exitFunc, self.__transitions, self.__FSMList)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|