shuvit/scripts/camFSM.py

import bge
from random import randint
from time import clock
   
   



#camera - (Target Object, Min Distance, Max Distance, Height)
def activate_camera(cobj, cmin, cmax, cheight):
    cont = bge.logic.getCurrentController()
    scene = bge.logic.getCurrentScene()
    camActu = cont.actuators['Camera']
    camActu.object = scene.objects[cobj]
    camActu.min = cmin
    camActu.max = cmax
    camActu.height = cheight
    cont.activate(camActu)



#====================================
class Transition(object):
    def __init__(self, toState):
        self.toState = toState
    def Execute(self):
        print('Transitioning ...', self.toState)
            
   
   
#====================================
State = type("State", (object,), {})

class State(object):
    def __init__(self, FSM):
        self.FSM = FSM
        self.timer = 0
        self.startTime = 0
        #cam settings
        self.target = None
        self.min = 0
        self.max = 0

    def Enter(self):
        self.timer = randint(0,5)
        self.startTime = int(clock())
    def Execute(self):
        print('Executing')
    def Exit(self):
        print('Exiting')
        
class WalkCam(State):
    def __init__(self,FSM):
        super(WalkCam, self).__init__(FSM)   
        self.min = 4
        self.max = 5
        self.target = 'player' 
        
    def Enter(self):
        print('Preparing to enter walk cam state.')
        self.FSM.stateLife = 1
        super(WalkCam, self).Enter()
        
    def Execute(self):
        #print('walk cam state', self.FSM.stateLife)
        self.FSM.stateLife += 1
        duration = 50
        activate_camera('camCube', 2, 3, 1)
        # if self.FSM.stateLife > duration:
        #     if not (randint(1,3) % 2):
        #         self.FSM.ToTransition('toRollCam')
        #     else:
        #         self.FSM.ToTransition('toRagdollCam')
                
    def Exit(self):
        print('walk cam state')  

class RollCam(State):
    def __init__(self,FSM):
        super(RollCam, self).__init__(FSM)    
        
    def Enter(self):
        print('Preparing to enter roll cam state')
        self.FSM.stateLife = 1
        super(RollCam, self).Enter()
        
    def Execute(self):
        #print('Eating Breakfast.', self.FSM.stateLife)
        self.FSM.stateLife += 1
        duration = 500
        activate_camera('camCube', 1.5, 3, 2)
        if self.FSM.stateLife > duration:
            if not (randint(1,3) % 2):
                self.FSM.ToTransition('toRagdollCam')
            else:
                self.FSM.ToTransition('toWalkCam')
                
    def Exit(self):
        print('Finished RollCaming')          
        
class RagdollCam(State):
    def __init__(self,FSM):
        super(RagdollCam, self).__init__(FSM)    
        
    def Enter(self):
        print('Preparing to RagdollCam state.')
        self.FSM.stateLife = 1
        super(RagdollCam, self).Enter()
        
    def Execute(self):
        #print('Vacumming.', self.FSM.stateLife)
        self.FSM.stateLife += 1
        duration = 6
        if self.FSM.stateLife > duration:
        #if (self.startTime + self.timer <= clock()):
            if not (randint(1,3) % 2):
                self.FSM.ToTransition('toWalkCam')
            else:
                self.FSM.ToTransition('toPauseCam')
                
    def Exit(self):
        print('Finished RagdollCaming')             
        
        
class PauseCam(State):
    
    def __init__(self,FSM):
        super(PauseCam, self).__init__(FSM)  
        
    def Enter(self):
        print('Starting to PauseCam.')
        super(PauseCam, self).Enter()
        self.FSM.stateLife = 1
        
    def Execute(self):
        print('PauseCaming.', self.FSM.stateLife)
        self.FSM.stateLife += 1
        duration = 10
        if self.FSM.stateLife > duration:
            self.FSM.ToTransition('toWalkCam')
            
    def Exit(self):
        print('Finished PauseCaming.')                  
                     
#===================================
                        

class FSM(object):
    def __init__ (self, character):
        self.char = character
        self.states = {}
        self.transitions = {}
        self.curState = None
        self.prevState = None
        self.trans = None
        self.stateLife = 0
        
    def AddTransition(self, transName, transition):
        self.transitions[transName] = transition
    
    def AddState(self, stateName, state):
        self.states[stateName] = state        
        
    def SetState(self, stateName):
        self.prevState = self.curState
        self.curState = self.states[stateName]
        
    def ToTransition(self, toTrans):
        self.trans = self.transitions[toTrans]
        
    def Execute(self):
        if (self.trans):
            self.curState.Exit()
            self.trans.Execute()
            self.SetState(self.trans.toState)
            self.curState.Enter()
            self.trans = None        
        self.curState.Execute()    
                
#====================================
Char = type("Char",(object,),{})

class CameraFSM(Char):
    def __init__(self):
        self.FSM = FSM(self)
        
        ##STATES
        self.FSM.AddState('WalkCam', WalkCam(self.FSM))
        self.FSM.AddState('RollCam', RollCam(self.FSM))
        self.FSM.AddState('RagdollCam', RagdollCam(self.FSM))
        self.FSM.AddState("PauseCam", PauseCam(self.FSM))

        #TRANSITIONS
        self.FSM.AddTransition('toPauseCam', Transition('PauseCam'))
        self.FSM.AddTransition('toWalkCam', Transition('WalkCam'))
        self.FSM.AddTransition('toRollCam', Transition('RollCam'))
        self.FSM.AddTransition('toRagdollCam', Transition('RagdollCam'))
        
        if self.FSM.curState == None:
            self.FSM.SetState('WalkCam')
            print('setting none')
    
    def Execute(self):
        self.FSM.Execute()    
#====================================     
r = CameraFSM()
def main(cont):
    own = cont.owner   
   
    if 'inited' not in own:
        own['inited'] = True
        own['frame'] = 0
        own['state'] = 'On'
        print('initing')

    r.Execute()    
    
    own['frame'] += 1