sun

assets/levels/scratch/level.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:59be75f7d28822ee6fd219d2f812c7411f69ccbd2679e1f3b67c71b3aa7396d5
-size 580320
+oid sha256:80da2750251e443d10fe87c4831cbd303754d9a8f43b0cd447faca8b2a184956
+size 21404212

assets/ramps.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:5395502faddbee5158b7c9ffd14807408fbb2a6b14b148db93ef53ea011a4a9b
-size 48154268
+oid sha256:7f0ca585c24b56ca66641f6ebeec9b3525f19f757b6857a8c1ac9fb957421066
+size 80413544

assets/user2.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:ab1b42cf5d4aee552dc3f4f15e5e04b0c16882a41ce75c79726a9dceb04b1463
-size 662960
+oid sha256:591f877f598327200b89c9518b9ba7e8aaefe0f5b69957836fbf0044cb26b5e5
+size 3442504

config.ini

 
 #camera 
 #######
-cam_height = -0.1
+cam_height = -0.3
 focal_length = 12
 cam_min = 2.0
 cam_max = 4.4
 
 shirt_logo = 2
 
-shirt_color_r = 0.4
-shirt_color_g = 0.03
-shirt_color_b = 0.03
+shirt_color_r = 0
+shirt_color_g = 0
+shirt_color_b = 0
 
-shoe_color_r = 0.31
-shoe_color_g = 0.23
-shoe_color_b = 0
+shoe_color_r = 0.69
+shoe_color_g = 0.69
+shoe_color_b = 0.67
 #-----------------
 
 #deck settings

scripts/FSM.py

         self.stateLife = 0
         self.owner = owner
         self.name = None
+        self.last_state_notes = None
         
     def AddTransition(self, transName, transition):
         self.transitions[transName] = transition
         'WalkHang',
         'WalkClimb',
         'WalkHurdle',
+        'WalkOnboard',
+        'AirOnboard',
+        'Offboard', 
+        'Dropin',
         'Roll',
         'Ragdoll']
         

scripts/StatesPlayer.py

 import bge
 dict = bge.logic.globalDict
+import sound_man
 #====================================     
 
 State = type("State", (object,), {})
         #print(o.worldPosition.z)
         #print(o['getonboard'], 'dict onboard')
         #print(dict['walk'], 'fsm walk walk')
-        if self.FSM.stateLife == 2:
-            if o['stance']:
-                o.applyRotation([0,0,3.14], True)
-                o['stance'] = False
+        # if self.FSM.stateLife == 2:
+        #     if o['stance']:
+        #         o.applyRotation([0,0,3.14], True)
+        #         o['stance'] = False
         #         o['requestAction'] = 'fak_offboard' 
         #         print('request fak offboard')            
         #     else:
             dist = c.get_ground_dist(ground_rays)
             if dist > .7:
                 self.FSM.ToTransition('toWalkAir')
-                print('---falling')
+                #print('---falling')
             else:
                 c.set_walk_z(dist)
             #print(dist, 'setting height')
         o = self.FSM.owner.obj
         #print(o['getonboard'], 'getonboard')
 
-
-
+        
         if dict['walk'] == 0:
             o['getonboard'] = True
-            self.FSM.ToTransition('toRoll')
+            #self.FSM.ToTransition('toRoll')
+            self.FSM.ToTransition('toWalkOnboard')
             #print('onboard', dict['walk'], o['getonboard'])
+        if dict['yBut'] == 1 and dict['last_yBut'] == 0:
+        
+            
+            dropin = self.check_dropin()
+            print('-----dropin', dropin)
+            if dropin == None:
+                o['getonboard'] = True
 
+                self.FSM.ToTransition('toWalkOnboard')
+            else:
+                self.FSM.owner.dropin_obj = dropin
+                self.FSM.ToTransition('toDropin')
 
 
 
-
-        if dict['yBut'] == 1 and dict['last_yBut'] == 0:
-            o['getonboard'] = True
-            self.FSM.ToTransition('toRoll')
+    def check_dropin(self):
+        dr = None
+        ground_rays = self.FSM.owner.get_dropin_rays()
+        for x in ground_rays:
+            if x[0] != None:
+                #print(x[0], '---checked')
+                if 'coping' in x[0]:
+                    print('dropin collided')
+                    dr = x
+        return dr
 
     def check_jump(self):
         if dict['xBut'] == True or dict['kb_space'] == 1: 
             if dict['last_xBut'] == 0:
                 self.FSM.ToTransition('toWalkJump')
+                
 
     def idle_blend(self):
         arm = self.FSM.owner.arm
         #     #tw = self.turn_weight
         #     arm.stopAction(4)
         #     arm.playAction('bwalk_left', 1,60, layer=4, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=tw)
-
+            #print('walk_weight', self.walk_weight)
+            if self.walk_weight < .8:
+                if frame > 15:
+                    if self.FSM.owner.step == False:
+                        self.FSM.owner.step = True
+                        
+                        if frame < 23:
+                            print('step left')
+                            dict['camera']['sndmgr'].queue_sound(['s_l_1', self.FSM.owner.obj, dict['camera']])
+                else:
+                    if self.FSM.owner.step == True:
+                        self.FSM.owner.step = False
+                        if frame < 8:
+                            dict['camera']['sndmgr'].queue_sound(['s_r_1', self.FSM.owner.obj, dict['camera']])
+                            print('step right')
+                    
+            # if frame > 15 and self.FSM.owner.step:
+            #     self.FSM.owner.step = True
+            #     print('step left')
+            # if frame < 15 and not self.FSM.owner.step:
+            #     self.FSM.owner.step = False
+            #     print('step right')
+            #print('frame', frame)
 
     def get_walk_weight(self):
         #print(self.FSM.owner.linearVelocity.y) 
         ground_rays = self.FSM.owner.get_ground_ray() 
 
         self.FSM.owner.check_throw()
