sucked

scripts/FSM.py

@@ -97,6 +97,12 @@ class PlayerFSM(Char):
         'Example',
         'Startup',
         'Walk',
+        'WalkJump',
+        'WalkAir',
+        'WalkLand',
+        'WalkHang',
+        'WalkClimb',
+        'WalkHurdle',
         'Roll']
         
         for s in state_list:

scripts/StatesPlayer.py

@@ -29,7 +29,7 @@ class Example(State):
         
     def Execute(self):
         self.FSM.stateLife += 1
-        #self.FSM.ToTransition('toLand')
+        #self.FSM.ToTransition('toExample')
         
     def Exit(self):
         pass
@@ -65,21 +65,6 @@ class Walk(State):
     def Enter(self):
         self.FSM.stateLife = 1
         o = self.FSM.owner
-    
-        # if self.FSM.owner['stance']:
-        #     self.FSM.owner.applyRotation([0,0,3], True)
-        #     self.FSM.owner['stance'] = False
-        #     o['requestAction'] = 'fak_offboard' 
-        #     print('request fak offboard')            
-        # else:
-        #     o['requestAction'] = 'reg_offboard'                 
-        #     print('request reg offboard')            
-            #o['requestAction'] = 'fak_offboard'                          
-        
-        
-
-        
-
         super(Walk, self).Enter()        
         
     def Execute(self):
@@ -116,17 +101,7 @@ class Walk(State):
             o.linearVelocity.z = -10
         if dict['xBut'] == True or dict['kb_space'] == 1: 
             if dict['last_xBut'] == 0:
-                #killact(3)
-                #killact(4)
-                #killact(5)
-                #killact(6)
-                #killact(7)      
-                #if STANCE == 0:  
                 o['requestAction'] ='reg_jump'  
-                    #print('jump') 
-                #if STANCE == 1:
-                    #own['requestAction'] ='fak_jump'             
-                    #print('jump')
                 JUMPHEIGHT = 1100
                 force = [ 0.0, 0.0, JUMPHEIGHT]
                 # use local axis
@@ -135,16 +110,116 @@ class Walk(State):
                 if o.linearVelocity.z < 10:
                     o.applyForce(force, local)
                     o.linearVelocity.z += 5
