replay sound fix

assets/levels/user2.blend

-version https://git-lfs.github.com/spec/v1
-oid sha256:0536309cdac72fe106d4ca3b9a6f268d02831c90346df3de24d98991dc01339d
-size 1211092

assets/maps/Demo/map.blend

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

assets/maps/Demo/map_settings.ini

+#shuvit map settings configuration file
+
+#lighting template
+map_template = outdoor_ns
+
+map_npcs = 0
+map_cars = 15

assets/maps/Frank's Garage/map.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:773add811d95e272e288d1dfa8b2c60f33b0515fd9aac7bfbc823123b9b59706
+size 722880

assets/maps/Frank's Garage/map_settings.ini

+#shuvit map settings configuration file
+
+#lighting template
+map_template = indoor
+
+map_npcs = 0
+map_cars = 15

assets/maps/Harry's Garage/map.blend

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

assets/maps/Harry's Garage/map_settings.ini

+#shuvit map settings configuration file
+
+#lighting template
+map_template = indoor
+
+map_npcs = 0
+map_cars = 15

assets/maps/John's Mini/map_settings.ini

+#shuvit map settings configuration file
+
+#lighting template
+map_template = outdoor
+
+map_npcs = 0
+map_cars = 15

assets/maps/Scratch/map_settings.ini

+#shuvit map settings configuration file
+
+#lighting template
+map_template = outdoor
+
+map_npcs = 0
+map_cars = 15

assets/materials/base_m_kit.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:c182c5eb0c2bd584a523fab0cd26dd30cb10a2b852eec3513da70bac981703df
-size 35791236
+oid sha256:a2e299b71b355f6f71238d6d39eb243687732cda57a536db004b593a042f5977
+size 35932972

assets/materials/textures/Ceiling_A.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:633fa590e8f749a9c058a9553bf512bf1f9899e4f2ce1bafcc85b30c4ed93e2a
+size 1944896

assets/materials/textures/Ceiling_N.png

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

assets/materials/textures/Grunge_Masks_A.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:5618ce49202765378f412e556850a36a7ae1e0eb18c69d82868050818f67dccc
+size 1657326

assets/materials/textures/bricks.png

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

assets/materials/textures/bricks_h.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:3eaaee418f491c0c8b911a970f8a31167a17b941fe80df4b9e1b95768b7927a2
+size 231818

assets/materials/textures/bricks_hnb.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:51b7237418626912ca3fae3bf6510ca839296a30620bdab7c30fb3e0e11ca089
+size 754969

assets/materials/textures/color_grid.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:5fc4b73b2fdda62dc09e25a8614072d5b5021738b51e93e157931d23c07f8275
+size 4624

assets/materials/textures/greyscale-pxb.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:1d933843b33401c385dfa8201381f4eef4da35a589916c40a981e299551901bb
+size 637110

assets/materials/textures/plywood_m_a.jpg

+version https://git-lfs.github.com/spec/v1
+oid sha256:51aa200ddd45fef473de251882048149d8dc8e1f65f96b8e299c76b5551c3921
+size 496720

assets/materials/textures/plywood_m_d.jpg

+version https://git-lfs.github.com/spec/v1
+oid sha256:25dcf970b3fceda59dfc9ac22871994a2b6f6a4577e9479d98a7bb4a31f6a57a
+size 446995

assets/materials/textures/plywood_m_h.jpg

+version https://git-lfs.github.com/spec/v1
+oid sha256:0daf050a331bab951d2da760704bffd6be67a1d607744175a844e176ce6feaaf
+size 196285

assets/materials/textures/plywood_m_hb.jpg

+version https://git-lfs.github.com/spec/v1
+oid sha256:6334aad32ad862c62ec1fcd4b75ec4d1dec330754c0d9d10d840a98271b9b07d
+size 240274

assets/materials/textures/plywood_m_hn.jpg

+version https://git-lfs.github.com/spec/v1
+oid sha256:3da31787d46ef5794691f56027f903567ebec19983a92cfe68c77d677d0b1684
+size 1424429

assets/materials/textures/plywood_m_ln.jpg

+version https://git-lfs.github.com/spec/v1
+oid sha256:0b55fbf2d677bfd0832f7b51b3af69f375962a3e70092a3aaa3fe437000f578e
+size 592079

assets/materials/textures/plywood_m_mn.jpg

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

assets/materials/textures/plywood_m_n.jpg

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

assets/materials/textures/plywood_m_s.jpg

+version https://git-lfs.github.com/spec/v1
+oid sha256:88bd5b070da8edf56529f901d9b7576bc3bd4a209741277d1a6cbdf3638fb672
+size 617364

assets/materials/textures/plywood_m_sn.jpg

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

assets/ramps.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:7f0ca585c24b56ca66641f6ebeec9b3525f19f757b6857a8c1ac9fb957421066
-size 80413544
+oid sha256:5f79f92570790b1dce9967d31066953686e966be6e24f8cea739475130b5dcb6
+size 84686084

assets/user2.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:591f877f598327200b89c9518b9ba7e8aaefe0f5b69957836fbf0044cb26b5e5
-size 3442504
+oid sha256:290945cb39568c3ecffdfe59a94d188c0e20dd7eac5b7c33c4b4393a396d6fac
+size 3403128

assets/walls.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:50275c1ba939f8e547bf590f50357cfd10bd80d8adf9a241443ccf39df76ae82
+size 7128536

config.ini

 
 #level
 ######
-level = user2
-levelBlend = user2
+level = indoor
+levelBlend = indoor
+map = Harry's Garage
 #------------
 
 #replay recorder
 #camera 
 #######
 cam_height = -0.3
-focal_length = 12
+focal_length = 10
 cam_min = 2.0
 cam_max = 4.4
 cch_targetHeight = 0.3
 
 shirt_logo = 2
 
-shirt_color_r = 0
-shirt_color_g = 0
-shirt_color_b = 0
+shirt_color_r = 1
+shirt_color_g = 0.03
+shirt_color_b = 0.03
 
-shoe_color_r = 0.69
-shoe_color_g = 0.69
-shoe_color_b = 0.67
+shoe_color_r = 1
+shoe_color_g = 0.38
+shoe_color_b = 0
 #-----------------
 
 #deck settings
 BC_CONTRAST = 1.09
 
 #HDR
-hdr = 0
-avgL = 0.8
+hdr = 1
+avgL = 0.69
 HDRamount = 0.05
 
 #Ambient Occlusion
-ao = 0
+ao = 1
 onlyAO = 0
 aowidth = 0.2
 aoradius = 2.4
 
 #sun settings
 #############
-sun_strength = 1.05
-ambient_strength = 0.15
-sun_rot_x = 0.05
-sun_rot_y = 0.05
+sun_strength = 1.1
+ambient_strength = 0.18
+sun_rot_x = -0.05
+sun_rot_y = -0.05
 shadow_on = 0
 #------------
 

scripts/FSM.py

         'Startup',
         'Initer',
         'LoadLevel',
-        'GameOn']
+        'GameOn',
+        'Reload']
         
         for s in state_list:
             self.FSM.AddState(s, getattr(StatesGame, s)(self.FSM))
         'Offboard', 
         'Dropin',
         'Roll',
-        'Ragdoll']
+        'Ragdoll',
+        'Pause']
         
         for s in state_list:
             self.FSM.AddState(s, getattr(StatesPlayer, s)(self.FSM))

scripts/Record.py

     lengthVis = own["lengthVis"]
     
     if lengthVis:
+        pass
+        # if valueIndex > lengthVis-1:
+        #     own["valueIndex"] = 0
+        # if objIndex < 0:
+        #     own["objIndex"] = lengthVis-2
 
-        if valueIndex > lengthVis-1:
-            own["valueIndex"] = 0
-        if objIndex < 0:
-            own["objIndex"] = lengthVis-2
-
-        name, visible = readData.returnVisibility(objIndex, valueIndex)
+        # name, visible = readData.returnVisibility(objIndex, valueIndex)
         
-        if name in scene.objects:
-            try:
-                scene.objects[name].visible = int(visible)
-            except:
-                pass
+        # if name in scene.objects:
+        #     try:
+        #         scene.objects[name].visible = int(visible)
+        #     except:
+        #         pass
     #-----Skater Animation Name-----#
     own["lengthSkaterAnim"] = readData.getLengthSkaterAnim()
     lengthSkaterAnim = own["lengthSkaterAnim"]

scripts/Settings.py

 
 config = ConfigObj(fileName, interpolation=True)
 dict = bge.logic.globalDict
+#map_config = {}
+
 
 print('###############start game##########')
 dict['music_player'] = 1
 
+def to_dict3(section, key):
+    #dict = bge.logic.globalDict
+    print(section, key)
+    #d = dict['map']
+    fileName2 = GameLogic.expandPath("//assets/maps/" + dict['map'] + '/map_settings.ini')    
+    map_config = ConfigObj(fileName2, interpolation=True)   
+    value = map_config[key]
+    if isinstance(value, str):
+        if value.isdigit():
+            value = int(value)
+        else:
+            try:
+                value = float(value)
+            except:
+                pass
+    #print(dict['mapDict'])
+    dict[key] = value    
+
+
 def to_dict(section, key):
     dict = bge.logic.globalDict
     value = config[key]
             except:
                 pass
     dict[key] = value  
-    #print(key, value)
+
     
+def readMap():
+    fileName = GameLogic.expandPath("//assets/maps/" + dict['map'] + '/map_settings.ini')    
+    #fileName = mainDir + dict['character'] + ".ini"
+    #print('loading character settings', fileName)
+    map_config = ConfigObj(fileName, interpolation=True)
+    print('map_config', map_config)
+    dict['mapDict'] = map_config
+    # def to_dict2(section, key):
+    #     #dict = bge.logic.globalDict
+    #     value = map_config[key]
+    #     if isinstance(value, str):
+    #         if value.isdigit():
+    #             value = int(value)
+    #         else:
+    #             try:
+    #                 value = float(value)
+    #             except:
+    #                 pass
+    #     dict[key] = value 
+
 def readChar():
     mainDir = GameLogic.expandPath("//characters/")    
     fileName = mainDir + dict['character'] + ".ini"
     
 
 def readSettings():
-    config.walk(to_dict)         
+    config.walk(to_dict)    
+    dict['mapDict'] = {}  
+    fileName2 = GameLogic.expandPath("//assets/maps/" + dict['map'] + '/map_settings.ini')    
+    map_config = ConfigObj(fileName2, interpolation=True)   
+    map_config.walk(to_dict3)         
+    #readMap()
     readChar()
 
 def from_dict(section, key):
     if own["profile"] ==1:    
         bge.render.showProfile(1)   
     act = own2.actuators["level"]
-    dict = bge.logic.globalDict
-    level = dict['level']
-    print('loading level', level)
+    #dict = bge.logic.globalDict
+    
+    fileName2 = GameLogic.expandPath("//assets/maps/" + dict['map'] + '/map_settings.ini')    
+    map_config = ConfigObj(fileName2, interpolation=True)   
+    map_config.walk(to_dict3)  
+    
+    level = dict['map_template']
+    dict['level'] = level
+    #level = dict['level']
+    print('loading template level', level)
     act.scene = level 
     cont.activate(own2.actuators["level"]) 
     dict['npause'] = False 

scripts/Startup.py

     dict['sunz'] = 1.0 
     dict['replay_loop_start'] = 0
     dict['replay_loop_end'] = 0
-    dict['replay_record_length'] = 7300#240 #1200 #7300
+    dict['replay_record_length'] = 2600#240 #1200 #7300
     dict['rp_keyframes'] = []
     dict['rp_positions'] = []
     dict['temp_list'] = []
     dict['scene_inited'] = True
     dict['p1c'] = None
+    dict['sun_lights'] = []
+    dict['ambient_lights'] = []
 
     dict['joy_con'] = False
     

scripts/StatesGame.py

 import Settings
 import inputs
 import logo_fades
+
+dict = bge.logic.globalDict
 #====================================     
 
 State = type("State", (object,), {})
     def Exit(self):
         pass
 
+#==================================== 
+
+class Reload(State):
+    def __init__(self,FSM):
+        super(Reload, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(Reload, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        dict.clear()
+        self.FSM.owner['cont'].activate(self.FSM.owner['cont'].actuators['restart'])
+        #cont.activate(own.actuators['add_fade'])  
+        #own['cont'] = cont
+
+    def Exit(self):
+        pass
+
 #==================================== 

scripts/StatesPlayer.py

 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 = 0
-        self.startTime = 0
-    def Execute(self):
-        print('Executing')
-    def Exit(self):
-        print('Exiting')
+	def __init__(self, FSM):
+		self.FSM = FSM
+		self.timer = 0
+		self.startTime = 0
+	def Enter(self):
+		self.timer = 0
+		self.startTime = 0
+	def Execute(self):
+		print('Executing')
+	def Exit(self):
+		print('Exiting')
 
 #==================================== 
-            
+			
 class Example(State):
-    def __init__(self,FSM):
-        super(Example, 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
+	def __init__(self,FSM):
+		super(Example, 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
 
 #==================================== 
 
 class Startup(State):
-    def __init__(self,FSM):
-        super(Startup, self).__init__(FSM)    
-        
-    def Enter(self):
-        self.FSM.stateLife = 1
-        super(Startup, self).Enter()        
-        
-    def Execute(self):
-        self.FSM.stateLife += 1
-
-        if self.FSM.stateLife == 5:
-            self.FSM.ToTransition('toWalk')
-        print('player FSM')
-        
-    def Exit(self):
-        pass
+	def __init__(self,FSM):
+		super(Startup, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.FSM.stateLife = 1
+		super(Startup, self).Enter()        
+		
+	def Execute(self):
+		self.FSM.stateLife += 1
+
+		if self.FSM.stateLife == 5:
+			self.FSM.ToTransition('toWalk')
+		print('player FSM')
+		
+	def Exit(self):
+		pass
 
 #==================================== 
-            
+			
 class Walk(State):
-    def __init__(self,FSM):
-        super(Walk, self).__init__(FSM)    
-        
-    def Enter(self):
-        self.FSM.stateLife = 1
-        o = self.FSM.owner.obj
-        c = self.FSM.owner
-        o['getoffboard'] = False
-        o['getonboard'] = False
-
-        if c.arm == None:
-            
-            c.arm = o.childrenRecursive['Char4']
-            c.deck_arm = o.childrenRecursive['deck_arm']
-        self.walk_weight = 1
-        self.run_weight = 1
-        self.run_speed = 0.0
-        self.turn_weight = 0
-        self.FSM.owner.walking = True
-        dict['walking'] = True
-        dict['walk'] = 1
-        print('fsm enter walk')
-
-        super(Walk, self).Enter()        
-        
-    def Execute(self):
-        self.FSM.stateLife += 1
-        o = self.FSM.owner.obj
-        c = self.FSM.owner
-        #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
-        #         o['requestAction'] = 'fak_offboard' 
-        #         print('request fak offboard')            
-        #     else:
-        #         o['requestAction'] = 'reg_offboard'                 
-        #         print('request reg offboard') 
-        # if self.FSM.stateLife > 5:
-        #     o['requestAction'] = 'reg_idle'                 
-        c.align_walk_z()
-        ground_rays = c.get_ground_ray()
-        #77777777777777777777777777777777777777777777777777777777777777777777777777777777777
-        c.get_hang_align_ray()
-        c.move_walk_cam()
-        c.check_reset_point()       
-        c.check_throw()
-
-        if ground_rays[0][0] != None:
-            dist = c.get_ground_dist(ground_rays)
-            if dist > .7:
-                self.FSM.ToTransition('toWalkAir')
-                #print('---falling')
-            else:
-                c.set_walk_z(dist)
-            #print(dist, 'setting height')
-
-        if self.FSM.stateLife > 4:
-            self.check_onboard()
-            self.check_jump()
-
-            moving = c.walk_movement()
-            
-            self.get_walk_weight()
-            self.idle_blend()
-        else:
-            dict['walk'] = 1
-
-
-    def check_onboard(self):
-
-        o = self.FSM.owner.obj
-        #print(o['getonboard'], 'getonboard')
-
-        
-        if dict['walk'] == 0:
-            o['getonboard'] = True
-            #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')
-
-
-
-    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
-        deck = self.FSM.owner.deck_arm
-        arm.playAction('reg_idle1', 1,120, layer=1, play_mode=1, speed=1, blendin=10)
-        deck.playAction('b_reg_idle1', 1,120, layer=1, play_mode=1, speed=1, blendin=10)
-        if self.FSM.stateLife > 20:
-            frame = arm.getActionFrame(2) + .5 * self.run_speed
-            if frame > 30:
-                frame = 0
-            arm.stopAction(2)
-            deck.stopAction(2)
-            arm.playAction('reg_nwalk3', 0,30, layer=2, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=self.walk_weight)
-            deck.playAction('b_reg_walk', 0,30, layer=2, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=self.walk_weight)
-            #b_reg_walk
-            arm.setActionFrame(frame, 2)
-            deck.setActionFrame(frame, 2)
-            #print(self.walk_weight, frame)
-
-            
-
-            frame = arm.getActionFrame(3) + .5 * self.run_speed
-            if frame > 30:
-                frame = 0
-            arm.stopAction(3)
-            deck.stopAction(3)
-            arm.playAction('reg_run.003', 0,30, layer=3, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=self.run_weight)
-            deck.playAction('b_reg_run', 0,30, layer=3, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=self.run_weight)
-            
-            arm.setActionFrame(frame, 3)
-            deck.setActionFrame(frame, 3)
-            #print(frame, 'frame')
-            #print(self.run_weight, frame)
-            
-        # if self.turn_weight > 0:
-        #     tw = abs(self.turn_weight - 1)
-        #     #tw = self.turn_weight
-        #     arm.stopAction(4)
-        #     arm.playAction('bwalk_right', 1,60, layer=4, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=tw)
-        # elif self.turn_weight < 0:
-        #     tw = abs(abs(self.turn_weight) - 1)
-        #     #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) 
-
-
-        o = self.FSM.owner.obj
-        w = abs(o.linearVelocity.x)
-        #wt = 3.5
-        #yt = 8
-        wt = 1.7
-        yt = 3
-        out2 = 0
-        if w < wt:
-            out = w / wt
-        else:
-            out = 1
-            #print('running', w)
-            out2 = w / yt
-        out = abs(1 - out)
-        out2 = abs(1 - out2)
-        tgww = round(out, 3)
-        tgrw = round(out2, 3)
-        incer = .05
-        if self.walk_weight < tgww:
-            self.walk_weight += incer
-        if self.walk_weight > tgww:
-            self.walk_weight -= incer
-        if self.run_weight <= tgrw:
-            self.run_weight += incer
-        if self.run_weight > tgrw:
-            self.run_weight -= incer
-        if self.walk_weight <= 0:
-            self.walk_weight = 0
-        if self.walk_weight > .95:            
-            self.walk_weight = 1        
-        if self.run_weight <= 0:
-            self.run_weight = 0
-        if self.run_weight > .95:
-            self.run_weight = 1
-
-
-        if dict['kb_lsh'] == 2 or dict['aBut'] == 1:
-            self.run_speed = 1.3
-        else:
-            self.run_speed = .8
-        #print(self.run_speed, '---', self.walk_weight, 'walk weight', self.run_weight, 'run weight')
-
-    def Exit(self):
-        self.FSM.owner.arm.stopAction(0)
-        self.FSM.owner.arm.stopAction(1)
-        self.FSM.owner.arm.stopAction(2)
-        self.FSM.owner.arm.stopAction(3)
-        self.FSM.owner.deck_arm.stopAction(0)
-        self.FSM.owner.deck_arm.stopAction(1)
-        self.FSM.owner.deck_arm.stopAction(2)
-        self.FSM.owner.deck_arm.stopAction(3)
-        dict['walk'] = 0
+	def __init__(self,FSM):
+		super(Walk, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.FSM.stateLife = 1
+		o = self.FSM.owner.obj
+		c = self.FSM.owner
+		o['getoffboard'] = False
+		o['getonboard'] = False
+
+		if c.arm == None:
+			
+			c.arm = o.childrenRecursive['Char4']
+			c.deck_arm = o.childrenRecursive['deck_arm']
+		self.walk_weight = 1
+		self.run_weight = 1
+		self.run_speed = 0.0
+		self.turn_weight = 0
+		self.FSM.owner.walking = True
+		dict['walking'] = True
+		dict['walk'] = 1
+		print('fsm enter walk')
+
+		super(Walk, self).Enter()        
+		
+	def Execute(self):
+		self.FSM.stateLife += 1
+		o = self.FSM.owner.obj
+		c = self.FSM.owner
+		#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
+		#         o['requestAction'] = 'fak_offboard' 
+		#         print('request fak offboard')            
+		#     else:
+		#         o['requestAction'] = 'reg_offboard'                 
+		#         print('request reg offboard') 
+		# if self.FSM.stateLife > 5:
+		#     o['requestAction'] = 'reg_idle'                 
+		c.align_walk_z()
+		ground_rays = c.get_ground_ray()
+		#77777777777777777777777777777777777777777777777777777777777777777777777777777777777
+		c.get_hang_align_ray()
+		c.move_walk_cam()
+		c.check_reset_point()       
+		c.check_throw()
+		c.check_pause()
+		c.check_idle(False)
+		c.idle_anim()
+
+		if ground_rays[0][0] != None:
+			dist = c.get_ground_dist(ground_rays)
+			if dist > .7:
+				self.FSM.ToTransition('toWalkAir')
+				#print('---falling')
+			else:
+				c.set_walk_z(dist)
+			#print(dist, 'setting height')
+
+		if self.FSM.stateLife > 4:
+			self.check_onboard()
+			self.check_jump()
+
+			moving = c.walk_movement()
+			
+			self.get_walk_weight()
+			self.idle_blend()
+		else:
+			dict['walk'] = 1
+
+
+	def check_onboard(self):
+
+		o = self.FSM.owner.obj
+		#print(o['getonboard'], 'getonboard')
+
+		
+		if dict['walk'] == 0:
+			o['getonboard'] = True
+			#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')
+
+
+
+	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
+		deck = self.FSM.owner.deck_arm
+		arm.playAction('reg_idle1', 1,120, layer=1, play_mode=1, speed=.5, blendin=10)
+		deck.playAction('b_reg_idle1', 1,120, layer=1, play_mode=1, speed=1, blendin=10)
+		if self.FSM.stateLife > 20:
+			frame = arm.getActionFrame(2) + .5 * self.run_speed
+			if frame > 30:
+				frame = 0
+			arm.stopAction(2)
+			deck.stopAction(2)
+			arm.playAction('reg_nwalk3', 0,30, layer=2, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=self.walk_weight)
+			deck.playAction('b_reg_walk', 0,30, layer=2, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=self.walk_weight)
+			#b_reg_walk
+			arm.setActionFrame(frame, 2)
+			deck.setActionFrame(frame, 2)
+			#print(self.walk_weight, frame)
+
+			
+
+			frame = arm.getActionFrame(3) + .5 * self.run_speed
+			if frame > 30:
+				frame = 0
+			arm.stopAction(3)
+			deck.stopAction(3)
+			arm.playAction('reg_run.003', 0,30, layer=3, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=self.run_weight)
+			deck.playAction('b_reg_run', 0,30, layer=3, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=self.run_weight)
+			
+			arm.setActionFrame(frame, 3)
+			deck.setActionFrame(frame, 3)
+			#print(frame, 'frame')
+			#print(self.run_weight, frame)
+			
+		# if self.turn_weight > 0:
+		#     tw = abs(self.turn_weight - 1)
+		#     #tw = self.turn_weight
+		#     arm.stopAction(4)
+		#     arm.playAction('bwalk_right', 1,60, layer=4, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=tw)
+		# elif self.turn_weight < 0:
+		#     tw = abs(abs(self.turn_weight) - 1)
+		#     #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) 
+
+
+		o = self.FSM.owner.obj
+		w = abs(o.linearVelocity.x)
+		#wt = 3.5
+		#yt = 8
+		wt = 1.7
+		yt = 3
+		out2 = 0
+		if w < wt:
+			out = w / wt
+		else:
+			out = 1
+			#print('running', w)
+			out2 = w / yt
+		out = abs(1 - out)
+		out2 = abs(1 - out2)
+		tgww = round(out, 3)
+		tgrw = round(out2, 3)
+		incer = .05
+		if self.walk_weight < tgww:
+			self.walk_weight += incer
+		if self.walk_weight > tgww:
+			self.walk_weight -= incer
+		if self.run_weight <= tgrw:
+			self.run_weight += incer
+		if self.run_weight > tgrw:
+			self.run_weight -= incer
+		if self.walk_weight <= 0:
+			self.walk_weight = 0
+		if self.walk_weight > .95:            
+			self.walk_weight = 1        
+		if self.run_weight <= 0:
+			self.run_weight = 0
+		if self.run_weight > .95:
+			self.run_weight = 1
+
+
+		if dict['kb_lsh'] == 2 or dict['aBut'] == 1:
+			self.run_speed = 1.3
+		else:
+			self.run_speed = .8
+		#print(self.run_speed, '---', self.walk_weight, 'walk weight', self.run_weight, 'run weight')
+
+	def Exit(self):
+		self.FSM.owner.arm.stopAction(0)
+		self.FSM.owner.arm.stopAction(1)
+		self.FSM.owner.arm.stopAction(2)
+		self.FSM.owner.arm.stopAction(3)
+		self.FSM.owner.deck_arm.stopAction(0)
+		self.FSM.owner.deck_arm.stopAction(1)
+		self.FSM.owner.deck_arm.stopAction(2)
+		self.FSM.owner.deck_arm.stopAction(3)
+		dict['walk'] = 0
 
 
 #==================================== 
-            
+			
 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.owner.check_reset_point()  
-        arm = self.FSM.owner.arm
-        deck_arm = self.FSM.owner.deck_arm
-        #arm.playAction('a_jump_t', 23, 23, layer=3, play_mode=1, speed=1, blendin=5)
-        arm.playAction('c_jump_up', 23, 23, layer=3, play_mode=1, speed=1, blendin=15)
-        deck_arm.playAction('b_walk_jump', 23, 23, layer=3, play_mode=1, speed=1, blendin=15)
-
-        if self.FSM.owner.obj.linearVelocity.z < -10:
-            self.FSM.owner.obj.linearVelocity.z = -10
-        moving = self.FSM.owner.walk_movement() 
-        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.ToTransition('toWalkLand')  
-
-
-
-            if dist > .5 and self.FSM.owner.obj.worldPosition.z < self.FSM.owner.last_pos.z: 
-                hang_ray = self.FSM.owner.get_hang_ray()           
-                hang_align_ray = self.FSM.owner.get_hang_align_ray()
-
-                if hang_ray[0] != None and hang_align_ray[0] != None and self.FSM.prevState != 'WalkHang' and dict['lUD'] < .04:
-                    hr_dist = self.FSM.owner.get_hang_dist(hang_ray)
-                    if hr_dist < .1:
-                        self.FSM.owner.obj.linearVelocity = [0,0,0]
-                        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)
-        self.FSM.owner.arm.stopAction(2)
-        self.FSM.owner.arm.stopAction(3)
-        self.FSM.owner.deck_arm.stopAction(0)
-        self.FSM.owner.deck_arm.stopAction(1)
-        self.FSM.owner.deck_arm.stopAction(2)
-        self.FSM.owner.deck_arm.stopAction(3)
+	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.owner.check_reset_point()  
+		arm = self.FSM.owner.arm
+		deck_arm = self.FSM.owner.deck_arm
+		#arm.playAction('a_jump_t', 23, 23, layer=3, play_mode=1, speed=1, blendin=5)
+		arm.playAction('c_jump_up', 23, 23, layer=3, play_mode=1, speed=1, blendin=15)
+		deck_arm.playAction('b_walk_jump', 23, 23, layer=3, play_mode=1, speed=1, blendin=15)
+
+		if self.FSM.owner.obj.linearVelocity.z < -10:
+			self.FSM.owner.obj.linearVelocity.z = -10
+		moving = self.FSM.owner.walk_movement() 
+		ground_rays = self.FSM.owner.get_ground_ray() 
+
+		self.FSM.owner.check_throw()
+		self.check_onboard()
+		self.FSM.owner.align_walk_z()
+		self.FSM.owner.check_pause()
+		if ground_rays[0][0] != None:
+			dist = self.FSM.owner.get_ground_dist(ground_rays)
+			if dist < .4:
+					self.FSM.ToTransition('toWalkLand')  
+
+
+
+			if dist > .5 and self.FSM.owner.obj.worldPosition.z < self.FSM.owner.last_pos.z: 
+				hang_ray = self.FSM.owner.get_hang_ray()           
+				hang_align_ray = self.FSM.owner.get_hang_align_ray()
+
+				if hang_ray[0] != None and hang_align_ray[0] != None and self.FSM.prevState != 'WalkHang' and dict['lUD'] < .04:
+					hr_dist = self.FSM.owner.get_hang_dist(hang_ray)
+					if hr_dist < .1:
+						self.FSM.owner.obj.linearVelocity = [0,0,0]
+						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)
+		self.FSM.owner.arm.stopAction(2)
+		self.FSM.owner.arm.stopAction(3)
+		self.FSM.owner.deck_arm.stopAction(0)
+		self.FSM.owner.deck_arm.stopAction(1)
+		self.FSM.owner.deck_arm.stopAction(2)
+		self.FSM.owner.deck_arm.stopAction(3)
 
 #==================================== 
-            
+			
 class WalkJump(State):
-    def __init__(self,FSM):
-        super(WalkJump, self).__init__(FSM)    
-        
-    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)
-        arm.playAction('c_jump_up', 1, 23, layer=3, play_mode=0, speed=1, blendin=5)
-        deck.playAction('b_walk_jump', 1, 23, layer=3, play_mode=0, speed=1, blendin=5)
-            
-
-        super(WalkJump, self).Enter()        
-        
-    def Execute(self):
-        self.FSM.stateLife += 1
-        arm = self.FSM.owner.arm
-        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:
-                     o.applyForce(force, True)
-
-        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
+	def __init__(self,FSM):
+		super(WalkJump, self).__init__(FSM)    
+		
+	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)
+		arm.playAction('c_jump_up', 1, 23, layer=3, play_mode=0, speed=1, blendin=5)
+		deck.playAction('b_walk_jump', 1, 23, layer=3, play_mode=0, speed=1, blendin=5)
+			
+
+		super(WalkJump, self).Enter()        
+		
+	def Execute(self):
+		self.FSM.stateLife += 1
+		arm = self.FSM.owner.arm
+		o = self.FSM.owner.obj
+
+		moving = self.FSM.owner.walk_movement()              
+		self.check_onboard()
+		self.FSM.owner.check_pause()
+		if self.FSM.stateLife == 10:
+				force = [ 0.0, 0.0, dict['walk_jump_force']]
+				if o.linearVelocity.z < 10:
+					 o.applyForce(force, True)
+
+		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
 
 #==================================== 
-            
+			
 class WalkLand(State):
-    def __init__(self,FSM):
-        super(WalkLand, self).__init__(FSM)    
-        
-    def Enter(self):
-        self.FSM.stateLife = 1
-        #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()        
-        
-    def Execute(self):
-        self.FSM.stateLife += 1
-        self.FSM.owner.obj.linearVelocity.x *= .8
-        self.FSM.owner.obj.linearVelocity.y *= .8
-        # arm = self.FSM.owner.arm
-        
-        # print('af', arm.getActionFrame(5))
-        # if arm.getActionFrame(5) > 30:
-        #     print('stopping land')
-        #     arm.stopAction(5)
-        #     arm.playAction('reg_idle1', 1,120, layer=1, play_mode=1, speed=1, blendin=2)
-        if self.FSM.stateLife > 30:
-            self.FSM.ToTransition('toWalk')
-
-        ground_rays = self.FSM.owner.get_ground_ray() 
-        if ground_rays[0][0] != None:
-            dist = self.FSM.owner.get_ground_dist(ground_rays)
-            self.FSM.owner.set_walk_z(dist)
-
-    def Exit(self):
-        pass
+	def __init__(self,FSM):
+		super(WalkLand, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.FSM.stateLife = 1
+		#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()        
+		
+	def Execute(self):
+		self.FSM.stateLife += 1
+		self.FSM.owner.obj.linearVelocity.x *= .8
+		self.FSM.owner.obj.linearVelocity.y *= .8
+		# arm = self.FSM.owner.arm
+		
+		# print('af', arm.getActionFrame(5))
+		# if arm.getActionFrame(5) > 30:
+		#     print('stopping land')
+		#     arm.stopAction(5)
+		#     arm.playAction('reg_idle1', 1,120, layer=1, play_mode=1, speed=1, blendin=2)
+		if self.FSM.stateLife > 30:
+			self.FSM.ToTransition('toWalk')
+
+		self.FSM.owner.check_pause()
+		ground_rays = self.FSM.owner.get_ground_ray() 
+		if ground_rays[0][0] != None:
+			dist = self.FSM.owner.get_ground_dist(ground_rays)
+			self.FSM.owner.set_walk_z(dist)
+
+	def Exit(self):
+		pass
 
 #==================================== 
-            
+			
 class WalkHang(State):
-    def __init__(self,FSM):
-        super(WalkHang, self).__init__(FSM)    
-        
-    def Enter(self):
-        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()        
-        
-    def Execute(self):
-        self.FSM.stateLife += 1
-        self.FSM.owner.obj.linearVelocity = [0,0,0]
-        #self.FSM.owner.arm.playAction('c_braced_hang', 0, 36, layer=2, play_mode=0, speed=1, blendin=10)
-        self.FSM.owner.arm.playAction('c_braced_hang', 36, 50, layer=1, play_mode=1, speed=1, blendin=10)
-        if dict['lUD'] > .04:
-            self.FSM.ToTransition('toWalkAir')
-           
-        
-        self.FSM.owner.move_walk_cam()
-        if self.FSM.stateLife > 25:
-            self.moveable = True
-        if self.moveable:
-            if dict['lUD'] < -.04:
-                self.FSM.ToTransition('toWalkClimb') 
-            self.FSM.owner.hang_move()
-        ground_rays = self.FSM.owner.get_ground_ray() 
-        if ground_rays[0][0] != None:
-            dist = self.FSM.owner.get_ground_dist(ground_rays)
-            if dist < .4:
-                self.FSM.ToTransition('toWalkLand') 
-
-        hang_ray = self.FSM.owner.get_hang_ray()           
-        hang_align_ray = self.FSM.owner.get_hang_align_ray()
-        #print(hang_align_ray, 'hang_align_ray')
-        #self.FSM.owner.hang_move()
-
-
-
-        if hang_ray[0] != None:
-            hr_dist = self.FSM.owner.get_hang_dist(hang_ray)
-            #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])
-                v = hang_align_ray[2]
-                self.FSM.owner.obj.alignAxisToVect(v, 0, .5)    
-        else:
-            self.FSM.ToTransition('toWalkAir')
-        if hang_align_ray[0] == None:
-            self.FSM.ToTransition('toWalkAir')
-
-        self.FSM.owner.align_walk_z()
-    def Exit(self):
-        pass
+	def __init__(self,FSM):
+		super(WalkHang, self).__init__(FSM)    
+		
+	def Enter(self):
+		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()        
+		
+	def Execute(self):
+		self.FSM.stateLife += 1
+		self.FSM.owner.obj.linearVelocity = [0,0,0]
+		#self.FSM.owner.arm.playAction('c_braced_hang', 0, 36, layer=2, play_mode=0, speed=1, blendin=10)
+		self.FSM.owner.arm.playAction('c_braced_hang', 36, 50, layer=1, play_mode=1, speed=1, blendin=10)
+		if dict['lUD'] > .04:
+			self.FSM.ToTransition('toWalkAir')
+		   
+		
+		self.FSM.owner.move_walk_cam()
+		self.FSM.owner.check_pause()
+		if self.FSM.stateLife > 25:
+			self.moveable = True
+		if self.moveable:
+			if dict['lUD'] < -.04:
+				self.FSM.ToTransition('toWalkClimb') 
+			self.FSM.owner.hang_move()
+		ground_rays = self.FSM.owner.get_ground_ray() 
+		if ground_rays[0][0] != None:
+			dist = self.FSM.owner.get_ground_dist(ground_rays)
+			if dist < .4:
+				self.FSM.ToTransition('toWalkLand') 
+
+		hang_ray = self.FSM.owner.get_hang_ray()           
+		hang_align_ray = self.FSM.owner.get_hang_align_ray()
+		#print(hang_align_ray, 'hang_align_ray')
+		#self.FSM.owner.hang_move()
+
+
+
+		if hang_ray[0] != None:
+			hr_dist = self.FSM.owner.get_hang_dist(hang_ray)
+			#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])
+				v = hang_align_ray[2]
+				self.FSM.owner.obj.alignAxisToVect(v, 0, .5)    
+		else:
+			self.FSM.ToTransition('toWalkAir')
+		if hang_align_ray[0] == None:
+			self.FSM.ToTransition('toWalkAir')
+
+		self.FSM.owner.align_walk_z()
+	def Exit(self):
+		pass
 
 #==================================== 
-            
+			
 class WalkClimb(State):
-    def __init__(self,FSM):
-        super(WalkClimb, self).__init__(FSM)    
-        
-    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):
-        self.FSM.stateLife += 1
-        #self.FSM.ToTransition('toLand')
-        
-        if self.FSM.stateLife > 25:
-            self.FSM.owner.obj.applyForce([-300, 0, 80], True)
-        else:
-            self.FSM.owner.obj.applyForce([-20, 0, 80], True)    
-        if self.FSM.stateLife > 35:
-            self.FSM.ToTransition('toWalkLand')
-        
-    def Exit(self):
-        pass                                
+	def __init__(self,FSM):
+		super(WalkClimb, self).__init__(FSM)    
+		
+	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):
+		self.FSM.stateLife += 1
+		#self.FSM.ToTransition('toLand')
+		self.FSM.owner.check_pause()
+		if self.FSM.stateLife > 25:
+			self.FSM.owner.obj.applyForce([-300, 0, 80], True)
+		else:
+			self.FSM.owner.obj.applyForce([-20, 0, 80], True)    
+		if self.FSM.stateLife > 35:
+			self.FSM.ToTransition('toWalkLand')
+		
+	def Exit(self):
+		pass                                
 
 #==================================== 
-            
+			
 class WalkHurdle(State):
-    def __init__(self,FSM):
-        super(WalkHurdle, self).__init__(FSM)    
-        
-    def Enter(self):
-        self.FSM.stateLife = 1
-        super(WalkHurdle, self).Enter()        
-        
-    def Execute(self):
-        self.FSM.stateLife += 1
-        #self.FSM.ToTransition('toLand')
-        
-    def Exit(self):
-        pass                                
+	def __init__(self,FSM):
+		super(WalkHurdle, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.FSM.stateLife = 1
+		super(WalkHurdle, self).Enter()        
+		
+	def Execute(self):
+		self.FSM.stateLife += 1
+		#self.FSM.ToTransition('toLand')
+		
+	def Exit(self):
+		pass                                
 
 
 #==================================== 
 
-            
+			
 class WalkOnboard(State):
-    def __init__(self,FSM):
-        super(WalkOnboard, self).__init__(FSM)    
-        
-    def Enter(self):
-        self.FSM.stateLife = 1
-        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('toRoll')
-        
-    def Exit(self):
-        pass
+	def __init__(self,FSM):
+		super(WalkOnboard, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.FSM.stateLife = 1
+		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('toRoll')
+		
+	def Exit(self):
+		pass
 
 #==================================== 
 
 
-            
+			
 class AirOnboard(State):
-    def __init__(self,FSM):
-        super(AirOnboard, self).__init__(FSM)    
-        
-    def Enter(self):
-        self.FSM.stateLife = 1
-        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)
-
-        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
-        print('@@@@@@@@@@@@@@@@@@@@@@@@@@@air ob')
-        self.FSM.ToTransition('toRoll')
-        
-    def Exit(self):
-        pass
+	def __init__(self,FSM):
+		super(AirOnboard, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.FSM.stateLife = 1
+		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)
+
+		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('toRoll')
+		
+	def Exit(self):
+		pass
 
 #==================================== 
-            
+			
 class Roll(State):
-    def __init__(self,FSM):
-        super(Roll, self).__init__(FSM)    
-        
-    def Enter(self):
-        self.FSM.stateLife = 1
-        # self.FSM.owner.obj['getoffboard'] == False
-        # dict['walk'] = 0
-        print('roll entered')
-        super(Roll, self).Enter()        
-        
-    def Execute(self):
-        self.FSM.stateLife += 1
-        if dict['walk'] == 1 or self.FSM.owner.obj['getoffboard'] == True:
-            dict['walk'] = 1
-            self.FSM.owner.obj['getoffboard'] = True
-            #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')
-        #self.FSM.ToTransition('toLand')
-        
-    def Exit(self):
-        pass
+	def __init__(self,FSM):
+		super(Roll, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.FSM.stateLife = 1
+		# self.FSM.owner.obj['getoffboard'] == False
+		# dict['walk'] = 0
+		print('roll entered')
+		super(Roll, self).Enter()        
+		
+	def Execute(self):
+		self.FSM.stateLife += 1
+		if dict['walk'] == 1 or self.FSM.owner.obj['getoffboard'] == True:
+			dict['walk'] = 1
+			self.FSM.owner.obj['getoffboard'] = True
+			#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')
+		#self.FSM.ToTransition('toLand')
+		
+	def Exit(self):
+		pass
 
 #==================================== 
 
 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
+	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):
-        self.FSM.stateLife += 1
-        print('ragdolling')
-        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('toOffboard')
-        self.FSM.owner.move_walk_cam()
-    def Exit(self):
-        print('ragdoll_player_fsm exited')
-        self.FSM.owner.obj['ragdoll_active'] = False
-        #pass                                
+	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):
+		self.FSM.stateLife += 1
+		#print('ragdolling')
+		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('toOffboard')
+		self.FSM.owner.move_walk_cam()
+		self.FSM.owner.check_pause()
+	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):
-        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
+	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()
+		self.FSM.owner.check_pause()
+
+		
+		
+
+
+	def Exit(self):
+		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
 
 
 
 #==================================== 
+
+#==================================== 
+			
+class Pause(State):
+	def __init__(self,FSM):
+		super(Pause, self).__init__(FSM)    
+		
+	def Enter(self):
+		self.FSM.stateLife = 1
+		super(Pause, self).Enter()        
+		
+	def Execute(self):
+		self.FSM.stateLife += 1
+		#print('******paused')
+		self.FSM.owner.obj['walk'] = True
+		if dict['npause'] == False:
+			n = self.FSM.prevState.__class__.__name__
+			n = 'to' + n
+			#self.FSM.ToTransition('toWalk')
+			self.FSM.ToTransition(n)
+		
+	def Exit(self):
+		pass
+
+#==================================== 

scripts/actionsFSMlist.py

 	#player armature action name, start, end frames
 	'fak_BS_Board2', 1, 40,
 	#deck action name, start, end frames  
-	'b_reg', 1, 40,
+	'b_fak_bsboard', 1, 40,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
 	1, 1, 0, 10,
 	#intro, length
 	#player armature action name, start, end frames
 	'fak_BS_Board2', 41, 80,
 	#deck action name, start, end frames  
-	'b_reg', 1, 1,
+	'b_fak_bsboard', 1, 40,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
 	1, .5, 1, 15,
 	#intro, length
 	#player armature action name, start, end frames
 	'fak_FS_Board2', 1, 40,
 	#deck action name, start, end frames  
-	'b_reg', 1, 40,
+	'b_fak_bsboard', 1, 40,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
 	1, 1, 0, 10,
 	#intro, length

scripts/boneRecord.py

 #bone_list = ['root', 'head']
 
 def Record():   
-    print('bone recording') 
+    #print('bone recording') 
     scene = bge.logic.getCurrentScene()
     #own = cont.owner
     master = scene.objects['control_cube.002']
         master[str(y) + '-pos'].append(pos)
         master[str(y) + '-rot'].append(rot)
 
+    # pl = master['foot.ik.R-pos'][len(master['foot.ik.R-pos']) - 1]
+
+    # if dict['player_class'].obj['ragdoll_active']:
+    #     rdfp = armature.worldPosition - scene.objects['npc_ed_arm_phys_foot.ik.R'].worldPosition
+    #     print('rd foot pos', rdfp)
+    #     #print(dict['player_class'].obj['ragdoll_active'], 'is ragdolling')
+    # else:
+    #     print('foot pos', pl)
+
+    #print(len(master['foot.ik.R-pos']), 'br length---')
+
 
 
     for y in deck_list:

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
 
         if d2 > .3 and own['airup'] == 1 and localRay_v[0] == None:
             #pass
-            own.alignAxisToVect(gray.hitNormal, 2, .03)
+            #own.alignAxisToVect(gray.hitNormal, 2, .03)
+            #own.alignAxisToVect(gray.hitNormal, 2, .08)
+            own.alignAxisToVect([0,0,1], 2, .08)
         if d2 > .3 and own['airup'] == 0 and localRay_v[0] == None:
 
             distance = own.getDistanceTo(gray.hitPosition)
             own.alignAxisToVect([0.0, 0.0, 1.0], 2, .05)  
         if localRay_v[0] and own['LAST_GRIND'] == False and rBump == 0 and lBump == 0 and ((own['framenum'] - own['last_transition_frame'] < 10) or (own['framenum'] - own['last_vert_frame'] < 10)):
             own['vert'] = 1
-            print('vert hit')
+            #print('vert hit')
             ud_sens = .04      
             if 'spine' in localRay_v[0] and lUD < -.04:
                 if STANCE == True:
                 #     own.applyMovement((0, 0, (.295 - (localHitDist))), True)
             else:
                 own.alignAxisToVect([0,0,1], 2, .1)
-                print('doing nothing')            
+                #print('doing nothing')            
 
     localHitDist = 1000
     raytof = scene.objects['rayTo_f']

scripts/game.py

 import FSM
 import requests
 import platform
+import os
 
 def phone_home():
 	url = 'https://shuvit.org/phone_home.php'
 	print('phone home response')
 	print(x.text)
 
+def get_map_list():
+	out = []
+	ldir = bge.logic.expandPath("//assets/maps")
+	out = os.listdir(ldir)
+	print('$$$$$$$$$$$$$$$$$$$$$$$out', out)
+	return out
+
 def main(cont):
 	own = cont.owner
 	dict = bge.logic.globalDict
 		own['cont'] = cont
 		dict['gameFSM'] = FSM.GameFSM(own)
 		dict['game_life'] = 0
+		dict['maps'] = get_map_list()
 		#phone_home()
-
+	if 'game_life' in dict:
+		dict['game_life'] += 1
 	dict['gameFSM'].Execute()