+        self.check_onboard()
+        self.FSM.owner.align_walk_z()
         if ground_rays[0][0] != None:
             dist = self.FSM.owner.get_ground_dist(ground_rays)
             if dist < .4:
                         self.FSM.owner.obj.worldPosition.z = hang_ray[1].z - 1
                         self.FSM.ToTransition('toWalkHang')
         
+    def check_onboard(self):
+        o = self.FSM.owner.obj
+        # if dict['walk'] == 0:
+        #     o['getonboard'] = True
+        #     self.FSM.ToTransition('toWalkOnboard')
+        if dict['yBut'] == 1 and dict['last_yBut'] == 0:
+            o['getonboard'] = True
+            #self.FSM.ToTransition('toWalkOnboard')
+            self.FSM.ToTransition('toAirOnboard')
+
     def Exit(self):
         self.FSM.owner.arm.stopAction(0)
         self.FSM.owner.arm.stopAction(1)
         
     def Enter(self):
         self.FSM.stateLife = 1
-
+        dict['camera']['sndmgr'].queue_sound(['walk_grunt', self.FSM.owner.obj, dict['camera']])
         arm = self.FSM.owner.arm
         deck = self.FSM.owner.deck_arm
         #arm.playAction('a_jump_t', 1, 23, layer=3, play_mode=0, speed=1, blendin=5)
         o = self.FSM.owner.obj
 
         moving = self.FSM.owner.walk_movement()              
-
+        self.check_onboard()
         if self.FSM.stateLife == 10:
                 force = [ 0.0, 0.0, dict['walk_jump_force']]
                 if o.linearVelocity.z < 10:
 
         if self.FSM.stateLife > 27:
             self.FSM.ToTransition('toWalkAir')
+
+    def check_onboard(self):
+        o = self.FSM.owner.obj
+        # if dict['walk'] == 0:
+        #     o['getonboard'] = True
+        #     self.FSM.ToTransition('toWalkOnboard')
+        if dict['yBut'] == 1 and dict['last_yBut'] == 0:
+            o['getonboard'] = True
+            self.FSM.ToTransition('toAirOnboard')            
         
     def Exit(self):
         pass
         #self.FSM.owner.arm.playAction('a_jump_t', 23, 50, layer=5, play_mode=0, speed=1, blendin=5)
         self.FSM.owner.arm.playAction('c_land', 0, 50, layer=1, play_mode=0, speed=1, blendin=5)
         self.FSM.owner.deck_arm.playAction('b_walk_land', 0, 50, layer=1, play_mode=0, speed=1, blendin=5)
+        dict['camera']['sndmgr'].queue_sound(['walk_land', self.FSM.owner.obj, dict['camera']])
         #c_land
         super(WalkLand, self).Enter()        
         
         self.FSM.stateLife = 1
         self.FSM.owner.arm.playAction('c_braced_hang', 0, 36, layer=2, play_mode=0, speed=1, blendin=10)
         self.moveable = False
+        dict['camera']['sndmgr'].queue_sound(['walk_hang', self.FSM.owner.obj, dict['camera']])
+        self.FSM.owner.drop_deck()
         #self.FSM.owner.arm.playAction('c_braced_hang', 36, 50, layer=1, play_mode=1, speed=1, blendin=10)
         super(WalkHang, self).Enter()        
         
 
         if hang_ray[0] != None:
             hr_dist = self.FSM.owner.get_hang_dist(hang_ray)
-            print(hr_dist, 'hang dist')
+            #print(hr_dist, 'hang dist')
             if hr_dist < .5:
                 self.FSM.owner.obj.linearVelocity = [0,0,0]
                 self.FSM.owner.obj.worldPosition.z = hang_ray[1].z  - 1
             if hang_align_ray[0] != None:
-                print(hang_align_ray[0])
+                #print(hang_align_ray[0])
                 v = hang_align_ray[2]
                 self.FSM.owner.obj.alignAxisToVect(v, 0, .5)    
         else:
     def Enter(self):
         self.FSM.stateLife = 1
         self.FSM.owner.arm.playAction('c_wallclimb', 1, 50, layer=3, play_mode=0, speed=1, blendin=10)
+        dict['camera']['sndmgr'].queue_sound(['walk_climb', self.FSM.owner.obj, dict['camera']])
         super(WalkClimb, self).Enter()        
         
     def Execute(self):
 #==================================== 
 
             
-class Example(State):
+class WalkOnboard(State):
     def __init__(self,FSM):
-        super(Example, self).__init__(FSM)    
+        super(WalkOnboard, self).__init__(FSM)    
         
     def Enter(self):
         self.FSM.stateLife = 1
-        super(Example, self).Enter()        
+        self.FSM.owner.walking = False
+        self.FSM.owner.obj['getonboard'] = False
+        if self.FSM.owner.throw_deck != None:
+            self.FSM.owner.throw_deck.endObject()
+            self.FSM.owner.throw_deck = None
+            self.FSM.owner.show_deck()
+        dict['walking'] = False
+        self.FSM.owner.obj['walking'] = False
+        self.FSM.owner.obj['requestAction'] = 'reg_onboard'
+        self.FSM.owner.obj['getoffboard'] == False
+        self.FSM.owner.obj.applyForce([-300, 0, 0], True)
+        print('walkonboard entered')
+        super(WalkOnboard, self).Enter()        
         
     def Execute(self):
         self.FSM.stateLife += 1
-        #self.FSM.ToTransition('toExample')
+        self.FSM.ToTransition('toRoll')
         
     def Exit(self):
         pass
 
 #==================================== 
 
+
             
-class Example(State):
+class AirOnboard(State):
     def __init__(self,FSM):
-        super(Example, self).__init__(FSM)    
+        super(AirOnboard, self).__init__(FSM)    
         
     def Enter(self):
         self.FSM.stateLife = 1
-        super(Example, self).Enter()        
-        
-    def Execute(self):
-        self.FSM.stateLife += 1
-        #self.FSM.ToTransition('toExample')
-        
-    def Exit(self):
-        pass
+        self.FSM.owner.walking = False
+        self.FSM.owner.obj['getonboard'] = False
+        if self.FSM.owner.throw_deck != None:
+            self.FSM.owner.throw_deck.endObject()
+            self.FSM.owner.throw_deck = None
+            self.FSM.owner.show_deck()
+        dict['walking'] = False
+        self.FSM.owner.obj['walking'] = False
+        #self.FSM.owner.obj['requestAction'] = 'reg_onboard'
 