-                    #o.linearVelocity.x = linvel.x
-                    #o.linearVelocity.y = linvel.y
-                    #own['walk_jump_timer'] = 6
+
+    def Exit(self):
+        pass
+
+
+#==================================== 
+            
+class WalkAir(State):
+    def __init__(self,FSM):
+        super(WalkAir, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(WalkAir, self).Enter()        
         
+    def Execute(self):
+        self.FSM.stateLife += 1
+        #self.FSM.ToTransition('toLand')
+        
+    def Exit(self):
+        pass
 
+#==================================== 
+            
+class WalkJump(State):
+    def __init__(self,FSM):
+        super(WalkJump, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(WalkJump, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        #self.FSM.ToTransition('toLand')
+        
     def Exit(self):
         pass
 
 #==================================== 
             
+class WalkLand(State):
+    def __init__(self,FSM):
+        super(WalkLand, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(WalkLand, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        #self.FSM.ToTransition('toLand')
+        
+    def Exit(self):
+        pass
+
+#==================================== 
+            
+class WalkHang(State):
+    def __init__(self,FSM):
+        super(WalkHang, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(WalkHang, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        #self.FSM.ToTransition('toLand')
+        
+    def Exit(self):
+        pass
+
+#==================================== 
+            
+class WalkClimb(State):
+    def __init__(self,FSM):
+        super(WalkClimb, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(WalkClimb, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        #self.FSM.ToTransition('toLand')
+        
+    def Exit(self):
+        pass                                
+
+#==================================== 
+            
+class WalkHurdle(State):
+    def __init__(self,FSM):
+        super(WalkClimb, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(WalkClimb, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        #self.FSM.ToTransition('toLand')
+        
+    def Exit(self):
+        pass                                
+
+
+#==================================== 
+            
 class Roll(State):
     def __init__(self,FSM):
         super(Roll, self).__init__(FSM)    

scripts/player.py

@@ -10,6 +10,13 @@ class Player:
 	def update(self):
 		self.FSM.Execute()
 
+	def get_ground_ray(self):
+		pass
+
+	def get_ground_dist(self, groundray):
+		pass
+
+
 def update(cont):
 	#print('-------------player updating----------------')
 	dict = bge.logic.globalDict

scripts/walk.py

@@ -460,36 +460,7 @@ def main(cont):
                         if (minDist is None or dist < minDist):
                             nearestObject = obj
                             minDist = dist
-                # if nearestObject != None:
-                #     #print(nearestObject)
-                #     obj = nearestObject
-                #     player_e = own.worldOrientation.to_euler()
-                #     player_pos = own.worldPosition
-                #     player_rotz = math.degrees(player_e[2])                
-                #     grinder_e = obj.worldOrientation.to_euler()
-                #     grinder_rotz = math.degrees(grinder_e[2])            
-                #     rot = player_rotz - grinder_rotz  
-                #     grinder_pos = obj.worldPosition 
-                #     worldVect = [1, 0, 0]
-                #     vect = obj.getAxisVect(worldVect)      
-                #     go = obj.worldOrientation
-                #     grinder_axis = [1,0,0] 
-                #     try: 
-                #         delta = player_pos - grinder_pos
-                        
-                #         delta = delta.cross(vect)
-                #         if delta[2] >= 0:
-                #             grindside = "right"
-                #         else:
-                #             grindside = "left"                    
-                #         deltamove = delta[2] * .1#.25
-                #         if STANCE == 0:
-                #             move = [-deltamove, 0, 0]
-                #         else:
-                #             move = [deltamove, 0, 0]                            
-                #         own.applyMovement(move, True)                    
-                #     except:
-                #         pass 
+
                 print('dropin')
                 if STANCE == 0: 
                     own['requestAction'] ='reg_dropin' 
@@ -867,243 +838,7 @@ def main(cont):
             except:
                 pass    
                           
-    # def switchcam():
-    #     if ltsBut == False and own['lastlts'] == True and rtsBut == False:
-    #         if own['camera'] == 1:
-    #             own['camera'] = 0
-    #         else:
-    #             own['camera'] = 1
-    #     if rtsBut == False and own['lastrts'] == True and ltsBut == False:
-    #         if own['camera'] == 2:
-    #             own['camera'] = 0
-    #         else:
-    #             own['camera'] = 2 
-    # #followcam 
-    # def move_followcam():
-    #     if own['camera'] == 2:
-    #         if own['lastbkBut'] == True and bkBut == False:
-    #             #print("activate move followcam") 
-    #             if own['move_followcam'] == False:
-    #                 own['move_followcam'] = True
-    #             else:
-    #                 own['move_followcam'] = False                       
-    #         if own['move_followcam'] == True:
-    #             camspeed1 = .015
-    #             camspeed2 = .055
-    #             camrot1 = .005
-    #             camrot2 = .02
-    #             #up
-    #             if lUD < -0.080:
-    #                 followcam.actuators["up"].dLoc = [ 0, 0, -camspeed2]
-    #                 cont.activate(followcam.actuators["up"])
-    #                 #print("fastup")
-    #             else:
-    #                 cont.deactivate(followcam.actuators["up"])    
-    # #            #down    
-    #             if lUD > .080:
-    #                 followcam.actuators["down"].dLoc = [ 0, 0, camspeed2]
-    #                 cont.activate(followcam.actuators["down"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["down"])                    
-    # #            #left
-    #             #if lLR < -0.080:
-    #             if lLR > 0.080:    
-    #                 followcam.actuators["left"].dLoc = [-camspeed2, 0, 0]                
-    #                 cont.activate(followcam.actuators["left"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["left"])                    
-    # #            #right
-    #             #if lLR > 0.080: 
-    #             if lLR < -0.080:         
-    #                 followcam.actuators["right"].dLoc = [camspeed2, 0, 0]                
-    #                 cont.activate(followcam.actuators["right"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["right"])  
-    #             #up
-    #             if rUD < -0.080:
-    #                 followcam.actuators["rotup"].dLoc = [0, 0, camrot2]
-    #                 cont.activate(followcam.actuators["rotup"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["rotup"])    
-    # #            #down    
-    #             if rUD > .080:
-    #                 followcam.actuators["rotdown"].dLoc = [0, 0, -camrot2]                
-    #                 cont.activate(followcam.actuators["rotdown"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["rotdown"])                    
-    # #            #left
-    #             if rLR < -0.080:
-    #                 followcam.actuators["rotleft"].dRot = [0, 0, camrot2]                
-    #                 cont.activate(followcam.actuators["rotleft"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["rotleft"])                    
-    # #            #right
-    #             if rLR > 0.080:         
-    #                 followcam.actuators["rotright"].dRot = [0, 0, -camrot2]
-    #                 cont.activate(followcam.actuators["rotright"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["rotright"]) 
-
-    # #*********************************************                
-                    
-    #             if lUD > -0.080 and lUD < -0.030:
-    #                 followcam.actuators["up"].dLoc = [ 0, 0, -camspeed1]
-    #                 cont.activate(followcam.actuators["up"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["up"])    
-    # #            #down    
-    #             if lUD < .080 and lUD > .03:
-    #                 followcam.actuators["down"].dLoc = [ 0, 0, camspeed1]                
-    #                 cont.activate(followcam.actuators["down"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["down"])                    
-    # #            #left
-    #             if lLR > -0.080 and lLR < -0.030:
-    #                 followcam.actuators["left"].dLoc = [-camspeed1, 0, 0]                
-    #                 cont.activate(followcam.actuators["left"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["left"])                    
-    # #            #right
-    #             if lLR < .080 and lLR > .03:       
-    #                 followcam.actuators["right"].dLoc = [camspeed1, 0, 0]
-    #                 cont.activate(followcam.actuators["right"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["right"])  
-    #             #up
-    #             if rUD > -0.080 and rUD < -0.030:
-    #                 followcam.actuators["rotup"].dRot = [camrot1, 0, 0]                
-    #                 cont.activate(followcam.actuators["rotup"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["rotup"])    
-    # #            #down    
-    #             if rUD < .080 and rUD > .03:
-    #                 followcam.actuators["rotdown"].dRot = [-camrot1, 0, 0]                
-    #                 cont.activate(followcam.actuators["rotdown"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["rotdown"])                    
-    # #            #left
-    #             if rLR > -0.080 and rLR < -0.030:
-    #                 followcam.actuators["rotleft"].dRot = [0, 0, camrot1]
-    #                 cont.activate(followcam.actuators["rotleft"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["rotleft"])                    
-    # #            #right
-    #             if rLR < .080 and rLR > .03:         
-    #                 followcam.actuators["rotright"].dRot = [0, 0, -camrot1]
-    #                 cont.activate(followcam.actuators["rotright"])
-    #             else:
-    #                 cont.deactivate(followcam.actuators["rotright"])                       
-    # def move_flycam():
-    #     if own['camera'] == 1:
-    #         if own['lastbkBut'] == True and bkBut == False: 
-    #             if own['move_freecam'] == False:
-    #                 own['move_freecam'] = True
-    #             else:
-    #                 own['move_freecam'] = False                       
-    #         if own['move_freecam'] == True:
-    #             camspeed1 = .015
-    #             camspeed2 = .055
-    #             camrot1 = .005
-    #             camrot2 = .02
-    #             #up
-    #             if lUD < -0.080:
-    #                 freecam.actuators["up"].dLoc = [ 0, 0, -camspeed2]
-    #                 cont.activate(freecam.actuators["up"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["up"])    
-    # #            #down    
-    #             if lUD > .080:
-    #                 freecam.actuators["down"].dLoc = [ 0, 0, camspeed2]
-    #                 cont.activate(freecam.actuators["down"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["down"])                    
-    # #            #left
-    #             if lLR < -0.080:
-    #                 freecam.actuators["left"].dLoc = [-camspeed2, 0, 0]                
-    #                 cont.activate(freecam.actuators["left"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["left"])                    
-    # #            #right
-    #             if lLR > 0.080:         
-    #                 freecam.actuators["right"].dLoc = [camspeed2, 0, 0]                
-    #                 cont.activate(freecam.actuators["right"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["right"])  
-    #             #up
-    #             if rUD < -0.080:
-    #                 freecam.actuators["rotup"].dRot = [camrot2, 0, 0]
-    #                 cont.activate(freecam.actuators["rotup"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["rotup"])    
-    # #            #down    
-    #             if rUD > .080:
-    #                 freecam.actuators["rotdown"].dRot = [-camrot2, 0, 0]                
-    #                 cont.activate(freecam.actuators["rotdown"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["rotdown"])                    
-    # #            #left
-    #             if rLR < -0.080:
-    #                 freecam.actuators["rotleft"].dRot = [0, 0, camrot2]                
-    #                 cont.activate(freecam.actuators["rotleft"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["rotleft"])                    
-    # #            #right
-    #             if rLR > 0.080:         
-    #                 freecam.actuators["rotright"].dRot = [0, 0, -camrot2]
-    #                 cont.activate(freecam.actuators["rotright"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["rotright"]) 
-
-    # #*********************************************                
                     
-    #             if lUD > -0.080 and lUD < -0.030:
-    #                 freecam.actuators["up"].dLoc = [ 0, 0, -camspeed1]
-    #                 cont.activate(freecam.actuators["up"])
-    #                 #print(lUD)
-    #             else:
-    #                 cont.deactivate(freecam.actuators["up"])    
-    # #            #down    
-    #             if lUD < .080 and lUD > .03:
-    #                 freecam.actuators["down"].dLoc = [ 0, 0, camspeed1]                
-    #                 cont.activate(freecam.actuators["down"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["down"])                    
-    # #            #left
-    #             if lLR > -0.080 and lLR < -0.030:
-    #                 freecam.actuators["left"].dLoc = [-camspeed1, 0, 0]                
-    #                 cont.activate(freecam.actuators["left"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["left"])                    
-    # #            #right
-    #             if lLR < .080 and lLR > .03:       
-    #                 freecam.actuators["right"].dLoc = [camspeed1, 0, 0]
-    #                 cont.activate(freecam.actuators["right"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["right"])  
-    #             #up
-    #             if rUD > -0.080 and rUD < -0.030:
-    #                 freecam.actuators["rotup"].dRot = [camrot1, 0, 0]                
-    #                 cont.activate(freecam.actuators["rotup"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["rotup"])    
-    # #            #down    
-    #             if rUD < .080 and rUD > .03:
-    #                 freecam.actuators["rotdown"].dRot = [-camrot1, 0, 0]                
-    #                 cont.activate(freecam.actuators["rotdown"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["rotdown"])                    
-    # #            #left
-    #             if rLR > -0.080 and rLR < -0.030:
-    #                 freecam.actuators["rotleft"].dRot = [0, 0, camrot1]
-    #                 cont.activate(freecam.actuators["rotleft"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["rotleft"])                    
-    # #            #right
-    #             if rLR < .080 and rLR > .03:         
-    #                 freecam.actuators["rotright"].dRot = [0, 0, -camrot1]
-    #                 cont.activate(freecam.actuators["rotright"])
-    #             else:
-    #                 cont.deactivate(freecam.actuators["rotright"])                     
     if r_ground.triggered == False:
         cont.deactivate(own.actuators["walk_align"])
     else: