misc unknown changes

scripts/Manager.py

@@ -4,12 +4,16 @@ def main():
     #Modified BGE Gameplay Recorder Version 2
     #originally written by Nicholas Anderson, aka Red Frost Games.
     #"""
-
+    from bge import logic
+    import Record
+    import SortData    
+    dict = logic.globalDict
     #####Tweakables###############
     #Watch out! These numbers might bite!
     frame_rate = 60    #Set this to the framerate of your game.
     optimization = 1    #An integer, must be at least 1! Higher value will make a smaller saved file size. I do not reccomend setting it to anything other than 1 though.
-    recording_cutoff = 7300 #3600   #Frames at which the oldest recorded frame will be deleted. 0 is no cutoff.
+    recording_cutoff = dict['replay_record_length']
+    #recording_cutoff = 7300 #3600   #Frames at which the oldest recorded frame will be deleted. 0 is no cutoff.
     recorder_state = 1   #This is the main state of the recorder object. State will be reverted to this value when the user breaks out of the playback.
     allow_playback_break = True   #Allow the player to resume playing from the position in the recording.
     #####Sensor names#############
@@ -21,15 +25,13 @@ def main():
     break_sensor = "Break"
     ##############################
 
-    from bge import logic
-    import Record
-    import SortData
+
 
     cont = logic.getCurrentController()
     own = cont.owner
 
     cont.sensors[record_sensor].skippedTicks = optimization
-    dict = logic.globalDict
+    
 
     #dict['recorder_on'] = recorder_on
     recorder_on = dict.get('recorder_on')
@@ -61,29 +63,7 @@ def main():
         b_on = dict['bBut']
         #print(a on)
         last_back = own['last_back_but']
-        #last_back = own['last_a_but']
-    #    reduction = 400000
-    #    axisTh = 0.03 
-    #    lt = 4
-    #    rt = 5
-    #    lts_pr = 7
-    #    rts_pr = 8
-
-    #    lar_lts = 0
-    #    uad_lts = 1
-    #    lar_rts = 2 
-    #    uad_rts = 3 
-        #lts_pr = 7
-        #rts_pr = 8
-    #    lTrig = aXis.axisValues[lt] / reduction
-    #    rTrig = aXis.axisValues[rt] / reduction
-    #    lLR = aXis.axisValues[lar_lts] / reduction
-    #    lUD = aXis.axisValues[uad_lts] / reduction
-    #    rLR = aXis.axisValues[lar_rts] / reduction
-    #    rUD = aXis.axisValues[uad_rts] / reduction
-    #    ltsBut = butt.getButtonStatus(lts_pr)
-    #    rtsBut = butt.getButtonStatus(rts_pr) 
-    #        
+      
         lLR = dict['lLR']
         lUD = dict['lUD']
         rLR = dict['rLR']
@@ -115,10 +95,6 @@ def main():
             pause_state = 0
             last_pause = 0          
            
-        #trigs results range 0 - .08
-        #print(lTrig, rTrig)
-
-        #if cont.sensors[record_sensor].positive:
         if own["playback"] != True:    
             Record.main(recording_cutoff, cube)
             
@@ -152,7 +128,9 @@ def main():
             own["objIndex"] += 2
             logic.setLogicTicRate(frame_rate*own["playbackSpeed"])
 
-        if own["playback"] == True:    
+        if own["playback"] == True: 
+            #print("objIndex = ", own["lengthPos"],  own['objIndex'])   
+            
             if rTrig > .01 and rTrig < .02:
                 own["objIndex"] += 2
                 logic.setLogicTicRate(frame_rate*.5) 
@@ -188,26 +166,10 @@ def main():
             if own['back_state'] == 0 and back_on == 1 and last_back == 0:       
                 own["playbackBroken"] = True
                 own["playback"] = False
-                #print("break - add hud, remove stance (back_state == False)")
-                #cont.activate(own.actuators['add_hud'])
-                #cont.activate(own.actuators['remove_stance'])
-                #removescene = cont.actuators["remove_hud"]
-                #removescene.scene = "replay_HUD"
-                #addscene = cont.actuators["add_hud"]
-                #addscene.scene = "stance"
-                #cont.activate(addscene)        
-                #cont.activate(removescene)
+
             elif own["playbackBroken"] and back_on == 0:
                 Record.breakOut()
-                #cont.activate(own.actuators['remove_hud'])
-                #cont.activate(own.actuators['add_stance'])
-                #addscene = cont.actuators["add_hud"]
-                #addscene.scene = "replay_HUD"
-                #removescene = cont.actuators["remove_hud"]
-                #removescene.scene = "stance"
-                #cont.activate(addscene)
-                #cont.activate(removescene)
-                
+
                 logic.setLogicTicRate(frame_rate)
                 #set value index
                 own.state = recorder_state