-#==================================== 
+        self.FSM.owner.arm.playAction('c_land', 0, 50, layer=1, play_mode=0, speed=1, blendin=5)
+        self.FSM.owner.deck_arm.playAction('b_walk_land', 0, 50, layer=1, play_mode=0, speed=1, blendin=5)
 
-            
-class Example(State):
-    def __init__(self,FSM):
-        super(Example, self).__init__(FSM)    
-        
-    def Enter(self):
-        self.FSM.stateLife = 1
-        super(Example, self).Enter()        
+        self.FSM.owner.obj['getoffboard'] == False
+        self.FSM.owner.obj.applyForce([-300, 0, 0], True)
+        print('air entered')
+        super(AirOnboard, self).Enter()        
         
     def Execute(self):
         self.FSM.stateLife += 1
-        #self.FSM.ToTransition('toExample')
+        print('@@@@@@@@@@@@@@@@@@@@@@@@@@@air ob')
+        self.FSM.ToTransition('toRoll')
         
     def Exit(self):
         pass
         
     def Enter(self):
         self.FSM.stateLife = 1
-        self.FSM.owner.walking = False
-        self.FSM.owner.obj['getonboard'] = False
-        dict['walking'] = False
+        # self.FSM.owner.obj['getoffboard'] == False
+        # dict['walk'] = 0
+        print('roll entered')
         super(Roll, self).Enter()        
         
     def Execute(self):
         if dict['walk'] == 1 or self.FSM.owner.obj['getoffboard'] == True:
             dict['walk'] = 1
             self.FSM.owner.obj['getoffboard'] = True
-            self.FSM.ToTransition('toWalk')
-            print('fsm to walk')
+            #self.FSM.ToTransition('toWalk')
+            self.FSM.ToTransition('toOffboard')
+            print('fsm to walk', dict['walk'], self.FSM.owner.obj['getoffboard'])
         if self.FSM.owner.obj['fall'] == True:
             self.FSM.ToTransition('toRagdoll')    
-        print('rolling')
+        #print('rolling')
         #self.FSM.ToTransition('toLand')
         
     def Exit(self):
 
 #==================================== 
 