-	dict['game_life'] += 1
+	

scripts/grindV2.py

 
         #print(own['inverting'])
         #if frames_grinding > 20 and own['inverting'] == False:
-        if frames_grinding > 20:    
-            #print("setting stance")
-            if (rot == 90 or rot == -270) and STANCE == True:
-                #print("90 fak stance")
-                own['stance'] = 1
-                STANCE = 1
-            if (rot == 90 or rot == -270) and STANCE == False:
-                #print("90 fak stance")
-                own['stance'] = 1
-                STANCE = 1
-            if (rot == -90 or rot == 270) and STANCE == True:
-                #print("-90 reg stance")
-                own['stance'] = 0
-                STANCE = 0
-            if (rot == -90 or rot == 270) and STANCE == False:
-                #print("-90 reg stance")
-                own['stance'] = 0
-                STANCE = 0
+        #print('obj', grindDar.hitObjectList[0])
+        if 'edge' in grindDar.hitObjectList[0]:
+            #print('do not fucking change stance')
+
+
+
+
+            if frames_grinding > 20:    
+                #print("setting stance")
+                if (rot == 90 or rot == -270) and STANCE == True:
+                    #print("90 fak stance")
+                    own['stance'] = 1
+                    STANCE = 1
+                if (rot == 90 or rot == -270) and STANCE == False:
+                    #print("90 fak stance")
+                    own['stance'] = 1
+                    STANCE = 1
+                if (rot == -90 or rot == 270) and STANCE == True:
+                    #print("-90 reg stance")
+                    own['stance'] = 0
+                    STANCE = 0
+                if (rot == -90 or rot == 270) and STANCE == False:
+                    #print("-90 reg stance")
+                    own['stance'] = 0
+                    STANCE = 0
 
     def grindrotvel(obj):
         joinit = 0

scripts/levelLibload.py

+import bge
+
+def main(cont):
+    own = cont.owner
+    scene = bge.logic.getCurrentScene()
+    dict = bge.logic.globalDict
+    
+    mainDir = bge.logic.expandPath("//")
+    fileName = mainDir + 'assets/maps/' + dict['map'] + '/map.blend'   
+    path = bge.logic.expandPath(fileName)
+    bge.logic.LibLoad(path, 'Scene', load_actions=True) 
+    

scripts/npause.py

         else:
             cont.activate(cont.actuators['walk'])    
         try:
-            own.setLinearVelocity(own['pre_pause_linvel'], 1) 
+            if own['walk'] == False:
+                own.setLinearVelocity(own['pre_pause_linvel'], 1) 
         except:
             pass    
         cont.activate(cont.actuators['remove_overlay'])  

scripts/pause_menu2.py

 
 def check_idle():
     dict = bge.logic.globalDict
-    dict['menu_idle_timer'] +=1
-    idle = 0
-    if dict['aBut'] or dict['bBut'] or dict['xBut'] or dict['yBut'] or dict['ddPad'] or dict['udPad'] or dict['ldPad'] or dict['rdPad'] or (dict['lUD'] > .02 or dict['lUD'] < -.02) or (dict['lLR'] > .02 or dict['lLR'] < -.02) or (dict['rUD'] > .02 or dict['rUD'] < -.02) or (dict['rLR'] > .02 or dict['rLR'] < -.02):
-        dict['menu_idle_timer'] = 0
-    #print('idtime', dict['menu_idle_timer']) 
-    if dict['menu_idle_timer'] > 500:
-        idle =1
-    return idle                        
+    if 'pause_menu_text' in dict:
+        dict['menu_idle_timer'] += 1
+        idle = 0
+        if dict['aBut'] or dict['bBut'] or dict['xBut'] or dict['yBut'] or dict['ddPad'] or dict['udPad'] or dict['ldPad'] or dict['rdPad'] or (dict['lUD'] > .02 or dict['lUD'] < -.02) or (dict['lLR'] > .02 or dict['lLR'] < -.02) or (dict['rUD'] > .02 or dict['rUD'] < -.02) or (dict['rLR'] > .02 or dict['rLR'] < -.02):
+            dict['menu_idle_timer'] = 0
+        #print('idtime', dict['menu_idle_timer']) 
+        if dict['menu_idle_timer'] > 500:
+            idle =1
+        return idle                        
 
 def update_text(cont):
     own = cont.owner
     scene = bge.logic.getCurrentScene()
     dict = bge.logic.globalDict
-    if dict['pause_menu_text'] == '':
-        scene.objects['menu_text'].text = 'menu > fuck' 
-    else:
-        if 'menu_text' in scene.objects: 
-            scene.objects['menu_text'].text = dict['pause_menu_text']   
-        if 'menu_text.001' in scene.objects: 
-            scene.objects['menu_text.001'].text = dict['pause_menu_text']               
+    if 'pause_menu_text' in dict:
+        if dict['pause_menu_text'] == '':
+            scene.objects['menu_text'].text = 'menu > fuck' 
+        else:
+            if 'menu_text' in scene.objects: 
+                scene.objects['menu_text'].text = dict['pause_menu_text']   
+            if 'menu_text.001' in scene.objects: 
+                scene.objects['menu_text.001'].text = dict['pause_menu_text']               
 
-#    scene = bge.logic.getCurrentScene()
-    for object in scene.objects:
-        if isinstance(object, bge.types.KX_FontObject):
-            object.resolution = 16     
-                    
-    info = ('Music > ' + dict['mu_artist'] + ' - ' + dict['mu_title'])
-    #print(info)
-    try:
-        scene.objects['music_info_txt'].text = info                       
-    except:
-        pass    
-                    
+    #    scene = bge.logic.getCurrentScene()
+        for object in scene.objects:
+            if isinstance(object, bge.types.KX_FontObject):
+                object.resolution = 16     
+                        
+        info = ('Music > ' + dict['mu_artist'] + ' - ' + dict['mu_title'])
+        #print(info)
+        try:
+            scene.objects['music_info_txt'].text = info                       
+        except:
+            pass    
+                        
                     
 def main(cont):
     update_text(cont)  

scripts/player.py

 from mathutils import Vector
 import math
 import mathutils
+import random
 
 dict = bge.logic.globalDict
 
 		self.throw_deck_empty = self.obj.childrenRecursive["throw_deck_empty"]
 		self.step = True
 		self.dropin_obj = None
-
+		self.joystick_active_frame = 0
+		self.joystick_idle = False
+		self.idle_cam_dir = True
 		#self.throw_deck_obj = dict['level_scene'].objects['throw_deck']
 		dict['walking'] = True
 		#print(self.obj.childrenRecursive)
 
 	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
+			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
 		o.worldOrientation = te.worldOrientation
 		o.linearVelocity = [0,0,0]
 