@@ -218,10 +180,7 @@ def main():
                 cont.activate(own.actuators['replayCam'])
                 #print("unbreak")
                 own['loop_play'] = 0
-                #own['valueIndex'] = 0
-                #own["objIndex"] += 2
-                #logic.setLogicTicRate(frame_rate*1)
-                #own['objectIndex'] = 0
+
                 #print("valueIndex = ", own['valueIndex'])
         if back_on == 1 and own['back_but'] == 0:
             #print("change back state")

scripts/Record.py

@@ -1,4 +1,5 @@
 #record
+import bge
 from bge import logic
 from mathutils import Vector
 from SortData import *
@@ -193,7 +194,7 @@ def loadData():
     
     #Function for loading the data from
     #the disk and setting it.
-    
+    dict = bge.logic.globalDict
     objIndex = own["objIndex"]
     own["valueIndex"] = objIndex + 1
     valueIndex = own["valueIndex"]
@@ -236,13 +237,15 @@ def loadData():
     
     #-----Position-----#
     own["lengthPos"] = readData.getLengthPos()
+    dict['replay_loop_end'] = own['lengthPos']
+    print('setting replay end', dict['replay_loop_end'])
     lengthPos = own["lengthPos"] 
     
     if lengthPos:
         
         if objIndex > lengthPos-1:
-            own["objIndex"] = 0
-        if objIndex < 0:
+            own["objIndex"] = dict['replay_loop_start']
+        if objIndex < dict['replay_loop_start']:
             own["objIndex"] = lengthPos-2
 
         name, position = readData.returnPosition(objIndex, valueIndex)
@@ -395,7 +398,7 @@ def loadData():
                         deck.playAction(deckanim, DAF,DAF, layer=9999, play_mode=1, speed=1)
                         trucks.playAction(deckanim, DAF,DAF, layer=9999, play_mode=1, speed=1)
                     else:
-                        print('play a_reg')  
+                        #print('play a_reg')  
                         deck.playAction(deckanim, DAF,DAF, layer=9999, play_mode=1, speed=1)
                         trucks.playAction('a_reg', DAF,DAF, layer=9999, play_mode=1, speed=1)                          
                 #print("Playing: ", deckanim, PAF)

scripts/Startup.py

@@ -148,6 +148,12 @@ def main():
     dict['cur_ccH_targetHeight'] = .3
     dict['music_start'] = False  
     dict['npause'] = False
-    dict['playback'] = False  
+    dict['playback'] = False 
+    dict['sunx'] = 1.0
+    dict['suny'] = 1.0
+    dict['sunz'] = 1.0 
+    dict['replay_loop_start'] = 0
+    dict['replay_loop_end'] = 0
+    dict['replay_record_length'] = 7300
     
 main()

scripts/actionsFSM.py