+class Offboard(State):
+    def __init__(self,FSM):
+        super(Offboard, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        
+        o = self.FSM.owner.obj
+        if o['stance']:
+            o.applyRotation([0,0,3.14], True)
+            o['stance'] = False
+            self.FSM.owner.arm.playAction('fak_noffboard', 0,24, layer=2, play_mode=0, speed=1, blendin=0)
+            self.FSM.owner.deck_arm.playAction('b_reg_offboard', 0,30, layer=2, play_mode=0, speed=1, blendin=0)
+        else:
+            self.FSM.owner.arm.playAction('reg_noffboard', 0,40, layer=2, play_mode=0, speed=1, blendin=0)
+            self.FSM.owner.deck_arm.playAction('b_reg_offboard', 0,40, layer=2, play_mode=0, speed=1, blendin=0)
+        print('fsm getting off board')
+        super(Offboard, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        
+        self.FSM.ToTransition('toWalk')
+        
+    def Exit(self):
+        pass
+#==================================== 
+
 class Ragdoll(State):
     def __init__(self,FSM):
         super(Ragdoll, self).__init__(FSM)    
         
     def Enter(self):
         self.FSM.stateLife = 1
+        self.FSM.owner.obj['ragdoll_active'] = True
+        self.FSM.owner.drop_deck()
+        print('ragdoll_player_fsm entered')
         super(Ragdoll, self).Enter()        
         
     def Execute(self):
         if dict['yBut'] == 1:
             self.FSM.owner.obj['fall'] = False
             self.FSM.owner.cont.activate(self.FSM.owner.cont.actuators['walk'])
-            self.FSM.ToTransition('toWalk')
+            #self.FSM.ToTransition('toWalk')
+            self.FSM.ToTransition('toOffboard')
+        self.FSM.owner.move_walk_cam()
+    def Exit(self):
+        print('ragdoll_player_fsm exited')
+        self.FSM.owner.obj['ragdoll_active'] = False
+        #pass                                
+
+#==================================== 
+            
+class Dropin(State):
+    def __init__(self,FSM):
+        super(Dropin, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        if self.FSM.owner.throw_deck != None:
+            self.FSM.owner.throw_deck.endObject()
+            self.FSM.owner.throw_deck = None
+            self.FSM.owner.show_deck()
+        self.FSM.owner.arm.playAction('reg_dropin3', 30, 50, layer=2, play_mode=0, speed=1, blendin=5)
+        self.FSM.owner.deck_arm.playAction('b_reg_dropin', 30, 50, layer=2, play_mode=0, speed=1, blendin=5)
+        self.out_triggered = False
+        # #player armature action name, start, end frames
+        # 'reg_dropin3', 30, 50,
+        # #deck action name, start, end frames  
+        # 'b_reg_dropin', 30, 50,
+        # #layer, speed, mode (0 = play, 1 = loop), blendin
+        # 1, .5, 0, 15,
+        # #intro, length
+
+        super(Dropin, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        print('dropin')
+        eu = self.FSM.owner.get_vert_rot(self.FSM.owner.obj, self.FSM.owner.dropin_obj[0])
+        #print(eu, 'eu')
+        
+        self.FSM.owner.arm.playAction('reg_dropin3', 50, 50, layer=1, play_mode=1, speed=1, blendin=5)
+        self.FSM.owner.deck_arm.playAction('b_reg_dropin', 50, 50, layer=1, play_mode=1, speed=1, blendin=5)
+        
+        if dict['last_yBut'] == True and dict['yBut'] == False:
+            self.out_triggered = True
+        
+        if self.out_triggered:
+            self.FSM.owner.arm.playAction('reg_dropin3', 60, 80, layer=2, play_mode=0, speed=1, blendin=5)
+            self.FSM.owner.deck_arm.playAction('b_reg_dropin', 60, 80, layer=2, play_mode=0, speed=1, blendin=5)
+            self.FSM.owner.obj.applyForce([-15, 0, 0], True)
+            self.FSM.owner.obj.applyRotation([0, -.01, 0], True)
+
+        else:
+            self.FSM.owner.move_to_te()
+
+        if self.FSM.owner.arm.getActionFrame(2)> 78:
+            
+            self.FSM.ToTransition('toRoll')
+
+        self.FSM.owner.move_walk_cam()
+
+        
         
+
+
     def Exit(self):
-        pass                                
+        self.FSM.owner.obj['getonboard'] = True
+        self.FSM.owner.walking = False
+        #self.FSM.owner.obj['getonboard'] = False
+        dict['walking'] = False
+        self.FSM.owner.obj['walking'] = False
+        self.FSM.owner.obj['requestAction'] = 'reg_air'
+        self.FSM.owner.obj['getoffboard'] == False
 
-#==================================== 
+
+
+#==================================== 

scripts/actionPlayer.py

 
 
 		#-----------------------
-		#print(own['aState'], newState, rA)
+		#print(own['aState'], newState, rA, own['l_aState'])
 		#print()
 		if newState != '':
 			own['aState'] = newState 

scripts/actionsFSMlist.py

 	#intro, length
 	None, 0,
 	#exits
-	['fak_idle', 'fak_offboard', 'reg_offboard' 'fak_turnLeft', 'fak_turnRight', 'fak_opos', 'fak_nopos', 'fak_pump', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
+	['fak_idle', 'fak_offboard', 'reg_offboard','fak_turnLeft', 'fak_turnRight', 'fak_opos', 'fak_nopos', 'fak_pump', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
 	#force exit, frame
 	None, 0,
 	#opposite
 	'reg_roll')
 
+#not working
 fak_turnLeft = a_class(
 	#player armature action name, start, end frames
 	'nfak_left', 10, 30,
 	#intro, length
 	None, 0,
 	#exits
-	['fak_roll', 'fak_opos', 'fak_nopos', 'fak_pump', 'fak_pump_left', 'fak_pump_right', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right', 'reg_turnRight'],
+	['fak_turnRight', 'fak_roll', 'fak_opos', 'fak_nopos', 'fak_pump', 'fak_pump_left', 'fak_pump_right', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right', 'reg_turnRight'],
 	#force exit, frame
 	None, 0,
 	#opposite
 	#intro, length
 	None, 0,
 	#exits
-	['fak_roll', 'fak_opos', 'fak_nopos', 'fak_pump', 'fak_pump_left', 'fak_pump_right', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right', 'reg_turnLeft'],
+	['fak_turnLeft', 'fak_roll', 'fak_opos', 'fak_nopos', 'fak_pump', 'fak_pump_left', 'fak_pump_right', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right', 'reg_turnLeft'],
 	#force exit, frame
 	None, 0,
 	#opposite

scripts/boneRecord.py

 dict = bge.logic.globalDict
 dict['replay_record_length']
 
-bone_list = ["foot.ik.R", "foot.ik.L", "knee.pt.ik.R", "knee.pt.ik.L", "hips", "root", "spine", "spine-1", "chest", "chest-1", "clavicle.L", "clavicle.R", "deltoid.L", "deltoid.R", "upper_arm.fk.L", "upper_arm.fk.R",  "forearm.fk.L", "forearm.fk.R", "hand.fk.L", "hand.fk.R", "neck", "head", "master"]
+bone_list = ["foot.ik.R", "foot.ik.L", "knee.pt.ik.R", "knee.pt.ik.L", "hips", "root", "spine", "spine-1", "chest", "chest-1", "clavicle.L", "clavicle.R", "deltoid.L", "deltoid.R", "upper_arm.fk.L", "upper_arm.fk.R",  "forearm.fk.L", "forearm.fk.R", "hand.fk.L", "hand.fk.R", "neck", "head", "master", 
+    'foot.rev.R', 'foot.rev.L', 'shin.ik.R', 'shin.ik.L', 'toe.rev.R', 'toe.rev.L']
 
 deck_list = ['main', 'turn']
 
 #bone_list = ['root', 'head']
 
-def Record():    
+def Record():   
+    print('bone recording') 
     scene = bge.logic.getCurrentScene()
     #own = cont.owner
     master = scene.objects['control_cube.002']
     cam = scene.objects['Camera.003']
     armature = scene.objects['Char4']
     deck = scene.objects['deck_arm']
-    #print('bone recording')
     if 'dataList' not in master:
         for x in bone_list:
             master['dataList'] = True

scripts/camera.py

 
 ################
     multer = .02
-    if dict['walk'] == 1 and not controlcube['ragdoll_active']:
+    if dict['walk'] == 1 and controlcube['ragdoll_active'] == False:
         if dict['cur_ccH_targetHeight'] < dict['cam_walk_height']:
             dist = dict['cam_walk_height'] - dict['cur_ccH_targetHeight']
 
         cam.max = dict['cam_walk_max']
 
     else:
-
         if dict['cur_ccH_targetHeight'] < dict['cch_targetHeight']:
             dist = dict['cur_ccH_targetHeight'] - dict['cch_targetHeight']
             dict['cur_ccH_targetHeight'] = dict['cur_ccH_targetHeight'] - (dist * multer)

scripts/controller2.py

             if LAST_LEFT_FAK == 0 or (playing_action_frame > (LAND_END - 2) and playing_action_frame < (LAND_END - 1)):
                 LAST_LEFT_FAK = 1
             own["LAST_LEFT_FAK"] = 1
+            
     def fak_stance_left_off():
         LAST_LEFT_FAK = own["LAST_LEFT_FAK"]
         own["LAST_LEFT_FAK"] = 0
                 own['requestAction'] = 'fak_turnRight'
             LAST_RIGHT_FAK = own["LAST_RIGHT_FAK"]
             own["LAST_RIGHT_FAK"] = 1
+
     def fak_stance_right_off():
         LAST_RIGHT_FAK = own["LAST_RIGHT_FAK"]
         own["LAST_RIGHT_FAK"] = 0
                     pass
 
     def getoffboard():
-        lasty = own['lasty']
+        #lasty = own['lasty']
+        lasty = dict['last_yBut']
         getoffboard = own['getoffboard']
         # if getoffboard == 1 and own['fall'] == False:
         #     own['getoffboard'] = 0
         if (yBut == True and lasty == False) or dict['kb_q'] == 3:
             own['getoffboard'] = 1
 
+
+
     def switchcam():
         pass
     #    if ltsBut == False and own['lastlts'] == True and rtsBut == False:
 
     def wallride_sound():
         sact = own.actuators["wallSound"]
+        # if 'aState' not in own:
+        #     own['aState'] = ''
         if  own['aState'] in ['reg_wall_r', 'reg_wall_l', 'fak_wall_r', 'fak_wall_l'] and not skater.isPlayingAction(3):
             sact.volume = .2
             cont.activate(own.actuators["wallSound"])
             ud_sens = .04      
             if 'spine' in localRay_v[0] and lUD < -.04:
                 if STANCE == True:
-                    own.applyRotation([0,.15,0], True)
+                    #own.applyRotation([0,.15,0], True)
+                    own.applyRotation([0,.1,0], True)
                 else:    
-                    own.applyRotation([0,-.15,0], True)
-                own.linearVelocity.x *= .97  
+                    #own.applyRotation([0,-.15,0], True)
+                    own.applyRotation([0,-.1,0], True)
+                #own.linearVelocity.x *= .97  
+                own.linearVelocity.x *= .95
             
             elif lUD > -ud_sens: 
                 own['last_vert_frame'] = own['framenum']
                         own.localLinearVelocity.z = 0
                     own.applyMovement((0, 0, (.295 - (localHitDist))), True)
                     if localRay_v[2] != [0, 0, -1]:    
-                        own.alignAxisToVect(localRay_v[2], 2, .5)
+                        #own.alignAxisToVect(localRay_v[2], 2, .5)
+                        own.alignAxisToVect(localRay_v[2], 2, .15)
                         aligned = True
+                # elif localHitDist > .4 and localHitDist < 1.5:
+                #     own.applyMovement((0, 0, (.295 - (localHitDist))), True)
             else:
                 own.alignAxisToVect([0,0,1], 2, .1)
                 print('doing nothing')            
     elif own['actionState'] in ['fak_backside_grab_out', 'fak_frontside_grab_out', 'fak_frontside_nose_grab_out', 'fak_frontside_tail_grab_out', 'fak_backside_nose_grab_out', 'fak_backside_tail_grab_out', 'fak_walk_air_out', 'fak_air-walk_air', 'fak_judo_out', 'fak_frigid_out', 'fak_fsonefoot_out', 'fak_onefoot_out'] and own['requestAction'] in  ['reg_land', 'fak_land']:
         own['requestAction'] = 'fak_land'   
 
-    print(own['getonboard'], 'controller geton', '--controller running')
+    #print(own['getonboard'], 'controller geton', '--controller running')

scripts/game.py

 		own['game_inited'] = True
 		own['cont'] = cont
 		dict['gameFSM'] = FSM.GameFSM(own)
+		dict['game_life'] = 0
 		#phone_home()
 
-	dict['gameFSM'].Execute()
+	dict['gameFSM'].Execute()
+	dict['game_life'] += 1

scripts/player.py

 import bge
 import FSM
 from mathutils import Vector
+import math
+import mathutils
 
 dict = bge.logic.globalDict
 
 		self.throw_timer = 0
 		self.throw_deck = None
 		self.throw_deck_empty = self.obj.childrenRecursive["throw_deck_empty"]
+		self.step = True
+		self.dropin_obj = None
+
 		#self.throw_deck_obj = dict['level_scene'].objects['throw_deck']
 		dict['walking'] = True
 		#print(self.obj.childrenRecursive)
 		front_start = start - 0.30 * tv
 		start.z += .1
 		front_end = Vector(front_start + (self.obj.worldOrientation.col[axis] * distance))
-		frontray = self.obj.rayCast(front_end, front_start, 0, 'ground', 1, 1, 0, 53247)
+		frontray = self.obj.rayCast(front_end, front_start, 0, 'ground', 1, 0, 0, 53247)
+		#if ray[0] == None and frontray[0] == None:
+		cray = self.obj.rayCast(end, start, 0, 'ground', 1, 0, 0, 53247)
+
 		#bge.render.drawLine(front_start, front_end, [1,0,0])
-		return [ray, frontray]
+		#bge.render.drawLine(back_start, end, [0,1,0])
+		#bge.render.drawLine(start, end, [0,0,1])
+		return [ray, frontray, cray]
+
+
+
+	def get_dropin_rays(self):
+		v = self.obj.worldOrientation.col[0]
+		tv = v.normalized()
+		axis = 2
+		distance = -50
+		start = self.obj.worldPosition.copy()
+		back_start = start + 0.1 * tv
+		start.z += .1
+		end = Vector.copy(self.obj.worldPosition + (self.obj.worldOrientation.col[axis] * distance))
+		ray = self.obj.rayCast(end, back_start, 0, 'ground', 1, 0, 0, 53247)
+		
+		v = self.obj.linearVelocity.copy()
+		v = self.obj.worldOrientation.col[0]
+		tv = v.normalized()
+		front_start = start - 0.1 * tv
+		start.z += .1
+		front_end = Vector(front_start + (self.obj.worldOrientation.col[axis] * distance))
+		frontray = self.obj.rayCast(front_end, front_start, 0, 'ground', 1, 0, 0, 53247)
+		cray = self.obj.rayCast(end, start, 0, 'ground', 1, 0, 0, 53247)
+		return [ray, frontray, cray]		
 
 
 	def get_hang_ray(self):
 	def get_ground_dist(self, groundray):
 		gr = groundray[0]
 		fgr = groundray[1]
+		cgr = groundray[2]
 		d = None
 		
 		if gr[0] != None:
 
 				if p2 < distance_to_ground:
 					distance_to_ground = p2
+			
+			if cgr[0] != None:
+				p2 = p_z - cgr[1].z 
+
+				if p2 < distance_to_ground:
+					distance_to_ground = p2
 
 			return distance_to_ground
 
 			self.obj.linearVelocity.z = 0
 
 	def align_walk_z(self):
-		self.obj.alignAxisToVect([0,0,1], 2, .05)
+		self.obj.alignAxisToVect([0,0,1], 2, .08)
 
 	def walk_movement(self):
 		
 			dict['camera'].applyMovement([0, amt2, 0], True)	
 
 	def check_reset_point(self):
-		print(dict['udPad'], dict['ddPad'])
-		if dict['udPad'] == 1:
-			print('set reset')
-		elif dict['ddPad'] == 1:
-			print('go to reset')			
-#reset
 		if dict['ddPad'] == 1:
 			spawn_pos = self.obj['spawn_pos']
 			spawn_rot = self.obj['spawn_rot']
 				self.throw_deck.endObject()
 				self.throw_deck = None
 
+	def drop_deck(self):
+
+		if self.throw_deck == None:	
+			self.throw_deck = dict['level_scene'].addObject('throw_deck', self.throw_deck_empty, 0)
+			self.throw_deck.worldOrientation = self.throw_deck_empty.worldOrientation
+			#self.throw_deck.applyForce([0, 0, -300], True)
+			#-z = forward +y = height
+			self.throw_deck.applyMovement([-.5, 0, .5], True)
+			self.throw_deck.worldPosition.z += .4
+			self.throw_deck.applyForce([0, 50, 75], True)
+			self.hide_deck()
+
+		
+			
+
 
 
 		#if self.throw_timer > 0:
 		for x in self.deck_arm.childrenRecursive:
 			x.visible = True
 
-
+	def get_vert_rot(self, own, object):
+
+	        if 'inited' not in object:
+	            object['inited'] = True
+
+	            for mesh in object.meshes:
+	                red_verts = []
+	                green_verts = []
+	                for m_index in range(len(mesh.materials)):
+	                    for v_index in range(mesh.getVertexArrayLength(m_index)):
+	                        vertex = mesh.getVertex(m_index, v_index)
+	                        if vertex.color[0] > .8:
+	                            loc = object.worldTransform * vertex.XYZ
+	                            red_verts.append(loc.freeze())
+	                        if vertex.color[1] > .8:
+	                            loc = object.worldTransform * vertex.XYZ
+	                            green_verts.append(loc.freeze())
+	                           
+	            red_verts = set(red_verts)
+	            #for v in red_verts:
+	                #print(v, 'red_vert')
+	            green_verts = set(green_verts)               
+	            object['red_verts'] = red_verts
+	            object['green_verts'] = green_verts
+	            
+	            size_red = len(object['red_verts'])
+	            kd_red = mathutils.kdtree.KDTree(size_red)
+	            size_green = len(object['green_verts'])
+	            kd_green = mathutils.kdtree.KDTree(size_green)    
+
+	            for i, v in enumerate(object['red_verts']):
+	                kd_red.insert(v, i)
+	            for i, v in enumerate(object['green_verts']):
+	                kd_green.insert(v, i)
+
+	            kd_red.balance()
+	            kd_green.balance() 
+	            object['kd_red'] = kd_red
+	            object['kd_green'] = kd_green    
+	            #print('kd built -------')
+	            #print(own['kd_red'])
+	        # Find the closest points to the player
+	        #co_find = control_bottom.worldPosition
+	        co_find = own.worldPosition
+	        found_red = object['kd_red'].find_n(co_find, 2)
+	        found_green = object['kd_green'].find_n(co_find, 1)    
+	        
+	        primary = Vector(found_red[0][0])
+	        secondary = Vector(found_red[1][0])
+
+	        lineVector = secondary - primary
+	        lineVector2 = primary - secondary
+	        if found_green != []:
+	            lv_green = Vector(found_green[0][0])
+	            
+	        eul = Vector((1, 0, 0)).rotation_difference(lineVector).to_euler()        
+	        
+	        te = dict['level_scene'].objects['temp_empty']
+	        
+
+	        rotation = te.worldOrientation.to_euler()
+	        if abs(rotation.z) > 3:
+	            te.applyRotation([0, 0, 1.570796*2], True)
+	        
+	        xyz = te.localOrientation.to_euler()
+	        xyz[0] = math.radians(0)
+	        te.localOrientation = xyz.to_matrix()
+
+	        if lineVector == Vector([0.0, 0.0, 0.0]):
+	            #print('vector is empty')
+	            pass
+	        else:
+	            te.alignAxisToVect(lineVector, 0, 1)
+	        
+	        te.worldPosition = primary
+
+	        if found_green != []:
+	            local = te.worldOrientation.inverted() * (lv_green - te.worldPosition)
+	            if local.y < 0:
+	                #print('flip vector')
+	                eul = Vector((1, 0, 0)).rotation_difference(lineVector2).to_euler() 
+	                if lineVector2 == Vector([0.0, 0.0, 0.0]):
+	                    #print('linVector2 is empty')
+	                    pass
+	                else:
+	                    te.alignAxisToVect(lineVector2, 0, 1)
+	                #print('align2', lineVector2)
+	                te.worldPosition = secondary
+	            else:
+	                #print('align1', lineVector)  
+	                pass
+
+
+	        #flip z axis
+
+	        #print(local, 'local')
+	        
+	        myhead = te.worldOrientation.col[2]
+	        worldUp = Vector([0,0,1])
+	        #worldY = Vector([0,1,0])
+	        dot_p = myhead.dot(worldUp)
+
+	        if dot_p > 0.9:
+	            pass
+	        else:
+	            #print('flip grind object rotation')
+	            te.applyRotation([1.570796*2, 0, 0], True)
+
+
+
+
+	        return eul
+
+	def move_to_te(self):
+		o = self.obj
+		te = dict['level_scene'].objects['temp_empty']
+		te.applyRotation([0,0,-3.14/2], True)
+		te.worldPosition.z += .3
+		o.worldPosition = te.worldPosition
+		o.worldOrientation = te.worldOrientation
+		o.linearVelocity = [0,0,0]
 
 
 def update(cont):

scripts/ragdoll.py

     #if (sens.positive) or (dict['aBut'] == 1 and dict['bBut'] == 1) or own['fall'] == True:
     if (sens.positive) or own['fall'] == True:
         #print('option1')
-        #own['fall'] = True
+        own['fall'] = False
         if own['ragdoll_active'] == False:
             #own['fall'] = 1
             own['fall'] = True
             print('do ragdoll')
             incer = -1
             update_rb(own['rd_rb'], scene)   
-            while incer < 20:
-                incer += 1
-                scene.objects[armature].stopAction(incer)
+            # while incer < 20:
+            #     incer += 1
+            #     scene.objects[armature].stopAction(incer)
             pB = scene.objectsInactive["npc_ed_arm_physBody"]        
             physBody = own['rd_rb']
             physBody.worldPosition = own.worldPosition
             own['ragdoll_active'] = True
             max_constraints(own, scene, physBody)
             own.visible = False
+            #own.visible = True
             own['throw_deck'] = False
             cont.actuators['Camera'].height = 2.0
             #cont.actuators['Camera'].min = 14.0
             #cont.actuators['Camera'].max = 18.0
             cont.actuators['Camera'].damping = .000001
             cont.activate(cont.actuators['Camera']) 
-                        
-            #own.suspendDynamics()
+            own.suspendDynamics(True)
             
     else:
 
         if own['ragdoll_active'] == True:
             #pass
-            scene.objects[armature].stopAction(2)
-            scene.objects[armature].stopAction(7)
-            scene.objects[armature].update()
+            own['rd_incer'] += 1
+            # scene.objects[armature].stopAction(1)
+            # scene.objects[armature].stopAction(2)
+            # scene.objects[armature].stopAction(3)
+            # scene.objects[armature].stopAction(7)
+            #scene.objects[armature].update()
             
             #cont.actuators['Camera'].object = scene.objects['ragdoll_parent']
-            #scene.objects['control_cube.002'].worldPosition = scene.objects['control_cube.002'].worldPosition.lerp(scene.objects['ragdoll_parent'].worldPosition, .01)
-            scene.objects['control_cube.002'].worldPosition = scene.objects['ragdoll_parent'].worldPosition
+            scene.objects['control_cube.002'].worldPosition = scene.objects['control_cube.002'].worldPosition.lerp(scene.objects['ragdoll_parent'].worldPosition, .01)
+            #scene.objects['control_cube.002'].worldPosition = scene.objects['ragdoll_parent'].worldPosition
 
+            #print('doing the active thing')
 
 
             wp = scene.objects['camCube'].worldPosition - scene.objects['ragdoll_parent'].worldPosition
             else:    
                 own['requestAction'] = 'fak_walk'
             if own['rd_set_vel'] == True:
-                print(own['rd_incer'], 'rdincer', own['rd_vel'])
+                #print(own['rd_incer'], 'rdincer', own['rd_vel'])
                 
                 scene.objects['npc_ed_arm_phys_master'].setLinearVelocity(own['rd_vel'] * 20, False)
                 own['rd_set_vel'] = False
                     #scene.objects['npc_ed_arm_phys_master'].worldLinearVelocity.x = 100
                     #scene.objects['npc_ed_arm_phys_master'].applyForce([5000,0,0], False)
                     for pB in own['rd_rb'].groupMembers:
-                        print('setting', pB, own['rd_vel'])
+                        #print('setting', pB, own['rd_vel'])
                         
                         try:
                             #pass
                             #pB.worldLinearVelocity.x = 100
                             #pB.worldLinearVelocity = own['rd_vel']
                             pB.setLinearVelocity(own['rd_vel'], False)
-                            print('adding force to', pB, pB.worldLinearVelocity)
+                            #print('adding force to', pB, pB.worldLinearVelocity)
                         except:
                             print('cant add force to ', pB)
                 else:
                 for x in own['rd_rb'].groupMembers:
                     x.suspendDynamics(True)
                 own['ragdoll_active'] = False    
-                print(scene.objects[armature].parent, 'parent')
+                #print(scene.objects[armature].parent, 'parent')
                 cont.actuators['Camera'].object = scene.objects['camCube']
                 cont.activate(cont.actuators['Camera']) 
                 own.worldPosition = scene.objects['npc_ed_arm_phys_master'].worldPosition
-                own.worldPosition.z += .4
+                own.worldPosition.z += .8#4
                 cont.activate(cont.actuators['walk']) 
                 own['getonboard'] = True
                 dict['walk'] = 0
                 own['fall'] = False
-
             if dict['lUD'] < -.08 and own['rd_incer'] > 200:
                 physBody = own['rd_rb']
                 excludes = ['npc_ed_arm_phys_hand.R', 'npc_ed_arm_phys_hand.L', 'npc_ed_arm_phys_forearm.fk.L', 'npc_ed_arm_phys_forearm.fk.R', 'npc_ed_arm_phys_upper_arm.fk.L', 'npc_ed_arm_phys_upper_arm.fk.R']
                 #excludes = []
-                for x in physBody.groupMembers:
-                    print(x.name)
+                # for x in physBody.groupMembers:
+                #     print(x.name)
                                     
-                    if x.name not in excludes:
-                        pass
-                        #x.applyForce([0,0,15], False)
-                    else:
-                        #x.applyForce([0,0,100], False)   
-                        pass 
+                #     if x.name not in excludes:
+                #         #pass
+                #         x.applyForce([0,0,15], False)
+                #     else:
+                #         x.applyForce([0,0,100], False)   
+                #         #pass 
 
-                scene.objects['npc_ed_arm_phys_master'].applyForce([0,0,500], False)
+                # scene.objects['npc_ed_arm_phys_master'].applyForce([0,0,500], False)
                 scene.objects['npc_ed_arm_phys_head'].applyForce([0,0,400], False)
-                scene.objects['npc_ed_arm_phys_chest'].applyForce([0,0,200], False)
+                # scene.objects['npc_ed_arm_phys_chest'].applyForce([0,0,200], False)
                 scene.objects['npc_ed_arm_phys_chest-1'].applyForce([0,0,200], False)
-                scene.objects['npc_ed_arm_phys_spine'].applyForce([0,0,200], False)
+                # scene.objects['npc_ed_arm_phys_spine'].applyForce([0,0,200], False)
                 scene.objects['npc_ed_arm_phys_neck'].applyForce([0,0,200], False)
-                scene.objects['npc_ed_arm_phys_deltoid.L'].applyForce([0,0,200], False)
-                scene.objects['npc_ed_arm_phys_deltoid.R'].applyForce([0,0,200], False)
-                scene.objects['npc_ed_arm_phys_clavicle.L'].applyForce([0,0,200], False)
-                scene.objects['npc_ed_arm_phys_clavicle.R'].applyForce([0,0,200], False)
+                scene.objects['npc_ed_arm_phys_forearm.fk.L'].applyForce([0,0,30], False)
+                scene.objects['npc_ed_arm_phys_forearm.fk.R'].applyForce([0,0,30], False)
+                
+                # scene.objects['npc_ed_arm_phys_deltoid.L'].applyForce([0,0,200], False)
+                # scene.objects['npc_ed_arm_phys_deltoid.R'].applyForce([0,0,200], False)
+                # scene.objects['npc_ed_arm_phys_clavicle.L'].applyForce([0,0,200], False)
+                # scene.objects['npc_ed_arm_phys_clavicle.R'].applyForce([0,0,200], False)
 
-            if dict['rUD'] > .08 and own['rd_incer'] > 200:
-                scene.objects['npc_ed_arm_phys_master'].applyForce([0,600,0], True)
+            if dict['lLR'] < -.04:
+                scene.objects['npc_ed_arm_phys_spine'].applyRotation([0,.1,0], True)
+                scene.objects['npc_ed_arm_phys_head'].applyRotation([0,.1,0], True)
+            if dict['lLR'] > .04:
+                scene.objects['npc_ed_arm_phys_spine'].applyRotation([0,-.1,0], True)
+                scene.objects['npc_ed_arm_phys_head'].applyRotation([0,-.1,0], True)
+                
+            # if dict['rUD'] > .08 and own['rd_incer'] > 200:
+            #     scene.objects['npc_ed_arm_phys_master'].applyForce([0,600,0], True)
         else:
             update_rb(own['rd_rb'], scene)   
             #pass

scripts/sound_man.py

 	self.pop = sounds('pop')
 	self.land = sounds('land')
 	self.roll = sounds('roll')
+	self.s_l_1 = sounds('s_l_1')
+
+	self.s_r_1 = sounds('s_r_1')
+	self.s_l_2 = sounds('s_l_2')
+	self.s_r_2 = sounds('s_r_2')
+	self.s_l_1.volume = 0.3
+	self.s_r_1.volume = 0.3
+	self.s_l_1.pitch = 3
+	self.s_r_1.pitch = 3
+
+	self.walk_grunt = sounds('walk_grunt')
+	self.walk_land = sounds('walk_land')
+	self.walk_hang = sounds('walk_hang')
+	self.walk_climb = sounds('walk_climb')
 	self.revert = sounds('revert')
 	self.engine_idle = sounds('engine_idle')
 	self.roll.loop = True

shuvit.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:ed9ccab1cd84ac46d7e14d38f51a2a6c4c23d4bc182f4cb05510ee43188ef47f
-size 125585980
+oid sha256:d1ad57d6355aae70aaf5a7e4dc2ca1a6917ca514249d3c072e54524ac5e2b0d0
+size 125371052

sounds/s_l_1.wav

+version https://git-lfs.github.com/spec/v1
+oid sha256:a143eb49abfe2cb65b7cdf9334049969eb1d7158421351d5586a61c5234c0f17
+size 96948

sounds/s_l_2.wav

+version https://git-lfs.github.com/spec/v1
+oid sha256:c47a482aae3f046822412fbc27dcd1b181a9d574992a746aea0be8a05d8f6c2d
+size 84092

sounds/s_r_1.wav

+version https://git-lfs.github.com/spec/v1
+oid sha256:f597344c9b60d80945d809cc7fd8cf7024bfd9834206b0e728cd907e0f73ea6c
+size 99284

sounds/s_r_2.wav

+version https://git-lfs.github.com/spec/v1
+oid sha256:7f719526cd85d65a6d6390a2a9f1f3693ad706e9af59bf76aa6271835a365e1a
+size 70576

sounds/walk_climb.wav

+version https://git-lfs.github.com/spec/v1
+oid sha256:670e826c4bd46f51eb6352fdb8e07e18ee0f106596ed0afa61a63487b01ddefe
+size 49584

sounds/walk_grunt.wav

+version https://git-lfs.github.com/spec/v1
+oid sha256:2a0f9b681331d5e8bc5da85a6a116b14faf96f80a8b65527ab7eb07ed158d010
+size 49584

sounds/walk_hang.wav

+version https://git-lfs.github.com/spec/v1
+oid sha256:57b60a397c288b0c5be62717fa26ac3bc877919bc67b927ecf12e260de966daf
+size 456044

sounds/walk_land.wav

+version https://git-lfs.github.com/spec/v1
+oid sha256:113be012923dd1ac23bdb8e17cd345cf8a0acbf77318167a81115def6b6f8995
+size 100384

sounds/walkondirt.wav

+version https://git-lfs.github.com/spec/v1
+oid sha256:c13bfda173c45077e66dbdffe96771ee77c8d5c22343b053668ff59edd710cc4
+size 403244