+	def check_pause(self):
+		if dict['npause'] == True:
+			self.FSM.FSM.ToTransition('toPause')
+
+	def check_idle(self, resetter):
+		idle = True
+		sens = .03
+		
+		if resetter:
+			idle = False
+		else:
+			if abs(dict['lUD']) > sens:
+				idle = False
+			elif abs(dict['lLR']) > sens:
+				idle = False
+			elif abs(dict['rUD']) > sens:
+				idle = False
+			elif abs(dict['rLR']) > sens:
+				idle = False
+			elif abs(dict['rTrig']) > sens:
+				idle = False
+			elif abs(dict['lTrig']) > sens:
+				idle = False
+			elif dict['aBut'] == True:
+				idle = False
+			elif dict['bBut'] == True:
+				idle = False
+			elif dict['xBut'] == True:
+				idle = False
+			elif dict['yBut'] == True:
+				idle = False
+			elif dict['udPad'] == True:
+				idle = False
+			elif dict['ddPad'] == True:
+				idle = False
+			elif dict['ldPad'] == True:
+				idle = False
+			elif dict['rdPad'] == True:
+				idle = False
+
+		if self.joystick_idle == True and idle == False:
+			self.arm.stopAction(6)		
+			self.deck_arm.stopAction(6)		
+			self.joystick_idle = False
+		if not idle:
+			self.joystick_active_frame = dict['game_life']
+		else:
+			idle_time = dict['game_life'] - self.joystick_active_frame
+			if idle_time > 400:
+				self.joystick_idle = True
+
+	def idle_anim(self):
+		if self.joystick_idle:
+			#if self.arm.isPlayingAction(6):
+			
+			if 1 == 2:
+				pass
+			else:
+				if dict['game_life'] % 280 == 1:
+
+						# 'reg_idle2_', 1, 120,
+						# #deck action name, start, end frames  
+						# 'b_reg_idle2', 1, 120,
+
+					#choice = random
+
+					s_list = ['reg_idle1', 'reg_idle2_', 'reg_idle3', 'reg_idle4', 'reg_idle5', 'reg_idle6', 'reg_idle7']
+					d_list = ['b_reg_idle1', 'b_reg_idle2', 'b_reg_idle3', 'b_reg_idle4', 'b_reg_idle5', 'b_reg_idle6', 'b_reg_idle7']
+
+					random_index = random.randrange(len(s_list))
+					
+					self.arm.playAction(s_list[random_index], 1, 120, layer=6, play_mode=0, speed=.5, blendin=15)
+					self.deck_arm.playAction(d_list[random_index], 1, 120, layer=6, play_mode=0, speed=.5, blendin=15)
+					#print('play an idle', s_list[random_index], d_list[random_index])
+					
+				if dict['game_life'] % 1280 == 1:				
+					self.idle_cam_dir = not self.idle_cam_dir
+			
+				#print('modded', dict['game_life'] % 280, dict['game_life'])
+				if self.idle_cam_dir:
+					dict['camera'].applyMovement([.0005, 0, 0], True)
+					dict['camera'].applyRotation([.0005, 0, .0005], True)
+				else:
+					dict['camera'].applyMovement([-.0005, 0, 0], True)
+					dict['camera'].applyRotation([-.0005, 0, -.0005], True)
+				# move_len = 2048
+		  #       if own['idlecampos_x'] < move_len:
+		  #           own['idlecampos_x'] += 1
+		  #       if own['idlecampos_x'] == move_len:
+		  #          own['idlecampos_x'] = 0
+
+		  #       if own['idlecampos_x'] < (move_len / 2):
+		  #           move = [.0001, 0, 0]
+		  #           freecam.applyMovement( move, True)
+		  #           freecam.applyRotation([.0001, 0, .0001], True)
+		  #       if own['idlecampos_x'] > (move_len / 2):
+		  #           move = [-.0001, 0, 0]
+		  #           freecam.applyMovement(move, True)
+		  #           freecam.applyRotation([-.0001, 0, -.0001], True)
+
 
 def update(cont):
 	#print('-------------player updating----------------')

scripts/ragdoll.py

     return bone.pose_matrix * offset_m4.inverted()
 
 def zero_constraints(own, scene):
+    own['rd_incer'] = 0
     armature = scene.objects['Char4']
     for const in armature.constraints:
         
             cont.actuators['Camera'].damping = .000001
             cont.activate(cont.actuators['Camera']) 
             own.suspendDynamics(True)
+
             
     else:
 
             #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'].worldOrientation = scene.objects['ragdoll_parent'].worldOrientation.copy()
+            #scene.objects['control_cube.002'].applyRotation([-3.14/2,3.14/2, 0], True)
+            scene.objects['control_cube.002'].worldPosition = scene.objects['npc_ed_arm_phys_master'].worldPosition.copy()
+            scene.objects['control_cube.002'].worldOrientation = scene.objects['npc_ed_arm_phys_master'].worldOrientation.copy()
+            scene.objects['control_cube.002'].applyRotation([3.14/2,3.14/2, 0], True)
             #print('doing the active thing')
 
 
                 own['getonboard'] = True
                 dict['walk'] = 0
                 own['fall'] = False
+                own.alignAxisToVect([0,0,1], 2, .99)
             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']

scripts/scene_init.py

             print('starting music') 
         else:
             print('not starting music', dict['music_player'])        
-            
-        for x in scene.objects:
+        
+        dict['sun_lights'] = []    
+        dict['ambient_lights'] = []    
+        for x in scene.lights:
             if 'hemi' in x:
                 if 'down' in x:
                     x.energy = dict['ambient_strength']
+                    dict['ambient_lights'].append(x)
                 else:
                     x.energy = dict['ambient_strength'] * .7    
+                    dict['ambient_lights'].append(x)
 
             if 'sun' in x:
                 x.energy = dict['sun_strength']
+                dict['sun_lights'].append(x)
         #scene.world.envLightEnergy = dict['ambient_strength']   
         #scene.world.envLightEnergy = 0
         
         own['grinding'] = False
         own['ground_since'] = 100
         own['last_transition_frame'] = 0
+        #own['aState'] = 'reg_roll'
         
         colors.update_shirt_tex() 
         colors.update_truck_tex()

scripts/sound_man.py

 import bge
 import aud
 
+dict = bge.logic.globalDict
+
 def init_sounds(self):
 	#pop
 
 			c.handle_buffered.stop()
 
 	def Record(self):
+		
+
+		self.history.append(self.h_queue)
 		self.history.append(self.h_queue)
 		#self.history.insert(0, self.h_queue)
-		
-		#print(self.h_queue, 'appended to history')
+		l = len(self.history)
+		#print(self.h_queue, 'appended to history', l)
 		#self.history.append(self.h_queue)
 		#print('appending', self.h_queue)
 		l = len(self.history)
 		if l > ((self.gd['replay_record_length'])):
-
+			#del self.history[0:1]
+			self.history.pop(0)
 			self.history.pop(0)
 			#self.history.pop(self.gd['replay_record_length'])
 			#self.history.pop(0)
 			#print(self.history[frame], self.queue, frame, 'replay queue')
 		except:
 			print('replay audio not playing', frame, len(self.history))
-		#print('h_queue', self.h_queue, frame)
+		#print('h_queue', self.h_queue, frame, (self.history))
+		#print('h_queue', self.h_queue, frame, len(self.history))
 		if self.h_queue is not []:
 			for ev in self.h_queue:
 				result = getattr(self, ev[0])
 				#print('ev0', ev[0])
 				if result.loop:
-					#result.loop_play(ev[1], ev[2], ev[3], ev[4])
-					pass
+					result.loop_play(ev[1], ev[2], ev[3], ev[4])
+					#pass
 				else:
 					result.play(ev[1], ev[2])
 					#print('... playing', result.name, frame, len(self.history))
 		#own['sndmgr'].Record()
 	if not dict['playback']:
 		own['sndmgr'].update()
+		#print('updating sound manager', dict['game_life'])
 
 	#if dict['playback']:
 		#own['sndmgr'].Playback()	

shuvit.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:d1ad57d6355aae70aaf5a7e4dc2ca1a6917ca514249d3c072e54524ac5e2b0d0
-size 125371052
+oid sha256:990b6a53606aad8b319016525a494c1d4b0188e41fa6619000ad8a44f891dd6a
+size 126713928