@@ -0,0 +1,372 @@
+import bge
+from random import randint
+import actionsFSMlist
+
+MAIN_LAYER = 10
+TRANS_LAYER = 12
+
+def getOwn():
+	cont = bge.logic.getCurrentController()
+	own = cont.owner
+	return own
+
+def transPlaying():
+	scene = bge.logic.getCurrentScene()
+	skater = scene.objects['Char4']
+	if skater.isPlayingAction(TRANS_LAYER):
+		return True
+	else:
+		return False	
+
+def stopTrans():
+	scene = bge.logic.getCurrentScene()
+	skater = scene.objects['Char4']
+	if skater.isPlayingAction(TRANS_LAYER):
+		skater.stopAction(TRANS_LAYER)	
+
+def getCurFrame():
+	scene = bge.logic.getCurrentScene()
+	skater = scene.objects['Char4']
+	if skater.isPlayingAction(TRANS_LAYER):
+		num = round(skater.getActionFrame(TRANS_LAYER), 3)
+		print('playing frame ', num)
+		return num
+	else:
+		return None	
+
+def interupt_request():
+	cont = bge.logic.getCurrentController()
+	own = cont.owner
+	print(own['requestAction'])
+	if own['requestAction'] in actionsFSMlist.reg_fliplist or own['requestAction'] in actionsFSMlist.fak_fliplist:
+		print('flip is true')
+		return True
+		
+	else:
+		return False						
+
+def actionPlayer(ac, FSM):
+	scene = bge.logic.getCurrentScene()
+	skater = scene.objects['Char4']
+	deck = scene.objects['deck']
+	trucks = scene.objects['trucks']
+	name = ac.FSM.action.s_action
+	start = ac.FSM.action.s_se[0]
+	end = ac.FSM.action.s_se[1]
+	layer = ac.FSM.action.layer
+	mode = ac.FSM.action.mode
+	speed = ac.FSM.action.speed
+	
+	skater.playAction(name, start,end, layer=layer, play_mode=mode, speed=speed)
+	
+def transEndPlayer(ac, FSM):
+
+	scene = bge.logic.getCurrentScene()
+	skater = scene.objects['Char4']
+	deck = scene.objects['deck']
+	trucks = scene.objects['trucks']
+	name = ac.FSM.action.s_action
+	end = ac.FSM.action.s_se[1]
+	
+	skater.playAction(name, end,end, layer=TRANS_LAYER, play_mode=1, speed=1)	
+
+#====================================
+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
+
+	def Enter(self):
+		self.timer = randint(0,5)
+		self.startTime = 0
+	def Execute(self):
+		print('Executing')
+	def Exit(self):
+		print('Exiting')
+
+#====================================
+#====================================		
+		
+class reg_roll(State):
+	def __init__(self,FSM):
+		super(reg_roll, self).__init__(FSM) 
+		
+	def Enter(self):
+		print('entering: ', type(self).__name__)
+		self.FSM.action = getattr(actionsFSMlist, type(self).__name__) 
+		super(reg_roll, self).Enter()
+		
+	def Execute(self):
+		print('executing: ', type(self).__name__)
+		self.FSM.stateLife += 1
+		actionPlayer(self, FSM)
+		own = getOwn()
+		if own['requestAction'] == 'reg_opos':
+			self.FSM.ToTransition('toreg_roll_to_opos') 
+		if own['requestAction'] == 'reg_turnLeft':
+			self.FSM.ToTransition('toreg_roll_to_left') 			  
+
+	def Exit(self):
+		print('exiting: ', type(self).__name__)
+
+
+class reg_opos(State):
+	def __init__(self,FSM):
+		super(reg_opos, self).__init__(FSM)    
+		
+	def Enter(self):
+		print('entering: ', type(self).__name__)
+		self.FSM.action = getattr(actionsFSMlist, type(self).__name__) 
+		super(reg_opos, self).Enter()
+		
+	def Execute(self):
+		print('executing: ', type(self).__name__)
+		self.FSM.stateLife += 1
+		dict = bge.logic.globalDict
+		actionPlayer(self, FSM)
+		own = getOwn()
+		if own['requestAction'] != 'reg_opos':      
+			self.FSM.ToTransition(self.FSM.action.parentTrans)
+	def Exit(self):
+		print('exiting: ', type(self).__name__)
+
+class reg_left(State):
+	def __init__(self,FSM):
+		super(reg_left, self).__init__(FSM)    
+		
+	def Enter(self):
+		print('entering: ', type(self).__name__)
+		self.FSM.action = getattr(actionsFSMlist, type(self).__name__) 
+		super(reg_left, self).Enter()
+		
+	def Execute(self):
+		print('executing: ', type(self).__name__)
+		self.FSM.stateLife += 1
+		actionPlayer(self, FSM)
+		own = getOwn()
+		if own['requestAction'] != self.FSM.action.requestAction:	
+			self.FSM.ToTransition(self.FSM.action.parentTrans) 
+			print('initing left')       
+	
+	def Exit(self):
+		print('exiting: ', type(self).__name__)	
+	
+#====================================
+#====================================
+
+class reg_roll_to_opos(State):
+	def __init__(self,FSM):
+		super(reg_roll_to_opos, self).__init__(FSM)    
+		
+	def Enter(self):
+		print('entering: ', type(self).__name__)
+		self.FSM.action = getattr(actionsFSMlist, type(self).__name__) 
+		super(reg_roll_to_opos, self).Enter()
+		
+	def Execute(self):
+		print('executing: ', type(self).__name__)
+		dict = bge.logic.globalDict
+		self.FSM.stateLife += 1
+		own = getOwn()
+		if own['requestAction'] == 'reg_roll':
+			print('requesting early out')
+			self.FSM.ToTransition('toreg_opos_to_roll')
+		if transPlaying() == False and self.FSM.stateLife > 2:		
+			self.FSM.ToTransition(self.FSM.action.parentTrans)
+			transEndPlayer(self, FSM)
+		else:
+			actionPlayer(self, FSM)
+
+	def Exit(self):
+		print('exiting: ', type(self).__name__)
+
+class reg_opos_to_roll(State):
+	def __init__(self,FSM):
+		super(reg_opos_to_roll, self).__init__(FSM) 
+		
+	def Enter(self):
+		print('entering: ', type(self).__name__)
+		self.FSM.action = getattr(actionsFSMlist, type(self).__name__) 
+		super(reg_opos_to_roll, self).Enter()
+
+		old_state = self.FSM.prevState
+		if getCurFrame() != None:	
+			print('do the things', old_state.FSM.currentFrame, getCurFrame())
+			self.FSM.action.s_se[0] = getCurFrame()
+		
+	def Execute(self):
+		print('executing: ', type(self).__name__)
+		self.FSM.stateLife += 1
+		if transPlaying() == False and self.FSM.stateLife > 2:		
+			self.FSM.ToTransition('toreg_roll')
+			transEndPlayer(self, FSM)
+		else:
+			actionPlayer(self, FSM)	        
+	
+	def Exit(self):
+		print('exiting: ', type(self).__name__)	
+					   
+class reg_roll_to_left(State):
+	def __init__(self,FSM):
+		super(reg_roll_to_left, self).__init__(FSM) 
+		
+	def Enter(self):
+		print('entering: ', type(self).__name__)
+		self.FSM.action = getattr(actionsFSMlist, type(self).__name__) 
+		super(reg_roll_to_left, self).Enter()
+
+		old_state = self.FSM.prevState
+		if getCurFrame() != None:	
+			print('current frame is', getCurFrame())
+			self.FSM.action.s_se[0] = getCurFrame()
+		
+	def Execute(self):
+		print('executing: ', type(self).__name__)
+		dict = bge.logic.globalDict
+		self.FSM.stateLife += 1
+		own = getOwn()
+		if own['requestAction'] == 'reg_roll':
+			self.FSM.ToTransition('toreg_left_to_roll')
+		if transPlaying() == False and self.FSM.stateLife > 2:		
+			self.FSM.ToTransition('toreg_left')
+			transEndPlayer(self, FSM)
+		else:
+			actionPlayer(self, FSM)        
+	
+	def Exit(self):
+		print('exiting: ', type(self).__name__)	
+
+class reg_left_to_roll(State):
+	def __init__(self,FSM):
+		super(reg_left_to_roll, self).__init__(FSM) 
+		
+	def Enter(self):
+		print('entering: ', type(self).__name__)
+		self.FSM.action = getattr(actionsFSMlist, type(self).__name__) 
+		super(reg_left_to_roll, self).Enter()
+
+		old_state = self.FSM.prevState
+		if getCurFrame() != None:	
+			print('do the things', old_state.FSM.currentFrame, getCurFrame())
+			self.FSM.action.s_se[0] = getCurFrame()
+		
+	def Execute(self):
+		print('executing: ', type(self).__name__)
+		dict = bge.logic.globalDict
+		self.FSM.stateLife += 1
+		if transPlaying() == False and self.FSM.stateLife > 2:		
+			self.FSM.ToTransition('toreg_roll')
+			transEndPlayer(self, FSM)
+		else:
+			actionPlayer(self, FSM)	        
+	
+	def Exit(self):
+		print('exiting: ', type(self).__name__)		
+					 
+#===================================
+#====================================						
+
+class FSM(object):
+	def __init__ (self, character):
+
+		try:
+			self.char = self.char
+
+		except:	
+
+			self.char = character
+			self.states = {}
+			self.transitions = {}
+			self.curState = None
+			self.prevState = None
+			self.stateLife = 0
+			self.currentFrame = 0.0
+			self.name = ''
+			  
+			self.action = []
+
+			print('always init')
+	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 StateMachine(Char):
+	def __init__(self):
+		self.FSM = FSM(self)
+		
+		##STATES
+		self.FSM.AddState('reg_roll', reg_roll(self.FSM))
+		self.FSM.AddState('reg_opos', reg_opos(self.FSM))
+		self.FSM.AddState('reg_roll_to_opos', reg_roll_to_opos(self.FSM))
+		self.FSM.AddState('reg_opos_to_roll', reg_opos_to_roll(self.FSM))
+		self.FSM.AddState('reg_left', reg_left(self.FSM))
+		self.FSM.AddState('reg_left_to_roll', reg_left_to_roll(self.FSM))
+		self.FSM.AddState('reg_roll_to_left', reg_roll_to_left(self.FSM))
+
+		#TRANSITIONS
+		self.FSM.AddTransition('toreg_roll', Transition('reg_roll'))
+		self.FSM.AddTransition('toreg_opos', Transition('reg_opos'))
+		self.FSM.AddTransition('toreg_roll_to_opos', Transition('reg_roll_to_opos'))
+		self.FSM.AddTransition('toreg_opos_to_roll', Transition('reg_opos_to_roll'))
+		self.FSM.AddTransition('toreg_left', Transition('reg_left'))
+		self.FSM.AddTransition('toreg_left_to_roll', Transition('reg_left_to_roll'))
+		self.FSM.AddTransition('toreg_roll_to_left', Transition('reg_roll_to_left'))
+
+		if self.FSM.curState == None:
+			self.FSM.SetState('reg_roll')
+			self.FSM.ToTransition('toreg_roll')
+			print('      -= Initializing Action Player State Machine =-')
+	
+	def Execute(self):
+		self.FSM.Execute()    
+#====================================     
+r = StateMachine()
+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
+	if interupt_request():
+		print('interupt request')

scripts/actionsFSMlist.py

@@ -0,0 +1,131 @@
+TRANS_LAYER = 12
+MAIN_LAYER = 10
+
+reg_fliplist = ['reg_ollie', 'reg_nollie', 'reg_nollie', 'reg_kickflip', 'reg_varial_kickflip', 'reg_nollie_varial_kickflip', 'reg_nollie_varial_heelflip', 'fak_nollie_varial_heelflip', 'reg_varial_heelflip', 'reg_nollie_kickflip',  'reg_heelflip', 'reg_nollie_heelflip', 'reg_shuvit', 'reg_shuvit360', 'reg_fsshuvit360', 'reg_nollie_shuvit', 'fak_nollie_shuvit', 'reg_fsshuvit', 'fak_fsshuvit',  'reg_nollie_fsshuvit', 'reg_nollie_shuvit360', 'reg_nollie_fsshuvit', 'reg_brfoot', 'reg_frfoot', 'reg_blfoot', 'reg_flfoot', 'reg_inward_heelflip', 'reg_hardflip', 'reg_nollie_inward_heelflip', 'reg_nollie_hardflip', 'reg_offboard', 'reg_nollie_fsshuvit_360'] 
+fak_fliplist = ['fak_ollie', 'fak_nollie', 'fak_nollie', 'fak_kickflip', 'fak_varial_kickflip', 'fak_nollie_varial_kickflip', 'fak_nollie_varial_heelflip', 'fak_nollie_varial_heelflip', 'fak_varial_heelflip', 'fak_nollie_kickflip',  'fak_heelflip','fak_nollie_heelflip', 'fak_shuvit', 'fak_shuvit360', 'fak_fsshuvit360', 'fak_nollie_shuvit', 'fak_nollie_shuvit', 'fak_fsshuvit', 'fak_fsshuvit',  'fak_nollie_fsshuvit', 'fak_nollie_shuvit360', 'fak_nollie_fsshuvit', 'fak_brfoot', 'fak_frfoot', 'fak_blfoot', 'fak_flfoot', 'fak_inward_heelflip', 'fak_hardflip', 'fak_nollie_inward_heelflip', 'fak_nollie_hardflip', 'fak_offboard', 'fak_nollie_fsshuvit_360']     
+
+
+class a_class:
+    pass
+#------------------------------
+reg_roll = a_class()
+reg_roll.name = 'reg_roll'
+reg_roll.parent = []
+#reg_roll.siblings['fak_roll']
+reg_roll.s_action = 'nreg'
+reg_roll.s_se = [1, 60]
+reg_roll.d_action = 'a_reg'
+reg_roll.d_se = [0, 10]
+reg_roll.t_action = 'a_reg'
+reg_roll.t_se = [0, 10]
+reg_roll.stateLife = 1
+reg_roll.layer = MAIN_LAYER
+reg_roll.speed = 1
+reg_roll.mode = 0
+#------------------------------
+reg_opos = a_class()
+reg_opos.name = 'reg_opos'
+reg_opos.parent = ['reg_roll']
+reg_opos.parentTrans = 'toreg_opos_to_roll'
+reg_opos.requestAction = 'reg_opos'
+#reg_roll.siblings['']
+reg_opos.s_action = 'nopos'
+reg_opos.s_se = [1, 40]
+reg_opos.d_action = 'a_reg'
+reg_opos.d_se = [0, 10]
+reg_opos.t_action = 'a_reg'
+reg_opos.t_se = [0, 10]
+reg_opos.stateLife = 1
+reg_opos.layer = MAIN_LAYER
+reg_opos.speed = 1
+reg_opos.mode = 0
+#------------------------------
+reg_left = a_class()
+reg_left.name = 'reg_left'
+reg_left.parent = ['reg_roll']
+reg_left.parentTrans = 'toreg_left_to_roll'
+reg_left.requestAction = 'reg_turnLeft'
+reg_left.s_action = 'nreg_left'
+reg_left.s_se = [10, 10]
+reg_left.d_action = 'a_reg_left'
+reg_left.d_se = [0, 10]
+reg_left.t_action = 'a_reg'
+reg_left.t_se = [0, 10]
+reg_left.stateLife = 1
+reg_left.layer = MAIN_LAYER
+reg_left.speed = 1
+reg_left.mode = 0
+#------------------------------
+reg_roll_to_opos = a_class()
+reg_roll_to_opos.name = 'reg_roll_to_opos'
+reg_roll_to_opos.parent = ['reg_roll']
+reg_roll_to_opos.parentTrans = 'toreg_opos'
+reg_roll_to_opos.s_action = 'noposin'
+reg_roll_to_opos.s_se = [1, 20]
+reg_roll_to_opos.d_action = 'a_reg'
+reg_roll_to_opos.d_se = [0, 10]
+reg_roll_to_opos.t_action = 'a_reg'
+reg_roll_to_opos.t_se = [0, 10]
+reg_roll_to_opos.stateLife = 1
+reg_roll_to_opos.layer = TRANS_LAYER
+reg_roll_to_opos.speed = 1
+reg_roll_to_opos.mode = 0
+#------------------------------
+reg_opos_to_roll = a_class()
+reg_opos_to_roll.name = 'reg_opos_to_roll'
+reg_opos_to_roll.parent = ['reg_roll']
+reg_opos_to_roll.s_action = 'noposin'
+reg_opos_to_roll.s_se = [20, 1]
+reg_opos_to_roll.d_action = 'a_reg'
+reg_opos_to_roll.d_se = [0, 10]
+reg_opos_to_roll.t_action = 'a_reg'
+reg_opos_to_roll.t_se = [0, 10]
+reg_opos_to_roll.stateLife = 1
+reg_opos_to_roll.layer = TRANS_LAYER
+reg_opos_to_roll.speed = 1
+reg_opos_to_roll.mode = 0
+#------------------------------
+reg_roll_to_left = a_class()
+reg_roll_to_left.name = 'reg_roll_to_left'
+reg_roll_to_left.parent = ['reg_roll']
+reg_roll_to_left.s_action = 'nreg_left'
+reg_roll_to_left.s_se = [1, 10]
+reg_roll_to_left.d_action = 'a_reg'
+reg_roll_to_left.d_se = [0, 10]
+reg_roll_to_left.t_action = 'a_reg'
+reg_roll_to_left.t_se = [0, 10]
+reg_roll_to_left.stateLife = 1
+reg_roll_to_left.layer = TRANS_LAYER
+reg_roll_to_left.speed = .5
+reg_roll_to_left.mode = 0
+#------------------------------
+reg_left_to_roll = a_class()
+reg_left_to_roll.name = 'reg_left_to_roll'
+reg_left_to_roll.parent = ['reg_roll']
+reg_left_to_roll.s_action = 'nreg_left'
+reg_left_to_roll.s_se = [10, 1]
+reg_left_to_roll.d_action = 'a_reg'
+reg_left_to_roll.d_se = [0, 10]
+reg_left_to_roll.t_action = 'a_reg'
+reg_left_to_roll.t_se = [0, 10]
+reg_left_to_roll.stateLife = 1
+reg_left_to_roll.layer = TRANS_LAYER
+reg_left_to_roll.speed = .5
+reg_left_to_roll.mode = 0
+#------------------------------
+reg_left_to_roll = a_class()
+reg_left_to_roll.name = 'reg_ollie'
+reg_left_to_roll.parent = ['reg_roll']
+reg_left_to_roll.s_action = 'reg_ollie'
+reg_left_to_roll.s_se = [1, 20]
+reg_left_to_roll.d_action = 'a_reg_ollie'
+reg_left_to_roll.d_se = [1, 20]
+reg_left_to_roll.t_action = 't_reg_ollie'
+reg_left_to_roll.t_se = [1, 20]
+reg_left_to_roll.stateLife = 1
+reg_left_to_roll.layer = TRANS_LAYER
+reg_left_to_roll.speed = .5
+reg_left_to_roll.mode = 0
+#------------------------------
+
+#reg_ollie

scripts/camera.py

@@ -3,9 +3,10 @@ import bge
 import mathutils
 from mathutils import *
 scene = bge.logic.getCurrentScene()
-cont = bge.logic.getCurrentController()
-own = cont.owner
-def main():
+#cont = bge.logic.getCurrentController()
+#own = cont.owner
+def main(cont):
+    own = cont.owner
     dict = bge.logic.globalDict 
     camempty = scene.objects['camEmpty.001']
     controlcube = scene.objects['control_cube.002']
@@ -70,6 +71,7 @@ def main():
     #if 1 == 1:
     #if own['playback'] == False:
     if controlcube['driving'] == False:
+        LAST_GRIND = False
         if down.triggered == True and LAST_GRIND == False and walk == 0:
             hitPosition = down.hitPosition
             distance = own.getDistanceTo(hitPosition)
@@ -137,20 +139,38 @@ def main():
         obj = cont.owner
         cube = controlcube
         to = cube
+        #print(to.worldPosition)
+        to2 = to.worldPosition
+        pos = [to.worldPosition.x, to.worldPosition.y, to.worldPosition.z]
+        
+        pos[2] = pos[2] - .2
+        #print(pos)
+
         from2 = obj
+        #print(from2)
+        from3 = [from2.worldPosition.x, from2.worldPosition.y, from2.worldPosition.z]
+        from3[2] = from3[2] - .2
         distance = 0.0
         property = ""
         face = 1
         xray = 0
         poly = 0
-        hit = obj.rayCast( to, from2, distance, property, face, xray, poly)
+        hit = obj.rayCast( pos, from3, distance, property, face, xray, poly)
+        #bge.render.drawLine(pos,from3, [1,0,0])
         control = "control_cube.002"
         hitobj = hit[0]
         hitobj = str(hitobj)
         if hitobj != control and walk == 0:
+            
             cam.damping = .0 
-            if cam.height < 3:
+            if cam.height < 2:
                 cam.height = cam_height + .1
+                cam.max = cam.max - .2
+                #print('small move')
+            elif cam.height >= 2 and cam.height < 4:
+                cam.height = cam_height + .05
+                cam.max = cam.max - .05                
+                #print('big move')
     
     if dict['menu_idle_timer'] > 300:
         move_len = 2048
@@ -259,7 +279,9 @@ def main():
                 dict['cur_ccH_targetHeight'] = dict['cam_walk_height']
                 
         cam.min = dict['cam_walk_min'] 
-        cam.max = dict['cam_walk_max']        
+        cam.max = dict['cam_walk_max'] 
+
+        #print('walk cam')       
         #ccH_targetHeight = .9
     else:  
 
@@ -360,4 +382,4 @@ def main():
         pass    
     
                     
-main()
+#main()

scripts/co_ActionState.py

@@ -1,5 +1,5 @@
 import bge
-
+import actionsFSM
 
 def main():
 
@@ -880,7 +880,24 @@ def main():
         if l_actionState == 'fak-reg_roll' and requestAction in ['fak_pump_right', 'fak_pump_left']:
             requestAction = 'fak_pump'
         if l_actionState == 'reg-fak_roll' and requestAction in ['reg_pump_right', 'reg_pump_left']:
-            requestAction = 'reg_pump'            
+            requestAction = 'reg_pump'  
+
+        if l_actionState == 'reg_air-roll' and requestAction == 'reg_5050' and actionTimer > 5:
+            requestAction = 'reg_5050'
+            #print('doing the thing')
+        tl = ['reg_turnLeft', 'reg_turnRight', 'reg_turnLeft_out', 'reg_turnRight_out']    
+        if l_actionState in tl and requestAction not in tl:
+            requestAction = 'reg_roll' 
+            #print('doing the other thing') 
+
+        if l_actionState == 'reg_air-roll' and requestAction != 'reg_air-roll':
+            requestAction = 'reg_roll'      
+            #print('doing the third thing')
+
+        if l_actionState == 'reg_roll' and requestAction == 'reg_5050':
+            requestAction = 'reg_air'
+            #print('doing the 4th thing')    
+
                                                                                   
 #---------------------------------------------------                                                                                  
                                                                                   
@@ -4848,5 +4865,7 @@ def main():
     own['l_actionState'] = actionState
     own['l_requestAction'] = requestAction
     own['queueAction'] = queueAction
+
+    #actionsFSM.main(cont)
     
 main()

scripts/colors.py

@@ -52,7 +52,7 @@ def main():
     #print(dict['shirt_color'])
     scol = [dict['shirt_color_r'], dict['shirt_color_g'], dict['shirt_color_b'], 1]
     deckC = [dict['deck_color_r'], dict['deck_color_g'], dict['deck_color_b'], 1]
-    print(scol)
+    #print(scol)
     shirt.color = scol
     deck.color = deckC
     throw_deck.color = deckC

scripts/controller2.py

@@ -1583,6 +1583,8 @@ def main():
                     own.applyRotation( rotation, True) 
                     
     def air():
+        if r_ground.triggered == False and own['airup'] == 1:
+            own.alignAxisToVect(gray.hitNormal, 2, .03)
         if r_ground.triggered == False and own['airup'] == 0:
              
             distance = own.getDistanceTo(gray.hitPosition)
@@ -4353,22 +4355,39 @@ def main():
     own["last_sel"] = own["sel"]
     own["sel"] = bkBut  
 
-    if r_ground.triggered and own["jump_timer"] < 20 and own['rotz'] > .65:
-        force2 = [0.0, 0, dict['antibounce']]
-        #own.applyForce(force2, True)
-
-        gdist = ((own.worldPosition.z - r_ground.hitPosition[2]))  
-        #print(gdist)
-        if gdist < .2875 and gdist > .1:
-            #move = 2.875 - gdist
-            move = (.2875 - gdist)*.33
-            #move = (own.worldPosition.z + gdist)
-            if move > 0:
-                own.worldPosition.z = own.worldPosition.z + move
-            else:
-                own.worldPosition.z = own.worldPosition.z - move    
-            own.linearVelocity.z = 0
-           
+    if r_ground.triggered and own["jump_timer"] < 20:
+        #if own['rotz'] > .65:
+        #if own['rotz'] > .15: 
+        if 1 == 1:    
+            force2 = [0.0, 0, dict['antibounce']]
+            #own.applyForce(force2, True)
+
+            gdist = ((own.worldPosition.z - r_ground.hitPosition[2]))  
+            #print(gdist)
+            if gdist < .2875 and gdist > .1:
+                #move = 2.875 - gdist
+                move = (.2875 - gdist)*.33
+                #move = (own.worldPosition.z + gdist)
+                if move > 0:
+                    own.worldPosition.z = own.worldPosition.z + move
+                else:
+                    own.worldPosition.z = own.worldPosition.z - move    
+                own.linearVelocity.z = 0
+        else:
+            gdist = ((own.worldPosition.z - r_ground.hitPosition[2]))  
+            #print(gdist)
+            if gdist < .2875 and gdist > .1:
+                #move = 2.875 - gdist
+                #move = (.2875 - gdist)*.33
+                move = (.2875 - gdist)*.4
+                #move = (own.worldPosition.z + gdist)
+                if move > 0:
+                    own.worldPosition.z = own.worldPosition.z + move
+                else:
+                    own.worldPosition.z = own.worldPosition.z - move    
+                own.linearVelocity.z = 0            
+                
+    
 
     Axis = 2 
     Distance = -10
@@ -4386,14 +4405,20 @@ def main():
         if localHitDist < .287:
             own.localPosition[2] += (.287 - localHitDist)
             if localRay[2] != [0,0,-1] and grindHit == 0:
-                own.alignAxisToVect(localRay[2], 2, .5)
+                own.alignAxisToVect(localRay[2], 2, .75)
                 #print('moving local')
 
-
-    #rend = bge.render
+    # if own['LAST_GRIND'] == False and touched:
+    #     print('touching but not grinding')
+    #     if STANCE == 0:
+    #         own.applyMovement([-.05, 0, .01], True)
+    #     else:
+    #         own.applyMovement([.05, 0, .01], True)    
+    # #rend = bge.render
     #rend.drawLine(Start, End, [1,0,0,1])
     #print(own['rotz'])
 
+
     if own.linearVelocity.x > 10:
         own.linearVelocity.x = 10
     if (grindDar == False and r_ground.triggered and own['grindTouch'] == False) or own['jump_timer'] > 40:
@@ -4401,4 +4426,4 @@ def main():
     
     dict['walk'] = 0  
 
-    print(own["LAST_GRIND"])
+    #print(own["LAST_GRIND"])

scripts/scene_init.py

@@ -122,7 +122,19 @@ def main():
     else:
         print('not starting music', dict['music_player'])        
         
-    scene.world.envLightEnergy = dict['ambient_strength']   
+    
+
+    for x in scene.objects:
+        if 'hemi' in x:
+            if 'down' in x:
+                x.energy = dict['ambient_strength']
+            else:
+                x.energy = dict['ambient_strength'] * .7    
+
+
+
+    #scene.world.envLightEnergy = dict['ambient_strength']   
+    scene.world.envLightEnergy = 0
     
     cam['BC_BRIGHTNESS'] = dict['BC_BRIGHTNESS'] 
     cam['BC_CONTRAST'] = dict['BC_CONTRAST']

scripts/walk.py

@@ -11,7 +11,6 @@ def main(cont):
     
     scene = bge.logic.getCurrentScene()
     objList = scene.objects
-
     cont = GameLogic.getCurrentController() 
     obj = bge.logic.getCurrentScene().objects
     char = bge.constraints.getCharacter