Merge branch 'foundations' of Shuvit-Org/shuvit into dev

weee

.~lock.shuvit_assets.ods#

+,rob,rob-XPS,12.05.2020 10:27,file:///home/rob/.config/libreoffice/4;

assets/foiliage_b.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:41e28fb10464bc68bcac66ddee5e21ffc460fa9207706b108802910e130b96bb
+size 43079304

assets/kits/ramps.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:2d4bed47956024b6fdda2f3f743b37b059ce591e0fbc12d3e86cc26c27f8ba9c
-size 149841436
+oid sha256:29696d65de25e271a669c8ce0dbe78f9ffb5b606969c5d8c9294b3d649c3113b
+size 24216420

assets/kits/ramps2.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:498ef10ab3bc64f9507ee4dc827291a714a86b7c843418df64f2f7972f9bb337
-size 24141316
+oid sha256:c6146e4b9d01ad879ad962f9666408f27efac8a3f045411774d2d2f4b30d3627
+size 24031756

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.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:97270cdd70f1424750c52c51b3f0de032422160ad3a6ee7532830b4f2813dbb6
+size 1211092

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.blend

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

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:6c37e5a83e1644e6488940c883139290940717fc94f675b34431f2136b41e62f
-size 35553820
+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/mountainslab01.png

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

assets/materials/textures/mountainslab01_n.png

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

assets/materials/textures/pineforest03.png

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

assets/materials/textures/pineforest03_n.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:72e39a36c94b29279c26f86765645a3ed599f7b5b450ed470abed4d611394a2f
+size 2281480

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/materials/textures/ramp_trans_n.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:98a113465808a42062053be89ad179f1df3ba4fd01c89b7a7aaebbcace35609c
+size 11320

assets/materials/textures/ramp_trans_nb.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:9b06b6f04c271ea6523932def0c1b0813cb7d1df90b0e2f7ee22cfcd61200502
+size 30364

assets/new_ass_test.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:529854bcecbe01c029bf1ba49e97acd152dbc2c2ad7e8b2b32b97d91d025c432
+size 848896

assets/ramps.blend

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

assets/user2.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:967c340fc4b16c93e9c64993595238e08da030575f98ddd663c2f8d6e5810059
-size 19833196
+oid sha256:290945cb39568c3ecffdfe59a94d188c0e20dd7eac5b7c33c4b4393a396d6fac
+size 3403128

assets/utils/mini_ramp_gen15new_text.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:028b82f4ecdbd46bdc2961cb4bcaa074664c2aeba68e18c6ea51795c1dc9759b
-size 119822052
+oid sha256:09b66fd8ac81815a16f9daaf3742ab0397919b0bbf6b9e35988bd1b564d71388
+size 140836564

assets/walls.blend

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

characters/ken.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:e5831d9cf377773a4db5172fb6a16fde1cfc1394fffc1be0adefd45b916fc1fa
-size 2869804
+oid sha256:6ba3abc8379099161710e43cf63b20f31c2a32532d14cc74a36b91429015198a
+size 2870372

config.ini

 resx = 1920
 resy = 1080
 fullscreen_on = 1
-music_player = 0
+music_player = 1
 vsync_on = 0
 #----------
 
 #level
 ######
-level = user2
-levelBlend = user2
+level = indoor
+levelBlend = indoor
+map = Harry's Garage
 #------------
 
 #replay recorder
 
 #camera 
 #######
-cam_height = -0.1
-focal_length = 12
-cam_min = 1.4
+cam_height = -0.3
+focal_length = 10
+cam_min = 2.0
 cam_max = 4.4
 cch_targetHeight = 0.3
 
 
 shirt_logo = 2
 
-shirt_color_r = 0.4
+shirt_color_r = 1
 shirt_color_g = 0.03
 shirt_color_b = 0.03
 
-shoe_color_r = 0.31
-shoe_color_g = 0.23
+shoe_color_r = 1
+shoe_color_g = 0.38
 shoe_color_b = 0
 #-----------------
 
 ###################
 
 #brightness / contrast
-bc = 1
+bc = 0
 BC_BRIGHTNESS = 1.1
 BC_CONTRAST = 1.09
 
 #HDR
 hdr = 1
-avgL = 0.8
+avgL = 0.69
 HDRamount = 0.05
 
 #Ambient Occlusion
 aoradius = 2.4
 
 #Depth of Field
-dof_on = 1
+dof_on = 0
 
 #Bloom
 bloom_on = 0
 
 #FXAA
-fxaa = 1
+fxaa = 0
 FXAA_SPAN_MAX = 8.0
 #-------------------
 
 #sun settings
 #############
-sun_strength = 0.95
-ambient_strength = 0.15
+sun_strength = 1.1
+ambient_strength = 0.18
 sun_rot_x = -0.05
 sun_rot_y = -0.05
 shadow_on = 0
 man_sens_l = 0.03
 man_sens_r = 0.08
 man_sens_side = 0.035
-turn_rotation = 0.0175
+turn_rotation = 0.025#0.0175
 turn_addx = 0.004
 turn_air_rotation = 0.07
 grass_mult = 0.98
 gravity = -10.5
 fall_height = 0.5
 
+walk_force = 15
+run_force = 40
+max_walk_vel = 1.5
+max_run_vel = 5
+walk_turn_amt = 0.03
+walk_jump_force = 1300
+
 #controller mappings
 ########
 lar_lts = 0

scripts/FSM.py

 import bge
 
+import StatesGame
+import StatesPlayer
 import StatesWalker
 import StatesCamera
 import StatesCar
         self.stateLife = 0
         self.owner = owner
         self.name = None
+        self.last_state_notes = None
         
     def AddTransition(self, transName, transition):
         self.transitions[transName] = transition
         self.owner = owner
         
         state_list = [
-        'Example']
+        'Example',
+        'Startup',
+        'Initer',
+        'LoadLevel',
+        'GameOn',
+        'Reload']
         
         for s in state_list:
             self.FSM.AddState(s, getattr(StatesGame, s)(self.FSM))
             self.FSM.AddTransition(t, Transition(s))
         
         if self.FSM.curState == None:
-            self.FSM.SetState('Example')
+            self.FSM.SetState('Startup')
+    
+    def Execute(self):
+        self.FSM.Execute(self.owner)    
+
+#=================================== 
+        
+class PlayerFSM(Char):
+    def __init__(self, owner):
+        self.FSM = FSM(self, owner)
+        self.owner = owner
+        
+        state_list = [
+        'Example',
+        'Startup',
+        'Walk',
+        'WalkJump',
+        'WalkAir',
+        'WalkLand',
+        'WalkHang',
+        'WalkClimb',
+        'WalkHurdle',
+        'WalkOnboard',
+        'AirOnboard',
+        'Offboard', 
+        'Dropin',
+        'Roll',
+        'Ragdoll',
+        'Pause']
+        
+        for s in state_list:
+            self.FSM.AddState(s, getattr(StatesPlayer, s)(self.FSM))
+            t = 'to' + s
+            self.FSM.AddTransition(t, Transition(s))
+        
+        if self.FSM.curState == None:
+            self.FSM.SetState('Startup')
     
     def Execute(self):
         self.FSM.Execute(self.owner)    

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 to_dict2(section, key):
-        dict = bge.logic.globalDict
+        #dict = bge.logic.globalDict
         value = char_config[key]
         if isinstance(value, str):
             if value.isdigit():
     char_config.walk(to_dict2, char_config)
     
 def writeChar():
-    dict = bge.logic.globalDict
+    #dict = bge.logic.globalDict
     mainDir = GameLogic.expandPath("//characters/")    
     fileName = mainDir + dict['character'] + ".ini"
     print('writing character settings', fileName)
     
 
 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):
-    dict = bge.logic.globalDict
+    #dict = bge.logic.globalDict
     config[key] = dict[key]
 
 def writeSettings():
     config.walk(from_dict)  
     config.write()  
-    dict = bge.logic.globalDict
+    #dict = bge.logic.globalDict
      
 def setres():
-    import GameLogic
-    import bge
+    #import GameLogic
+    #import bge
     scenes = bge.logic.getSceneList()
     main_scene = [scene for scene in scenes if scene.name=="main"][0]
     own = main_scene.objects['Empty']
-    cont = GameLogic.getCurrentController()
+    cont = bge.logic.getCurrentController()
     own2 = cont.owner
     dict = bge.logic.globalDict 
     resx = int(dict["resx"])
     #print("resolution = ", resx, resy)       
         
 def loadlevel():
-    import GameLogic
-    import bge
     scenes = bge.logic.getSceneList()
     main_scene = [scene for scene in scenes if scene.name=="main"][0]
     own = main_scene.objects['Empty']
     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 
     
 def timer():
-    import GameLogic
-    import bge    
-
-    dict = bge.logic.globalDict    
+    #dict = bge.logic.globalDict    
     
     if dict['reload_timer'] == 1:
         scene = bge.logic.getCurrentScene()

scripts/Startup.py

 
 def main(cont):
     #cont = bge.logic.getCurrentController() 
+    print('Startup.py running ----------')
     own = cont.owner
     scenes = bge.logic.getSceneList()
 
     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
+    
     
 #main()

scripts/StatesGame.py

-import utils
 import bge
+import random
+
+import Startup as S2
+import Settings
+import inputs
+import logo_fades
+
+dict = bge.logic.globalDict
+#====================================     
 
 State = type("State", (object,), {})
 #====================================     
         print('Executing')
     def Exit(self):
         print('Exiting')
+
 #==================================== 
             
 class Example(State):
         
     def Execute(self):
         self.FSM.stateLife += 1
-        #o = self.FSM.owner
-        #g = o.me['game']
-        #self.FSM.ToTransition('toNewState')
-        #print('cam fsm')
-    
+        #self.FSM.ToTransition('toLand')
+        
+    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 == 2:
+            #Startup.main(self.FSM.owner['cont'])
+
+        self.FSM.ToTransition('toIniter')
+        
+    def Exit(self):
+        pass
+
+#==================================== 
+
+class Initer(State):
+    def __init__(self,FSM):
+        super(Initer, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(Initer, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+
+        if self.FSM.stateLife == 2:
+            print('--------- fsm running startup')
+            S2.main(self.FSM.owner['cont'])
+            #Settings.readSettings(self.FSM.owner['cont'])
+            Settings.readSettings()
+            Settings.setres()
+
+
+        if self.FSM.stateLife == 120:
+
+            self.FSM.ToTransition('toLoadLevel')
+        
+    def Exit(self):
+        pass
+
+
+#==================================== 
+
+class LoadLevel(State):
+    def __init__(self,FSM):
+        super(LoadLevel, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(LoadLevel, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        print('fsm loading level')
+        
+        Settings.loadlevel()
+        
+        self.FSM.ToTransition('toGameOn')
+    def Exit(self):
+        pass
+
+#==================================== 
+
+class GameOn(State):
+    def __init__(self,FSM):
+        super(GameOn, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(GameOn, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        #self.FSM.ToTransition('toLand')
+        #print('game on')
+
+        inputs.main()
+        logo_fades.main()
+
+    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

+import bge
+dict = bge.logic.globalDict
+import sound_man
+#====================================     
+
+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')
+
+#==================================== 
+			
+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
+
+#==================================== 
+
+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
+
+#==================================== 
+			
+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()
+		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()
+		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()
+		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')
+
+		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()
+		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')
+		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                                
+
+
+#==================================== 
+
+			
+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
+
+#==================================== 
+
+
+			
+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
+		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
+
+#==================================== 
+
+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):
+		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()
+		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/actionPlayer.py

 'fak_jump',
 'fak_walk_air',
 'fak_walk_air_out',
-#'fak_onboard',
+'fak_onboard',
 #'fak_offboard',
 'fak_brfoot',
 'fak_frfoot',
 	return aState	
 
 def main(cont):
-	own = cont.owner
 	dict = bge.logic.globalDict
+	if not dict['walking']:
+		own = cont.owner
+		
 
-	#initial state
-	if 'aState' not in own:
-		own['aState'] = 'reg_idle'
-		own['l_aState'] = None
-		own['stateTimer'] = 0
-		own['eaState'] = FSM.EaFSM(own)
-		own['EaRequest'] = None
-	
-	aState = own['aState']
-	rA = own['requestAction']
-	timer = own['stateTimer']
-	newState = own['aState']
-	aState = check_land(rA, aState, own)
-	newState = aState
-	og_state = own['aState']
-	#print(aState)
-	if aState in state_a:
-
-		action = getattr(actionsFSMlist, aState)
-		if own['stateTimer'] < getattr(action, 'intro_frames'):	
-			intro = getattr(action, 'intro')
-			actionPlayer(getattr(actionsFSMlist, intro))	
-		else:
-			actionPlayer(action)
-		newState = check_exit(aState, rA, timer, action)
-			
 
-	elif aState in state_b:
-		action = getattr(actionsFSMlist, aState)
-		actionPlayer(action)
-		if own['stateTimer'] > getattr(action, 'fef'):
+		#initial state
+		if 'aState' not in own:
+			own['aState'] = 'reg_idle'
+			own['l_aState'] = None
+			own['stateTimer'] = 0
+			own['eaState'] = FSM.EaFSM(own)
+			own['EaRequest'] = None
+		
+		aState = own['aState']
+		rA = own['requestAction']
+		timer = own['stateTimer']
+		newState = own['aState']
+		aState = check_land(rA, aState, own)
+		newState = aState
+		og_state = own['aState']
+		#print(aState)
+		if aState in state_a:
+
+			action = getattr(actionsFSMlist, aState)
+			if own['stateTimer'] < getattr(action, 'intro_frames'):	
+				intro = getattr(action, 'intro')
+				actionPlayer(getattr(actionsFSMlist, intro))	
+			else:
+				actionPlayer(action)
 			newState = check_exit(aState, rA, timer, action)
+				
 
-
-###################################
-
-	check_state = 'reg_sit'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		#if own['stateTimer'] < 19:
-		if own['stateTimer'] < getattr(action, 'intro_frames'):	
-			actionPlayer(getattr(actionsFSMlist, 'intro'))
-		else:
+		elif aState in state_b:
+			action = getattr(actionsFSMlist, aState)
 			actionPlayer(action)
-		newState = check_exit(aState, rA, timer, actionsFSMlist.reg_sit)
-
-	#-----------------------
-	check_state = 'reg_walk'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		if own['l_aState'] == 'reg_walkFast':
-			frame = get_frame(actionsFSMlist.reg_walkFast)
-			actionPlayer(action)
-			set_frame(actionsFSMlist.reg_walk, frame)
-		else:	
-			frame = actionPlayer(action)
-		
-		newState = check_exit(aState, rA, timer, action)
+			if own['stateTimer'] > getattr(action, 'fef'):
+				newState = check_exit(aState, rA, timer, action)
+
+
+	###################################
+
+		check_state = 'reg_sit'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
+			#if own['stateTimer'] < 19:
+			if own['stateTimer'] < getattr(action, 'intro_frames'):	
+				actionPlayer(getattr(actionsFSMlist, 'intro'))
+			else:
+				actionPlayer(action)
+			newState = check_exit(aState, rA, timer, actionsFSMlist.reg_sit)
+
+		#-----------------------
+		check_state = 'reg_walk'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
+			if own['l_aState'] == 'reg_walkFast':
+				frame = get_frame(actionsFSMlist.reg_walkFast)
+				actionPlayer(action)
+				set_frame(actionsFSMlist.reg_walk, frame)
+			else:	
+				frame = actionPlayer(action)
+			
+			newState = check_exit(aState, rA, timer, action)
 
-	#-----------------------
-	check_state = 'reg_walkFast'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		newState = check_exit(aState, rA, timer, actionsFSMlist.reg_walkFast)
+		#-----------------------
+		check_state = 'reg_walkFast'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
+			newState = check_exit(aState, rA, timer, actionsFSMlist.reg_walkFast)
 
-		if own['l_aState'] == 'reg_walk':
-			frame = get_frame(actionsFSMlist.reg_walk)
-			actionPlayer(action)
-			set_frame(actionsFSMlist.reg_walkFast, frame)
+			if own['l_aState'] == 'reg_walk':
+				frame = get_frame(actionsFSMlist.reg_walk)
+				actionPlayer(action)
+				set_frame(actionsFSMlist.reg_walkFast, frame)
 
-		else:
-			actionPlayer(action)
+			else:
+				actionPlayer(action)
 
-	check_state = 'reg_push'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		actionPlayer(action)
-		if own['stateTimer'] > 70:
-			newState = 'reg_roll'
-
-	check_state = 'reg_push_goof'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		actionPlayer(action)
-		if own['stateTimer'] > 70:
-			newState = 'reg_roll'			
-	
-	check_state = 'reg_powerslide'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		# if own['stateTimer'] < 20:
-		# 	actionPlayer(actionsFSMlist.reg_powerslide_in)
-		if own['stateTimer'] < getattr(action, 'intro_frames'):	
-			intro = getattr(action, 'intro')
-			actionPlayer(getattr(actionsFSMlist, intro))	
-		else:
-			actionPlayer(action)
-		newState = check_exit(aState, rA, timer, actionsFSMlist.reg_powerslide)
-
-	check_state = 'reg_fs_powerslide'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		# if own['stateTimer'] < 20:
-		# 	actionPlayer(actionsFSMlist.reg_fs_powerslide_in)
-		if own['stateTimer'] < getattr(action, 'intro_frames'):	
-			intro = getattr(action, 'intro')
-			actionPlayer(getattr(actionsFSMlist, intro))	
-		else:
+		check_state = 'reg_push'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
 			actionPlayer(action)
-		newState = check_exit(aState, rA, timer, actionsFSMlist.reg_fs_powerslide)				
-
-
+			if own['stateTimer'] > 70:
+				newState = 'reg_roll'
 
-	check_state = 'fak_sit'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		#if own['stateTimer'] < 19:
-		if own['stateTimer'] < getattr(action, 'intro_frames'):	
-			actionPlayer(getattr(actionsFSMlist, 'intro'))
-		else:
-			actionPlayer(action)
-		newState = check_exit(aState, rA, timer, actionsFSMlist.fak_sit)
-
-	#-----------------------
-	check_state = 'fak_walk'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		if own['l_aState'] == 'fak_walkFast':
-			frame = get_frame(actionsFSMlist.fak_walkFast)
+		check_state = 'reg_push_goof'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
 			actionPlayer(action)
-			set_frame(actionsFSMlist.fak_walk, frame)
-		else:	
-			frame = actionPlayer(action)
+			if own['stateTimer'] > 70:
+				newState = 'reg_roll'			
 		
-		newState = check_exit(aState, rA, timer, action)
+		check_state = 'reg_powerslide'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
+			# if own['stateTimer'] < 20:
+			# 	actionPlayer(actionsFSMlist.reg_powerslide_in)
+			if own['stateTimer'] < getattr(action, 'intro_frames'):	
+				intro = getattr(action, 'intro')
+				actionPlayer(getattr(actionsFSMlist, intro))	
+			else:
+				actionPlayer(action)
+			newState = check_exit(aState, rA, timer, actionsFSMlist.reg_powerslide)
+
+		check_state = 'reg_fs_powerslide'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
+			# if own['stateTimer'] < 20:
+			# 	actionPlayer(actionsFSMlist.reg_fs_powerslide_in)
+			if own['stateTimer'] < getattr(action, 'intro_frames'):	
+				intro = getattr(action, 'intro')
+				actionPlayer(getattr(actionsFSMlist, intro))	
+			else:
+				actionPlayer(action)
+			newState = check_exit(aState, rA, timer, actionsFSMlist.reg_fs_powerslide)				
+
+
+
+		check_state = 'fak_sit'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
+			#if own['stateTimer'] < 19:
+			if own['stateTimer'] < getattr(action, 'intro_frames'):	
+				actionPlayer(getattr(actionsFSMlist, 'intro'))
+			else:
+				actionPlayer(action)
+			newState = check_exit(aState, rA, timer, actionsFSMlist.fak_sit)
+
+		#-----------------------
+		check_state = 'fak_walk'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
+			if own['l_aState'] == 'fak_walkFast':
+				frame = get_frame(actionsFSMlist.fak_walkFast)
+				actionPlayer(action)
+				set_frame(actionsFSMlist.fak_walk, frame)
+			else:	
+				frame = actionPlayer(action)
+			
+			newState = check_exit(aState, rA, timer, action)
 
-	#-----------------------
-	check_state = 'fak_walkFast'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		newState = check_exit(aState, rA, timer, actionsFSMlist.fak_walkFast)
+		#-----------------------
+		check_state = 'fak_walkFast'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
+			newState = check_exit(aState, rA, timer, actionsFSMlist.fak_walkFast)
 
-		if own['l_aState'] == 'fak_walk':
-			frame = get_frame(actionsFSMlist.fak_walk)
-			actionPlayer(action)
-			set_frame(actionsFSMlist.fak_walkFast, frame)
+			if own['l_aState'] == 'fak_walk':
+				frame = get_frame(actionsFSMlist.fak_walk)
+				actionPlayer(action)
+				set_frame(actionsFSMlist.fak_walkFast, frame)
 
-		else:
-			actionPlayer(action)
+			else:
+				actionPlayer(action)
 
 
-	check_state = 'fak_push'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		actionPlayer(action)
-		if own['stateTimer'] > 70:
-			newState = 'fak_roll'
+		check_state = 'fak_push'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
+			actionPlayer(action)
+			if own['stateTimer'] > 70:
+				newState = 'fak_roll'
 
-	check_state = 'fak_push_goof'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		actionPlayer(action)
-		if own['stateTimer'] > 70:
-			newState = 'fak_roll'			
-	
-	check_state = 'fak_powerslide'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		# if own['stateTimer'] < 20:
-		# 	actionPlayer(actionsFSMlist.fak_powerslide_in)
-		if own['stateTimer'] < getattr(action, 'intro_frames'):	
-			intro = getattr(action, 'intro')
-			actionPlayer(getattr(actionsFSMlist, intro))	
-		else:
+		check_state = 'fak_push_goof'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
 			actionPlayer(action)
-		newState = check_exit(aState, rA, timer, actionsFSMlist.fak_powerslide)
-
-	check_state = 'fak_fs_powerslide'
-	if aState == check_state:
-		action = getattr(actionsFSMlist, check_state)
-		# if own['stateTimer'] < 20:
-		# 	actionPlayer(actionsFSMlist.fak_fs_powerslide_in)
-		if own['stateTimer'] < getattr(action, 'intro_frames'):	
-			intro = getattr(action, 'intro')
-			actionPlayer(getattr(actionsFSMlist, intro))	
+			if own['stateTimer'] > 70:
+				newState = 'fak_roll'			
+		
+		check_state = 'fak_powerslide'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
+			# if own['stateTimer'] < 20:
+			# 	actionPlayer(actionsFSMlist.fak_powerslide_in)
+			if own['stateTimer'] < getattr(action, 'intro_frames'):	
+				intro = getattr(action, 'intro')
+				actionPlayer(getattr(actionsFSMlist, intro))	
+			else:
+				actionPlayer(action)
+			newState = check_exit(aState, rA, timer, actionsFSMlist.fak_powerslide)
+
+		check_state = 'fak_fs_powerslide'
+		if aState == check_state:
+			action = getattr(actionsFSMlist, check_state)
+			# if own['stateTimer'] < 20:
+			# 	actionPlayer(actionsFSMlist.fak_fs_powerslide_in)
+			if own['stateTimer'] < getattr(action, 'intro_frames'):	
+				intro = getattr(action, 'intro')
+				actionPlayer(getattr(actionsFSMlist, intro))	
+			else:
+				actionPlayer(action)
+			newState = check_exit(aState, rA, timer, actionsFSMlist.fak_fs_powerslide)				
+
+
+		#-----------------------
+		#print(own['aState'], newState, rA, own['l_aState'])
+		#print()
+		if newState != '':
+			own['aState'] = newState 
+		own['l_aState'] = og_state
+		own['l_actionState'] = og_state
+		state_timer(own)
+		skater = dict['p1']
+		
+		if own['requestAction'] == 'reg_roll' and own['rotz'] < .985:
+			frame = int(own['rotz'] * 70) 
 		else:
-			actionPlayer(action)
-		newState = check_exit(aState, rA, timer, actionsFSMlist.fak_fs_powerslide)				
-
-
-	#-----------------------
-	#print(own['aState'], newState, rA)
-	#print()
-	if newState != '':
-		own['aState'] = newState 
-	own['l_aState'] = og_state
-	own['l_actionState'] = og_state
-	state_timer(own)
-	skater = dict['p1']
-	
-	if own['requestAction'] == 'reg_roll' and own['rotz'] < .985:
-		frame = int(own['rotz'] * 70) 
-	else:
-		skater.stopAction(5)	
+			skater.stopAction(5)	
 
-	#own['eaState'].Execute()
+		#own['eaState'].Execute()
+		#print(dict['walking'], 'walk')

scripts/actionsFSMlist.py

 
 reg_jump = a_class(
 	#player armature action name, start, end frames
-	'reg_jump', 1, 10,
+	#'reg_jump', 1, 10,
+	'a_jump_t', 9, 27,
 	#deck action name, start, end frames  
-	'b_reg_jump', 1, 10,
+	'b_reg_jump', 1, 5,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
-	1, .5, 0, 10,
+	3, .75, 0, 5,
 	#intro, length
 	None, 0,
 	#exits
 	['reg_idle', 'reg_walk_air', 'reg_onboard'],
 	#force exit, frame
-	'reg_walk_air', 20,
+	'reg_walk_air', 12,
 	#opposite
 	None)
 
 reg_walk_air = a_class(
 	#player armature action name, start, end frames
-	'reg_walk_air', 10, 10,
+	#'reg_walk_air', 10, 10,
+	'a_jump_t', 27, 27,
 	#deck action name, start, end frames  
 	'b_reg_walk_air', 10, 10,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
 
 reg_walk_air_out = a_class(
 	#player armature action name, start, end frames
-	'reg_walk_air', 10, 40,
+	#'reg_walk_air', 10, 40,
+	'a_jump_t', 27, 49,
 	#deck action name, start, end frames  
 	'b_reg_walk_air', 10, 40,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
 	#['reg_idle', 'reg_walk', 'reg_walkFast', 'reg_onboard'],
 	walk_exits,
 	#force exit, frame
-	'reg_idle', 10,
+	'reg_idle', 20,
 	#opposite
 	None)
 
 	#intro, length
 	None, 0,
 	#exits
-	['reg_idle', 'reg_offboard', 'reg_turnLeft', 'reg_turnRight', 'reg_opos', 'reg_nopos', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right', 'reg_stop'],
+	['reg_idle', 'fak_offboard' 'reg_offboard', 'reg_turnLeft', 'reg_turnRight', 'reg_opos', 'reg_nopos', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right', 'reg_stop'],
 	#force exit, frame
 	None, 0,
 	#opposite
 
 fak_offboard = a_class(
 	#player armature action name, start, end frames
-	'fak_noffboard', 1, 30,
+	'fak_noffboard', 1, 24,
+	#'fak_noffboard', 
 	#deck action name, start, end frames  
-	'b_fak_offboard', 1, 30,
+	'b_reg_offboard', 1, 30,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
-	4, .5, 0, 5,
+	2, .5, 0, 0,
 	#intro, length
 	None, 0,
 	#exits
-	['fak_idle', 'fak_walkFast', 'fak_walk', 'fak_onboard'],
+	['reg_idle', 'fak_idle', 'fak_walkFast', 'fak_walk', 'fak_onboard'],
 	#force exit, frame
-	'fak_idle', 28,
+	'reg_idle', 24,
 	#opposite
 	None)
 
 	#intro, length
 	None, 0,
 	#exits
-	['fak_idle', 'fak_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
 	#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

 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
         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/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)
     sound_man.main(cont)
     
     if own['life'] % 2 == 1:
-        cars.Execute(cont)
+        #cars.Execute(cont)
         own['CamFSM'].Execute()
-        walkers.Execute(cont)
+        #walkers.Execute(cont)
     else:
         pass
 

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
 
         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)
                     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 == False and lasty == True) or dict['kb_q'] == 3:
+        # if getoffboard == 1 and own['fall'] == False:
+        #     own['getoffboard'] = 0
+        # if (yBut == False and lasty == True) or dict['kb_q'] == 3:
+        #     own['getoffboard'] = 1
+
+        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"])
             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.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')            
+                #print('doing nothing')            
 
     localHitDist = 1000
     raytof = scene.objects['rayTo_f']
     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')

scripts/game.py

+import bge
+import FSM
+import requests
+import platform
+import os
+
+def phone_home():
+	url = 'https://shuvit.org/phone_home.php'
+	n = platform.uname()
+	n = platform.platform()
+	myobj = {'somekey': n}
+	x = requests.post(url, data = myobj, timeout=3.50)
+	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
+	if 'game_inited' not in own:
+		info = bge.logic.PrintGLInfo()
+		own['game_inited'] = True
+		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()
+	

scripts/grindV2.py

 
         lineVector = secondary - primary
         lineVector2 = primary - secondary
-        lv_green = Vector(found_green[0][0])
+        if found_green != []:
+            lv_green = Vector(found_green[0][0])
             
         eul = Vector((1, 0, 0)).rotation_difference(lineVector).to_euler()        
         
         rotation = te.worldOrientation.to_euler()
         if abs(rotation.z) > 3:
             te.applyRotation([0, 0, 1.570796*2], True)
-        #te.alignAxisToVect(worldY, 1, 1)
-        #print(te.worldOrientation, 'world orientation')
-
-
+        
         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
             te.alignAxisToVect(lineVector, 0, 1)
         
         te.worldPosition = primary
-        
-        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
+
+        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:
-                te.alignAxisToVect(lineVector2, 0, 1)
-            #print('align2', lineVector2)
-            te.worldPosition = secondary
-        else:
-            #print('align1', lineVector)  
-            pass
+                #print('align1', lineVector)  
+                pass
 
 
         #flip z axis
 
         #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/inputs.py

             cube.restoreDynamics()
             print(cube.isSuspendDynamics)
 
-main()
+#main()
 

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/logo_fades.py

 import bge
-import Settings
+#import Settings
 
 def main():
 
     scene = bge.logic.getCurrentScene()
     black = scene.objects['black']
     shuvit_logo = scene.objects['shuvit_logo']
-    levels = ['garage18', 'mini_scene']
     scenes = bge.logic.getSceneList()
-    #print(dict['load_timer'])
     
     if dict['overlay_fadein'] == 1:
-        #dict['overlay_fadein'] = 0
-        #black.playAction('black_fade', 0,60, layer=0, play_mode=0)
-        #print("---add fade")
-        #fade_in
-        
         for i in scenes:
             if i.name == "fade_in":
                 scene2 = i
                 scene2.end()         
         cont.activate(own.actuators['add_fade'])  
         
-        #skater.playAction("reg_noses", 30,40, layer=trans_layer, play_mode=0, speed=.5)
     if dict['overlay_fadeout'] == 1:
         dict['overlay_fadeout'] = 0    
         black.playAction('black_fade', 100,200, layer=2, play_mode=0) 
         shuvit_logo.playAction('logo_fade', 100,200, layer=0, play_mode=0)  
-        #print('fade out black and logo') 
         
     if dict['load_timer'] > 0:
         dict['load_timer'] -= 1
     if dict['load_timer'] == 3:
-        #load   
         scenes = bge.logic.getSceneList()
-        #print('scenes: ', scenes)
 
-                 
-        #Settings.loadlevel()
-        #print('----reloading----')
         dict['load_timer'] == 0
         cont.activate(own.actuators['reload_game'])
-        
-        #cont.activate(own.actuators["loading"])
-        #print('loading', dict['level'])
     
-main()
+#main()

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

+import bge
+import FSM
+from mathutils import Vector
+import math
+import mathutils
+import random
+
+dict = bge.logic.globalDict
+
+class Player:
+	def __init__(self, cont):
+		self.cont = cont
+		self.obj = cont.owner
+		self.FSM = FSM.PlayerFSM(self)
+		self.walking = True
+		self.last_pos = self.obj.worldPosition.copy()
+		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.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)
+		#self.arm = self.obj.childrenRecursive['Char4']
+		self.arm = None
+
+	def update(self):
+		self.FSM.Execute()
+		self.last_pos = self.obj.worldPosition.copy()
+
+	def get_ground_ray(self):
+		v = self.obj.worldOrientation.col[0]
+		tv = v.normalized()
+		axis = 2
+		distance = -50
+		start = self.obj.worldPosition.copy()
+		back_start = start + 0.15 * 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.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, 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])
+		#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):
+
+		v = self.obj.worldOrientation.col[0]
+		tv = v.normalized()
+
+		axis = 2
+		distance = -5
+		start = self.obj.worldPosition.copy()
+		start.z += 1.8
+		mstart = start - 0.40 * tv
+		
+		end = Vector(mstart + (self.obj.worldOrientation.col[axis] * distance))
+		ray = self.obj.rayCast(end, mstart, 0, 'ground', 1, 1, 0, 53247)
+		#ray = self.obj.rayCast(end, mstart, 0, '', 1, 1, 0, 53247)
+		#bge.render.drawLine(mstart, end, [0,0,1])
+
+		return ray
+
+	def get_hang_align_ray(self):
+
+		v = self.obj.worldOrientation.col[0]
+		tv = v.normalized()
+
+		axis = 0
+		distance = -2
+		start = self.obj.worldPosition.copy()
+		start.z += 1
+		#mstart = start - 0.40 * tv
+		#mstart = start * tv
+		mstart = start 
+
+		end = Vector(mstart + (self.obj.worldOrientation.col[axis] * distance))
+		#ray = self.obj.rayCast(end, mstart, 0, 'ground', 1, 0, 0, 53247)
+		ray = self.obj.rayCast(end, mstart, 0, '', 1, 0, 0, 53247)
+		#if ray[0] != None:
+			#print(ray[0], 'player funct')
+		#bge.render.drawLine(mstart, end, [0,1,0])
+		
+		return ray
+
+
+
+	def get_ground_dist(self, groundray):
+		gr = groundray[0]
+		fgr = groundray[1]
+		cgr = groundray[2]
+		d = None
+		
+		if gr[0] != None:
+			p_z = self.obj.worldPosition.z
+			g_z = gr[1].z
+			distance_to_ground = p_z - g_z
+			p2 = None
+			if fgr[0] != None:
+				p2 = p_z - fgr[1].z 
+
+				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
+
+
+
+	def get_hang_dist(self, groundray):
+		if groundray[0] != None:
+			p_z = self.obj.worldPosition.z
+			g_z = groundray[1].z
+			distance_to_ground = p_z - g_z
+			return distance_to_ground
+
+
+	def set_walk_z(self, dist):
+		if dist < .6:
+			target_dist = .3
+			self.obj.worldPosition.z += (target_dist - dist)
+			self.obj.linearVelocity.z = 0
+
+	def align_walk_z(self):
+		self.obj.alignAxisToVect([0,0,1], 2, .08)
+
+	def walk_movement(self):
+		
+		moving = False
+		o = self.obj
+		
+
+		o.linearVelocity.y *= .9
+		o.linearVelocity.x *= .95
+
+		if dict['kb_w'] == 2 or dict['lUD'] < -.05:
+			#walk_blend(self)
+
+			#run
+			if (dict['kb_lsh'] == 2 or dict['aBut'] == 1) and o.linearVelocity.x > -dict['max_run_vel']:
+				#self.run_speed = 1.5
+				#o.applyForce([-dict['run_force'], 0, 0], True)
+				o.linearVelocity.x -= .2
+
+			#walk
+			elif o.linearVelocity.x > -dict['max_walk_vel']:
+				#o.applyForce([-dict['walk_force'], 0, 0], True)
+				o.linearVelocity.x -= .1
+
+
+		if dict['kb_s'] == 2 or dict['lUD'] > .06:
+			#o.applyForce([10, 0, 0], True)
+			if o.linearVelocity.x < (dict['max_walk_vel'] / 2):
+				o.linearVelocity.x += .05
+			#print('w')
+
+		if dict['kb_a'] == 2 or dict['lLR'] < -.03:
+			o.applyRotation([0, 0, dict['walk_turn_amt']], True)
+			#print('w')
+	
+		if dict['kb_d'] == 2 or dict['lLR'] > .03:
+			o.applyRotation([0, 0, -dict['walk_turn_amt']], True)
+
+
+
+		#print('linvel', o.linearVelocity)
+
+		return moving
+
+	def move_walk_cam(self):
+		amt = -.05
+		amt2 = -.07
+		if dict['rLR'] > .04:
+			dict['camera'].applyMovement([amt, 0, 0], True)
+		elif dict['rLR'] < -.04:
+			dict['camera'].applyMovement([-amt, 0, 0], True)	
+
+		if dict['rUD'] > .04:
+			dict['camera'].applyMovement([0, -amt2, 0], True)
+		elif dict['rUD'] < -.04:
+			dict['camera'].applyMovement([0, amt2, 0], True)	
+
+	def check_reset_point(self):
+		if dict['ddPad'] == 1:
+			spawn_pos = self.obj['spawn_pos']
+			spawn_rot = self.obj['spawn_rot']
+			spawn_cam_pos = self.obj['spawn_cam_pos']
+			spawn_cam_rot = self.obj['spawn_cam_rot']
+			try:
+				self.obj.worldPosition = (spawn_pos[0], spawn_pos[1], (spawn_pos[2] + .1))
+				self.obj.worldOrientation = [[spawn_rot[0][0], spawn_rot[0][1],spawn_rot[0][2]], [spawn_rot[1][0],spawn_rot[1][1], spawn_rot[1][2]], [0.0, 0.0, 1.0]]
+				dict['camera'].worldPosition = (spawn_cam_pos[0], spawn_cam_pos[1], (spawn_cam_pos[2]))
+				dict['camera'].worldOrientation = [[spawn_cam_rot[0][0], spawn_cam_rot[0][1], spawn_cam_rot[0][2]], [spawn_cam_rot[1][0], spawn_cam_rot[1][1], spawn_cam_rot[1][2]], [0.0, 0.0, 1.0]]
+			except:
+				self.obj.worldPosition = (0, 0, .1)
+				self.obj.worldOrientation = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]
+
+			if self.obj["spawn_stance"] == 1:
+				self.obj.setLinearVelocity([.1,0,0], 1)
+
+			else:
+				self.obj.setLinearVelocity([-.1,0,0], 1)
+
+		if dict['udPad'] == 1:
+			self.obj['spawn_pos'] = [self.obj.worldPosition[0], self.obj.worldPosition[1], self.obj.worldPosition[2]]
+			self.obj['spawn_rot'] = [[self.obj.worldOrientation[0][0], self.obj.worldOrientation[0][1],self.obj.worldOrientation[0][2]], [self.obj.worldOrientation[1][0], self.obj.worldOrientation[1][1], self.obj.worldOrientation[1][2]], self.obj.worldOrientation[2][2]]
+			self.obj['spawn_cam_pos'] = [dict['camera'].worldPosition[0], dict['camera'].worldPosition[1], dict['camera'].worldPosition[2]]
+			self.obj['spawn_cam_rot'] = [[dict['camera'].worldOrientation[0][0], dict['camera'].worldOrientation[0][1],dict['camera'].worldOrientation[0][2]], [dict['camera'].worldOrientation[1][0], dict['camera'].worldOrientation[1][1], dict['camera'].worldOrientation[1][2]], dict['camera'].worldOrientation[2][2]]
+			stance = self.obj["stance"]
+			self.obj["spawn_stance"] = stance
+
+
+	def hang_move(self):
+		if dict['lLR'] > .04:
+			#self.arm.playAction('c_hanghopleft', 0, 45, layer=3, play_mode=0, speed=.75, blendin=10)
+			self.arm.playAction('c_shimmy_l', 0, 34, layer=3, play_mode=0, speed=.75, blendin=10)
+			self.obj.applyForce([0,235,0], True)
+		if dict['lLR'] < -.04:
+			#self.arm.playAction('c_hanghopright', 0, 45, layer=3, play_mode=0, speed=.75, blendin=10)
+			self.arm.playAction('c_shimmy_r', 0, 34, layer=3, play_mode=0, speed=.75, blendin=10)
+			self.obj.applyForce([0,-235,0], True)
+
+
+	def check_throw(self):
+
+		def throw(strength):
+			print('throwing with strength', strength)
+			if self.throw_deck != None:
+				self.throw_deck.endObject()
+				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.applyForce([0, 150, -200], True)
+			self.hide_deck()
+
+		if self.throw_deck == None:	
+			strength = self.throw_timer
+			
+			if strength > 19:
+				strength = 19
+
+			if dict['bBut'] == 0 and dict['last_bBut'] == 1:
+				self.throw_timer = 0
+				self.arm.playAction('c_throw', 19, 45, layer=7, play_mode=0, speed=.75, blendin=5)
+				self.deck_arm.playAction('b_throw', 19, 45, layer=7, play_mode=0, speed=.75, blendin=5)
+				throw(strength)
+			elif dict['bBut'] == 1:
+				self.arm.playAction('c_throw', 0, 45, layer=7, play_mode=1, speed=.75, blendin=5)
+				self.deck_arm.playAction('b_throw', 0, 45, layer=7, play_mode=1, speed=.75, blendin=5)
+				self.arm.setActionFrame(strength, 7)
+				self.deck_arm.setActionFrame(strength, 7)
+				self.throw_timer += 1
+			else:
+				self.throw_timer = 0
+		else:
+			if dict['bBut'] == 0 and dict['last_bBut'] == 1:
+				self.show_deck()
+				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:
+	def hide_deck(self):
+		for x in self.deck_arm.childrenRecursive:
+			x.visible = False
+			
+	def show_deck(self):
+		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 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----------------')
+	dict = bge.logic.globalDict
+	#own = cont.owner
+
+	if 'player_class' not in dict:
+		#dict['playerFSM'] = FSM.PlayerFSM(own)
+		dict['player_class'] = Player(cont)
+
+	#dict['playerFSM'].Execute()
+	dict['player_class'].update()

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:
         
     #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'].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')
 
 
             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
+                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']
                 #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/scene_init.py

         
         cam = scene.objects['Camera.003']
         curscene = bge.logic.getCurrentScene()
+        dict['level_scene'] = curscene
 
         dict['overlay_fadeout'] = 1
         scenes = bge.logic.getSceneList()
             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
+        #scene.world.envLightEnergy = 0
         
         cam['BC_BRIGHTNESS'] = dict['BC_BRIGHTNESS'] 
         cam['BC_CONTRAST'] = dict['BC_CONTRAST']
         own['last_roty'] = 0.0
         
         own['walk_targ_speed'] = 2
-        own['walk_fast_targ_speed'] = 8
+        own['walk_fast_targ_speed'] = 5
         own['walk_speed'] = 0
         own['walk_inc'] = .2
         own['walk_jump_timer'] = 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
 
 	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
 			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()	

scripts/walk.py

 import math
 
 def main(cont):
-    
-    scene = bge.logic.getCurrentScene()
-    objList = scene.objects
-    cont = GameLogic.getCurrentController() 
-    obj = bge.logic.getCurrentScene().objects
-    char = bge.constraints.getCharacter
-    own = cont.owner
-    stance = own['stance']
-    STANCE = own['stance']
-    r_ground = cont.sensors["r_Ground"]
-    linvel = own.getLinearVelocity(True)
-    lasta = own['lasta']
-    lastx = own['lastx']
-    last_sit = own['sit']
-    dict = bge.logic.globalDict
+    pass    
+
+#---------------------------------------------------
+
+
+
+    # scene = bge.logic.getCurrentScene()
+    # objList = scene.objects
+    # cont = GameLogic.getCurrentController() 
+    # obj = bge.logic.getCurrentScene().objects
+    # char = bge.constraints.getCharacter
+    # own = cont.owner
+    # stance = own['stance']
+    # STANCE = own['stance']
+    # r_ground = cont.sensors["r_Ground"]
+    # linvel = own.getLinearVelocity(True)
+    # lasta = own['lasta']
+    # lastx = own['lastx']
+    # last_sit = own['sit']
+    # dict = bge.logic.globalDict
 
-    try:
-        own['walk_timer'] = own['walk_timer'] +1
-    except:
-        own['walk_timer'] = 1
-        own['walk_targ_speed'] = 2.0
+    # try:
+    #     own['walk_timer'] = own['walk_timer'] +1
+    # except:
+    #     own['walk_timer'] = 1
+    #     own['walk_targ_speed'] = 2.0
 
-    truckon = 450
-    deckon = 460
+    # truckon = 450
+    # deckon = 460
 
-    lLR = dict['lLR']
-    lUD = dict['lUD']
-    rLR = dict['rLR']
-    rUD = dict['rUD']
-    lTrig = dict['lTrig']
-    rTrig = dict['rTrig']
-    aBut = dict['aBut']
-    bBut = dict['bBut']
-    xBut = dict['xBut']
-    yBut = dict['yBut']
-    lBump = dict['lBump']
-    rBump = dict['rBump']
-    bkBut = dict['bkBut']
-    stBut = dict['stBut']
-    xbBut = dict['xbBut']
-    ltsBut = dict['ltsBut']
-    rtsBut = dict['rtsBut']
-    ldPad = dict['ldPad']
-    rdPad = dict['rdPad']
-    udPad = dict['udPad']
-    ddPad = dict['ddPad']
+    # lLR = dict['lLR']
+    # lUD = dict['lUD']
+    # rLR = dict['rLR']
+    # rUD = dict['rUD']
+    # lTrig = dict['lTrig']
+    # rTrig = dict['rTrig']
+    # aBut = dict['aBut']
+    # bBut = dict['bBut']
+    # xBut = dict['xBut']
+    # yBut = dict['yBut']
+    # lBump = dict['lBump']
+    # rBump = dict['rBump']
+    # bkBut = dict['bkBut']
+    # stBut = dict['stBut']
+    # xbBut = dict['xbBut']
+    # ltsBut = dict['ltsBut']
+    # rtsBut = dict['rtsBut']
+    # ldPad = dict['ldPad']
+    # rdPad = dict['rdPad']
+    # udPad = dict['udPad']
+    # ddPad = dict['ddPad']
 
-    #user
-    sens = .04
-    fliplay = 30
-    dropinCol = own.sensors['dropinCol']
-    cube = scene.objects['control_cube.002']
-    skater = scene.objects["Char4"]
-    deck = scene.objects["b_deck"]
-    trucks = scene.objects["b_trucks"]
-    camobj2 = scene.objects['camobj']
-    throw_deck_empty = scene.objects["throw_deck_empty"]
-    wheel1 = scene.objects["wheel1"]
-    wheel2 = scene.objects["wheel2"]
-    wheel3 = scene.objects["wheel3"]
-    wheel4 = scene.objects["wheel4"]
-    camobj = scene.objects["Camera.003"]
-    camera = cont.actuators["Camera"]
-    replayCam = cont.actuators["replayCam"]
-    timer = own['dropinTimer']
-    cam = scene.objects["Camera.003"]
-    freecam = scene.objects["freecam"]
-    followcam = scene.objects["followcam"]
+    # #user
+    # sens = .04
+    # fliplay = 30
+    # dropinCol = own.sensors['dropinCol']
+    # cube = scene.objects['control_cube.002']
+    # skater = scene.objects["Char4"]
+    # deck = scene.objects["b_deck"]
+    # trucks = scene.objects["b_trucks"]
+    # camobj2 = scene.objects['camobj']
+    # throw_deck_empty = scene.objects["throw_deck_empty"]
+    # wheel1 = scene.objects["wheel1"]
+    # wheel2 = scene.objects["wheel2"]
+    # wheel3 = scene.objects["wheel3"]
+    # wheel4 = scene.objects["wheel4"]
+    # camobj = scene.objects["Camera.003"]
+    # camera = cont.actuators["Camera"]
+    # replayCam = cont.actuators["replayCam"]
+    # timer = own['dropinTimer']
+    # cam = scene.objects["Camera.003"]
+    # freecam = scene.objects["freecam"]
+    # followcam = scene.objects["followcam"]
 
-    control_bottom = scene.objects['control_bottom']
-    cb = control_bottom.sensors['grindCol_bottom']
-    cb_td = control_bottom.sensors['td_bottom']
+    # control_bottom = scene.objects['control_bottom']
+    # cb = control_bottom.sensors['grindCol_bottom']
+    # cb_td = control_bottom.sensors['td_bottom']
 
-    noidle = 0
+    # noidle = 0
 
-    #if skater.isPlayingAction(460):  
-    #    noidle = 1  
+    # #if skater.isPlayingAction(460):  
+    # #    noidle = 1  
 
 
-    try:
-        walk_inc = own['walk_inc'] 
-    except:
-        own['walk_inc'] = .01
-        walk_inc = own['walk_inc']  
-        own['walk_jump_timer'] = 0   
-    if own['stair_counter'] != 0:
-        walk_inc = own['walk_inc']  *10
+    # try:
+    #     walk_inc = own['walk_inc'] 
+    # except:
+    #     own['walk_inc'] = .01
+    #     walk_inc = own['walk_inc']  
+    #     own['walk_jump_timer'] = 0   
+    # if own['stair_counter'] != 0:
+    #     walk_inc = own['walk_inc']  *10
 
-    if own["stance"] == None:
-        own["stance"] = True
-    STANCE = own["stance"]
-    def killact(layer):
-        if skater.isPlayingAction(layer):
-            skater.stopAction(layer)
-        if deck.isPlayingAction(layer):    
-            deck.stopAction(layer)
-        if trucks.isPlayingAction(layer):    
-            trucks.stopAction(layer)
-    def killall():
-        for x in range(5000):
-            skater.stopAction(x)
-            deck.stopAction(x)
-            trucks.stopAction(x)
-    def trucksisplaying():
-        for x in range(5000):
-            if deck.isPlayingAction(x):
-                print("deck is playing:", x)
+    # if own["stance"] == None:
+    #     own["stance"] = True
+    # STANCE = own["stance"]
+    # def killact(layer):
+    #     if skater.isPlayingAction(layer):
+    #         skater.stopAction(layer)
+    #     if deck.isPlayingAction(layer):    
+    #         deck.stopAction(layer)
+    #     if trucks.isPlayingAction(layer):    
+    #         trucks.stopAction(layer)
+    # def killall():
+    #     for x in range(5000):
+    #         skater.stopAction(x)
+    #         deck.stopAction(x)
+    #         trucks.stopAction(x)
+    # def trucksisplaying():
+    #     for x in range(5000):
+    #         if deck.isPlayingAction(x):
+    #             print("deck is playing:", x)
 
-    def printplaying():
-        splaying_layers = "S: "
-        playing_layers = "D: "
-        tplaying_layers = "T: "
-        for x in range(9900):
-            if skater.isPlayingAction(x):
-            #if trucks.isPlayingAction(x):
-            #if skater.isPlayingAction(x):                        
-                splaying_layers += str(x)
-                splaying_layers += " "        
-            if deck.isPlayingAction(x):
-            #if trucks.isPlayingAction(x):
-            #if skater.isPlayingAction(x):                        
-                playing_layers += str(x)
-                playing_layers += " "
-            if trucks.isPlayingAction(x):
-            #if trucks.isPlayingAction(x):
-            #if skater.isPlayingAction(x):                        
-                tplaying_layers += str(x)
-                tplaying_layers += " "            
-        print(splaying_layers, playing_layers, tplaying_layers) 
-    #printplaying() 
-    ##
-    if r_ground.positive and xBut == False and lastx == False:
-        killact(10)
-        #killact(11)
-        killact(12)
-        killact(13)              
-    ######################################    
+    # def printplaying():
+    #     splaying_layers = "S: "
+    #     playing_layers = "D: "
+    #     tplaying_layers = "T: "
+    #     for x in range(9900):
+    #         if skater.isPlayingAction(x):
+    #         #if trucks.isPlayingAction(x):
+    #         #if skater.isPlayingAction(x):                        
+    #             splaying_layers += str(x)
+    #             splaying_layers += " "        
+    #         if deck.isPlayingAction(x):
+    #         #if trucks.isPlayingAction(x):
+    #         #if skater.isPlayingAction(x):                        
+    #             playing_layers += str(x)
+    #             playing_layers += " "
+    #         if trucks.isPlayingAction(x):
+    #         #if trucks.isPlayingAction(x):
+    #         #if skater.isPlayingAction(x):                        
+    #             tplaying_layers += str(x)
+    #             tplaying_layers += " "            
+    #     print(splaying_layers, playing_layers, tplaying_layers) 
+    # #printplaying() 
+    # ##
+    # if r_ground.positive and xBut == False and lastx == False:
+    #     killact(10)
+    #     #killact(11)
+    #     killact(12)
+    #     killact(13)              
+    # ######################################    
 
-    #idle      
-    if stance == 0 and skater.isPlayingAction(fliplay) == False and yBut == False and r_ground.triggered and xBut == False and noidle == 0 and own['walk_idling'] == 0 and own['sit'] == 0 and own['dropinTimer'] == 0 and own['lasty']  == False:
-        own['requestAction'] = 'reg_idle'
-        if own['throw_deck'] == True:
-            own['requestAction'] = 'reg_idle_nb'
+    # #idle      
+    # #if stance == 0 and skater.isPlayingAction(fliplay) == False and yBut == False and r_ground.triggered and xBut == False and noidle == 0 and own['walk_idling'] == 0 and own['sit'] == 0 and own['dropinTimer'] == 0 and own['lasty']  == False:
+    #     #own['requestAction'] = 'reg_idle'
+    #     #if own['throw_deck'] == True:
+    #         #own['requestAction'] = 'reg_idle_nb'
 
-    if stance == 1 and skater.isPlayingAction(fliplay) == False and yBut == False and r_ground.triggered and xBut == False and noidle == 0 and own['walk_idling'] == 0 and own['sit'] == 0 and own['dropinTimer'] == 0 and own['lasty']  == False:
-        own['requestAction'] = 'fak_idle'
-        if own['throw_deck'] == True:
-            own['requestAction'] = 'fak_idle_nb'
+    # #if stance == 1 and skater.isPlayingAction(fliplay) == False and yBut == False and r_ground.triggered and xBut == False and noidle == 0 and own['walk_idling'] == 0 and own['sit'] == 0 and own['dropinTimer'] == 0 and own['lasty']  == False:
+    #     #own['requestAction'] = 'fak_idle'
+    #     #if own['throw_deck'] == True:
+    #         #own['requestAction'] = 'fak_idle_nb'
 
-    if lUD < -sens:
-        lup = 1
-    else:
-        lup = 0
-    if lUD > sens:
-        ldown = 1
-    else:
-        ldown = 0 
-    if lLR < -sens:
-        lLeft = 1
-    else:
-        lLeft = 0
-    if lLR > sens:
-        lRight = 1
-    else:
-        lRight = 0        
+    # if lUD < -sens:
+    #     lup = 1
+    # else:
+    #     lup = 0
+    # if lUD > sens:
+    #     ldown = 1
+    # else:
+    #     ldown = 0 
+    # if lLR < -sens:
+    #     lLeft = 1
+    # else:
+    #     lLeft = 0
+    # if lLR > sens:
+    #     lRight = 1
+    # else:
+    #     lRight = 0        
 
 
 
-    #turning
-    walk_turn_amt = .005#.05
-    turning = False
-    if r_ground.positive:
-        num = .4#.5
-        tilt = .015
-        if STANCE == 1:
-            num *= -1
-            tilt *= -1
-        if lRight == 1 or dict['kb_ra'] == 2:
-            #cont.activate(own.actuators['right'])
-            own.linearVelocity.y = num
-            if own['stair_counter'] > 0:
-                if STANCE == 0:
-                    own.applyRotation([0,0,walk_turn_amt], True)
-                else:
-                    own.applyRotation([0,0,-walk_turn_amt], True)                
-            else:
-                own.applyRotation([-tilt, 0, 0], True)
-            turning = True
-        else:
-            #cont.deactivate(own.actuators['right']) 
-            pass  
+    # #turning
+    # walk_turn_amt = .005#.05
+    # turning = False
+    # if r_ground.positive:
+    #     num = .4#.5
+    #     tilt = .015
+    #     if STANCE == 1:
+    #         num *= -1
+    #         tilt *= -1
+    #     if lRight == 1 or dict['kb_ra'] == 2:
+    #         #cont.activate(own.actuators['right'])
+    #         own.linearVelocity.y = num
+    #         if own['stair_counter'] > 0:
+    #             if STANCE == 0:
+    #                 own.applyRotation([0,0,walk_turn_amt], True)
+    #             else:
+    #                 own.applyRotation([0,0,-walk_turn_amt], True)                
+    #         else:
+    #             own.applyRotation([-tilt, 0, 0], True)
+    #         turning = True
+    #     else:
+    #         #cont.deactivate(own.actuators['right']) 
+    #         pass  
             
-        if lLeft == 1 or dict['kb_la'] == 2:
-            #cont.activate(own.actuators['left']) 
-            own.linearVelocity.y = -num
-            if own['stair_counter'] > 0:
-                if STANCE == 0:
-                    own.applyRotation([0,0,walk_turn_amt], True)
-                else:
-                    own.applyRotation([0,0,-walk_turn_amt], True)                                
-            else:        
-                own.applyRotation([tilt, 0, 0], True)        
-            turning = True
-        else:
-            #cont.deactivate(own.actuators['left'])        
-            pass
+    #     if lLeft == 1 or dict['kb_la'] == 2:
+    #         #cont.activate(own.actuators['left']) 
+    #         own.linearVelocity.y = -num
+    #         if own['stair_counter'] > 0:
+    #             if STANCE == 0:
+    #                 own.applyRotation([0,0,walk_turn_amt], True)
+    #             else:
+    #                 own.applyRotation([0,0,-walk_turn_amt], True)                                
+    #         else:        
+    #             own.applyRotation([tilt, 0, 0], True)        
+    #         turning = True
+    #     else:
+    #         #cont.deactivate(own.actuators['left'])        
+    #         pass
 
-    #in air        
-    #if (lup == 1 or dict['kb_ua'] != 0) and r_ground.positive == False:
-    if r_ground.positive == False:
-        airrot = .05
-        if lLeft == 1 or dict['kb_la'] == 2:
-            if stance == 0:
-                own.applyRotation([0,0,airrot], True)
-            if stance == 1:    
-                own.applyRotation([0,0,airrot], True)
-        if lRight == 1 or dict['kb_ra'] == 2:
-            if stance == 0:
-                own.applyRotation([0,0,-airrot], True)
-            if stance == 1:    
-                own.applyRotation([0,0,-airrot], True)  
+    # #in air        
+    # #if (lup == 1 or dict['kb_ua'] != 0) and r_ground.positive == False:
+    # if r_ground.positive == False:
+    #     airrot = .05
+    #     if lLeft == 1 or dict['kb_la'] == 2:
+    #         if stance == 0:
+    #             own.applyRotation([0,0,airrot], True)
+    #         if stance == 1:    
+    #             own.applyRotation([0,0,airrot], True)
+    #     if lRight == 1 or dict['kb_ra'] == 2:
+    #         if stance == 0:
+    #             own.applyRotation([0,0,-airrot], True)
+    #         if stance == 1:    
+    #             own.applyRotation([0,0,-airrot], True)  
                 
-        if lup == 1 or dict['kb_ua'] == 2:
-            if own.linearVelocity.x < 10 and own .linearVelocity.x > - 10:
-                if stance == 0:
-                    own.linearVelocity.x -= .04
-                if stance == 1:
-                    own.linearVelocity.x += .04                             
-        own['lF_air_frame'] = own['framenum']  
-        own.actuators["walkondirt"].stopSound()
+    #     if lup == 1 or dict['kb_ua'] == 2:
+    #         if own.linearVelocity.x < 10 and own .linearVelocity.x > - 10:
+    #             if stance == 0:
+    #                 own.linearVelocity.x -= .04
+    #             if stance == 1:
+    #                 own.linearVelocity.x += .04                             
+    #     own['lF_air_frame'] = own['framenum']  
+    #     own.actuators["walkondirt"].stopSound()
 
         
-    #walking
+    # #walking
 
-    #new walking
-    vel = own.getLinearVelocity(True)
-    if own['walk_timer'] < 50:
-        velx = vel.x * .95             
-        own.setLinearVelocity([velx, 0, vel.z], True)
-        #print('y is zero')
-    else:
-        pass
-        #own.setLinearVelocity([0, 0, vel.z], True)
+    # #new walking
+    # vel = own.getLinearVelocity(True)
+    # if own['walk_timer'] < 50:
+    #     velx = vel.x * .95             
+    #     own.setLinearVelocity([velx, 0, vel.z], True)
+    #     #print('y is zero')
+    # else:
+    #     pass
+    #     #own.setLinearVelocity([0, 0, vel.z], True)
         
-    wf = 1
-    if own['last_walk_frame'] - own['last_roll_frame'] > 55:
-        wf = 0   
+    # wf = 1
+    # if own['last_walk_frame'] - own['last_roll_frame'] > 55:
+    #     wf = 0   
        
-    if ((lup == 1 and aBut == 0) or (dict['kb_ua'] == 2 and dict['kb_lsh'] == 0)) and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0 and wf == 0 and dict['kb_space'] == 0:
-        own['walking'] = "regular"
-        walking = "regular"
+    # if ((lup == 1 and aBut == 0) or (dict['kb_ua'] == 2 and dict['kb_lsh'] == 0)) and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0 and wf == 0 and dict['kb_space'] == 0:
+    #     own['walking'] = "regular"
+    #     walking = "regular"
         
-    elif ((lup == 1 and aBut == 1) or (dict['kb_lsh'] == 2 and dict['kb_ua'] == 2)) and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0 and wf == 0 and dict['kb_space'] != 2:
-        own['walking'] = "fast"
-        walking = "fast"
-    else:
-        own['walking'] = None
-        walking = None
+    # elif ((lup == 1 and aBut == 1) or (dict['kb_lsh'] == 2 and dict['kb_ua'] == 2)) and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0 and wf == 0 and dict['kb_space'] != 2:
+    #     own['walking'] = "fast"
+    #     walking = "fast"
+    # else:
+    #     own['walking'] = None
+    #     walking = None
        
-    if walking == "regular":  
-        if stance == 1:
-            if linvel.x < own['walk_targ_speed']:
-                own.linearVelocity.x = linvel.x + walk_inc
-            else:
-                own.linearVelocity.x = own['walk_targ_speed']    
-        else:
-            if linvel.x > -own['walk_targ_speed']:
-                own.linearVelocity.x = linvel.x - walk_inc       
-            else:
-                own.linearVelocity.x = -own['walk_targ_speed']                
-    if walking == "fast":   
-        if stance == 1:
-            if linvel.x < own['walk_fast_targ_speed']:
-                own.linearVelocity.x = linvel.x + walk_inc
-            else:
-                own.linearVelocity.x = own['walk_fast_targ_speed']  
-        else:
-            if linvel.x > -own['walk_fast_targ_speed']:
-                own.linearVelocity.x = linvel.x - walk_inc      
-            else:
-                own.linearVelocity.x = -own['walk_fast_targ_speed'] 
+    # if walking == "regular":  
+    #     if stance == 1:
+    #         if linvel.x < own['walk_targ_speed']:
+    #             own.linearVelocity.x = linvel.x + walk_inc
+    #         else:
+    #             own.linearVelocity.x = own['walk_targ_speed']    
+    #     else:
+    #         if linvel.x > -own['walk_targ_speed']:
+    #             own.linearVelocity.x = linvel.x - walk_inc       
+    #         else:
+    #             own.linearVelocity.x = -own['walk_targ_speed']                
+    # if walking == "fast":   
+    #     if stance == 1:
+    #         if linvel.x < own['walk_fast_targ_speed']:
+    #             own.linearVelocity.x = linvel.x + walk_inc
+    #         else:
+    #             own.linearVelocity.x = own['walk_fast_targ_speed']  
+    #     else:
+    #         if linvel.x > -own['walk_fast_targ_speed']:
+    #             own.linearVelocity.x = linvel.x - walk_inc      
+    #         else:
+    #             own.linearVelocity.x = -own['walk_fast_targ_speed'] 
 
-    if walking == None and r_ground.positive and own['walk_jump_timer'] == 0:      
-        if own['walk_timer'] < 50 and turning == False:
-            velx = vel.x * .95             
-            own.setLinearVelocity([velx, 0, vel.z], True)
-        elif own['walk_timer'] > 50:
-            if own.linearVelocity.x > .1 or own.linearVelocity.x < -.1:
-                own.linearVelocity.x *= .01
-            else:
-                own.linearVelocity.x = 0
-            if turning == False:    
-                if own.linearVelocity.y > .01 or own.linearVelocity.y < -.01:
-                    own.linearVelocity.y *= .01
-                else:
-                    own.linearVelocity.y = 0                
-            #own.setLinearVelocity([0, 0, vel.z], True) 
+    # if walking == None and r_ground.positive and own['walk_jump_timer'] == 0:      
+    #     if own['walk_timer'] < 50 and turning == False:
+    #         velx = vel.x * .95             
+    #         own.setLinearVelocity([velx, 0, vel.z], True)
+    #     elif own['walk_timer'] > 50:
+    #         if own.linearVelocity.x > .1 or own.linearVelocity.x < -.1:
+    #             own.linearVelocity.x *= .01
+    #         else:
+    #             own.linearVelocity.x = 0
+    #         if turning == False:    
+    #             if own.linearVelocity.y > .01 or own.linearVelocity.y < -.01:
+    #                 own.linearVelocity.y *= .01
+    #             else:
+    #                 own.linearVelocity.y = 0                
+    #         #own.setLinearVelocity([0, 0, vel.z], True) 
         
-    #old walking
-    if ((lup == 1 and aBut == 0) or (dict['kb_ua'] == 2 and dict['kb_lsh'] == 0)  and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0) or (turning == True and aBut == 0):
-        own.actuators["walkondirt"].volume = .2
-        own.actuators["walkondirt"].pitch = 1
-        cont.activate(own.actuators["walkondirt"])          
-        if stance == 0 and skater.isPlayingAction(fliplay) == False:             
-            #without deck
-            if own['throw_deck'] == True:
-                own['requestAction'] = 'reg_walk_nb'
-            else:
-                own['requestAction'] = 'reg_walk'
+    # #old walking
+    # if ((lup == 1 and aBut == 0) or (dict['kb_ua'] == 2 and dict['kb_lsh'] == 0)  and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0) or (turning == True and aBut == 0):
+    #     own.actuators["walkondirt"].volume = .2
+    #     own.actuators["walkondirt"].pitch = 1
+    #     cont.activate(own.actuators["walkondirt"])          
+    #     if stance == 0 and skater.isPlayingAction(fliplay) == False:             
+    #         #without deck
+    #         if own['throw_deck'] == True:
+    #             own['requestAction'] = 'reg_walk_nb'
+    #         else:
+    #             own['requestAction'] = 'reg_walk'
                    
-        if stance == 1 and skater.isPlayingAction(fliplay) == False:        
-            #without deck
-            if own['throw_deck'] == True:
-                own['requestAction'] = 'fak_walk_nb'
-            else:
-                own['requestAction'] = 'fak_walk'
+    #     if stance == 1 and skater.isPlayingAction(fliplay) == False:        
+    #         #without deck
+    #         if own['throw_deck'] == True:
+    #             own['requestAction'] = 'fak_walk_nb'
+    #         else:
+    #             own['requestAction'] = 'fak_walk'
            
-    elif (((lup == 1 and aBut == 1) or (dict['kb_lsh'] == 2 and dict['kb_ua'] == 2)) and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0) or (turning == True and aBut == 1):
-        own.actuators["walkondirt"].volume = .2
-        #own.actuators["walkondirt"].pitch = 1.3
-        own.actuators["walkondirt"].pitch = 2
-        cont.activate(own.actuators["walkondirt"])
-        #print('fastwalk')
-        if stance == 0 and skater.isPlayingAction(fliplay) == False:        
-            if own['throw_deck'] == True:
-                own['requestAction'] = 'reg_walkFast_nb'
-            else:
-                own['requestAction'] = 'reg_walkFast'
+    # elif (((lup == 1 and aBut == 1) or (dict['kb_lsh'] == 2 and dict['kb_ua'] == 2)) and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0) or (turning == True and aBut == 1):
+    #     own.actuators["walkondirt"].volume = .2
+    #     #own.actuators["walkondirt"].pitch = 1.3
+    #     own.actuators["walkondirt"].pitch = 2
+    #     cont.activate(own.actuators["walkondirt"])
+    #     #print('fastwalk')
+    #     if stance == 0 and skater.isPlayingAction(fliplay) == False:        
+    #         if own['throw_deck'] == True:
+    #             own['requestAction'] = 'reg_walkFast_nb'
+    #         else:
+    #             own['requestAction'] = 'reg_walkFast'
              
-        if stance == 1 and skater.isPlayingAction(fliplay) == False:        
-            if own['throw_deck'] == True:
-                own['requestAction'] = 'fak_walkFast_nb'          
-            else:
-                own['requestAction'] = 'fak_walkFast'             
-    else:
-        vel = own.getLinearVelocity(True)
-        cont.deactivate(own.actuators["walkondirt"])       
+    #     if stance == 1 and skater.isPlayingAction(fliplay) == False:        
+    #         if own['throw_deck'] == True:
+    #             own['requestAction'] = 'fak_walkFast_nb'          
+    #         else:
+    #             own['requestAction'] = 'fak_walkFast'             
+    # else:
+    #     vel = own.getLinearVelocity(True)
+    #     cont.deactivate(own.actuators["walkondirt"])       
 
            
-    #---------------
-    if rLR > .05:
-        cont.activate(camobj.actuators['camRight'])
-    else:
-        cont.deactivate(camobj.actuators['camRight'])    
-    if rLR < -.05:
-        cont.activate(camobj.actuators['camLeft'])
-    else:
-        cont.deactivate(camobj.actuators['camLeft'])     
-    if rUD > .05:
-        cont.activate(camobj.actuators['camDown'])
-    else:
-        cont.deactivate(camobj.actuators['camDown'])     
-    if rUD < -.05:
-        cont.activate(camobj.actuators['camUp'])
-    else:
-        cont.deactivate(camobj.actuators['camUp'])     
+    # #---------------
+    # if rLR > .05:
+    #     cont.activate(camobj.actuators['camRight'])
+    # else:
+    #     cont.deactivate(camobj.actuators['camRight'])    
+    # if rLR < -.05:
+    #     cont.activate(camobj.actuators['camLeft'])
+    # else:
+    #     cont.deactivate(camobj.actuators['camLeft'])     
+    # if rUD > .05:
+    #     cont.activate(camobj.actuators['camDown'])
+    # else:
+    #     cont.deactivate(camobj.actuators['camDown'])     
+    # if rUD < -.05:
+    #     cont.activate(camobj.actuators['camUp'])
+    # else:
+    #     cont.deactivate(camobj.actuators['camUp'])     
                     
-    #----------------
-    #camera.height = .01 #.9
-    #camera.min = 1.75
-    #camera.max = 2.25
-    lasty = own['lasty']     
+    # #----------------
+    # #camera.height = .01 #.9
+    # #camera.min = 1.75
+    # #camera.max = 2.25
+    # lasty = own['lasty']     
 
-    def onboard():
-        if own['walk'] == 0:
-            print("start walking")
-            own['walk_idling'] = 0
-            if own['framenum'] > 100 and own['fall'] == False:
-                #cont.activate(own.actuators['pop'])
-                camobj['sndmgr'].queue_sound(['pop', cube, camobj])
-            own['getoffboard'] = False
-            own["walk_idle_frame"] = own["framenum"]
-            own['grindcement_vol'] = 0
-            own['grindcement_pitch'] = 0
-            own['grindrail_vol'] = 0
-            own['grindrail_pitch'] = 0 
-            own['sroll_vol'] = 0
-            own['sroll_pitch'] = 0 
+    # def onboard():
+    #     if own['walk'] == 0:
+    #         print("start walking")
+    #         own['walk_idling'] = 0
+    #         if own['framenum'] > 100 and own['fall'] == False:
+    #             #cont.activate(own.actuators['pop'])
+    #             camobj['sndmgr'].queue_sound(['pop', cube, camobj])
+    #         own['getoffboard'] = False
+    #         own["walk_idle_frame"] = own["framenum"]
+    #         own['grindcement_vol'] = 0
+    #         own['grindcement_pitch'] = 0
+    #         own['grindrail_vol'] = 0
+    #         own['grindrail_pitch'] = 0 
+    #         own['sroll_vol'] = 0
+    #         own['sroll_pitch'] = 0 
 
             
-            #camobj.worldPosition.z += 4              
-            try:
-                vel = own['offboard_vel']
-                vel = [velx, vel.y, vel.z]           
-            except: 
-                pass
+    #         #camobj.worldPosition.z += 4              
+    #         try:
+    #             vel = own['offboard_vel']
+    #             vel = [velx, vel.y, vel.z]           
+    #         except: 
+    #             pass
              
-            if STANCE == 0:
-                own['requestAction'] = 'reg_offboard'             
-                print('requesting off board')
+    #         if STANCE == 0:
+    #             #own['requestAction'] = 'reg_offboard'             
+    #             print('requesting off board')
                 
-            if STANCE == 1:
-                own['requestAction'] = 'fak_offboard'                          
-    def jump():
-        #limit fall speed
-        if linvel.z < -10:
-            own.linearVelocity.z = -10
-        if xBut == True or dict['kb_space'] == 1: 
-            if own['lastx'] == 0:
-                #killact(3)
-                #killact(4)
-                #killact(5)
-                #killact(6)
-                #killact(7)      
-                if STANCE == 0:  
-                    own['requestAction'] ='reg_jump'  
-                    #print('jump') 
-                if STANCE == 1:
-                    own['requestAction'] ='fak_jump'             
-                    #print('jump')
-                JUMPHEIGHT = 1100
-                force = [ 0.0, 0.0, JUMPHEIGHT]
-                # use local axis
-                local = False
-                # apply force -- limit jump speed
-                if linvel.z < 10:
-                    #own.applyForce(force, local)
-                    own.linearVelocity.z += 5
-                    own.linearVelocity.x = linvel.x
-                    own.linearVelocity.y = linvel.y
-                    own['walk_jump_timer'] = 6
-            own['lastx'] = 1
-        else:
-            own['lastx'] = 0  
+    #         #if STANCE == 1:
+    #             #own['requestAction'] = 'fak_offboard'                          
+    # def jump():
+    #     pass
+    #     # #limit fall speed
+    #     # if linvel.z < -10:
+    #     #     own.linearVelocity.z = -10
+    #     # if xBut == True or dict['kb_space'] == 1: 
+    #     #     if own['lastx'] == 0:
+    #     #         #killact(3)
+    #     #         #killact(4)
+    #     #         #killact(5)
+    #     #         #killact(6)
+    #     #         #killact(7)      
+    #     #         if STANCE == 0:  
+    #     #             own['requestAction'] ='reg_jump'  
+    #     #             #print('jump') 
+    #     #         if STANCE == 1:
+    #     #             own['requestAction'] ='fak_jump'             
+    #     #             #print('jump')
+    #     #         JUMPHEIGHT = 1100
+    #     #         force = [ 0.0, 0.0, JUMPHEIGHT]
+    #     #         # use local axis
+    #     #         local = False
+    #     #         # apply force -- limit jump speed
+    #     #         if linvel.z < 10:
+    #     #             #own.applyForce(force, local)
+    #     #             own.linearVelocity.z += 5
+    #     #             own.linearVelocity.x = linvel.x
+    #     #             own.linearVelocity.y = linvel.y
+    #     #             own['walk_jump_timer'] = 6
+    #     #     own['lastx'] = 1
+    #     # else:
+    #     #     own['lastx'] = 0  
             
-    def getonboard(dict, cont):
-        grindDar = cont.sensors['grindDar2']
-        getonboard = own['getonboard']
-        fliplay2 = 50#8560
-        if ((yBut == True and dict['last_yBut'] == False) or dict['kb_q'] == 2):# and (cont.sensors["vehicleNear"].positive == False and own['throw_deck'] == False):
-            fliplay3 = fliplay2 + 1
-            dar = 0 
-            if grindDar.hitObjectList != None:
-                for x in grindDar.hitObjectList:
-                    to_grinder = (x.worldPosition - own.worldPosition).length
-                    #if 'coping' in x and to_grinder < .36:
-                    if 'coping' in x:    
-                        dar = 1
-            if dropinCol.positive == True or dar == 1: 
-                nearestObject = None
-                grindEmpty = scene.objects['grindEmpty']
-                grindDar = grindEmpty.sensors['grindDar2']
-                minDist = None             
-                if grindDar.positive:
-                    detectedObjects = grindDar.hitObjectList
-                    dist = 0
-                    for obj in detectedObjects:
-                        dist = own.getDistanceTo(obj)
-                        if (minDist is None or dist < minDist):
-                            nearestObject = obj
-                            minDist = dist
-                # if nearestObject != None:
-                #     #print(nearestObject)
-                #     obj = nearestObject
-                #     player_e = own.worldOrientation.to_euler()
-                #     player_pos = own.worldPosition
-                #     player_rotz = math.degrees(player_e[2])                
-                #     grinder_e = obj.worldOrientation.to_euler()
-                #     grinder_rotz = math.degrees(grinder_e[2])            
-                #     rot = player_rotz - grinder_rotz  
-                #     grinder_pos = obj.worldPosition 
-                #     worldVect = [1, 0, 0]
-                #     vect = obj.getAxisVect(worldVect)      
-                #     go = obj.worldOrientation
-                #     grinder_axis = [1,0,0] 
-                #     try: 
-                #         delta = player_pos - grinder_pos
-                        
-                #         delta = delta.cross(vect)
-                #         if delta[2] >= 0:
-                #             grindside = "right"
-                #         else:
-                #             grindside = "left"                    
-                #         deltamove = delta[2] * .1#.25
-                #         if STANCE == 0:
-                #             move = [-deltamove, 0, 0]
-                #         else:
-                #             move = [deltamove, 0, 0]                            
-                #         own.applyMovement(move, True)                    
-                #     except:
-                #         pass 
-                print('dropin')
-                if STANCE == 0: 
-                    own['requestAction'] ='reg_dropin' 
-                    own['dropinTimer'] = 60                                     
+    # def getonboard(dict, cont):
+    #     grindDar = cont.sensors['grindDar2']
+    #     getonboard = own['getonboard']
+    #     fliplay2 = 50#8560
+    #     if ((yBut == True and dict['last_yBut'] == False) or dict['kb_q'] == 2):# and (cont.sensors["vehicleNear"].positive == False and own['throw_deck'] == False):
+    #         fliplay3 = fliplay2 + 1
+    #         dar = 0 
+    #         if grindDar.hitObjectList != None:
+    #             for x in grindDar.hitObjectList:
+    #                 to_grinder = (x.worldPosition - own.worldPosition).length
+    #                 #if 'coping' in x and to_grinder < .36:
+    #                 if 'coping' in x:    
+    #                     dar = 1
+    #         if dropinCol.positive == True or dar == 1: 
+    #             nearestObject = None
+    #             grindEmpty = scene.objects['grindEmpty']
+    #             grindDar = grindEmpty.sensors['grindDar2']
+    #             minDist = None             
+    #             if grindDar.positive:
+    #                 detectedObjects = grindDar.hitObjectList
+    #                 dist = 0
+    #                 for obj in detectedObjects:
+    #                     dist = own.getDistanceTo(obj)
+    #                     if (minDist is None or dist < minDist):
+    #                         nearestObject = obj
+    #                         minDist = dist
+
+    #             print('dropin')
+    #             if STANCE == 0: 
+    #                 own['requestAction'] ='reg_dropin' 
+    #                 own['dropinTimer'] = 60                                     
                         
-                if STANCE == 1: 
-                    own['requestAction'] ='fak_dropin'  
-                    own['dropinTimer'] = 60                                 
+    #             if STANCE == 1: 
+    #                 own['requestAction'] ='fak_dropin'  
+    #                 own['dropinTimer'] = 60                                 
                                          
-        if getonboard == 1:
-            fliplay3 = 6000 
-            onboard_speed = .1                                      
-            own['getonboard'] = 0 
-            own['walk_idling'] = 0
-        if (yBut == False and lasty == True) or (yBut == True or dict['kb_q'] == 3) and dropinCol.positive:
-            print('getting on board')
-            deckact = deck.actuators["Visibility"]
-            trucksact = trucks.actuators["Visibility"]
-            wheel1act = wheel1.actuators["Visibility"]
-            wheel2act = wheel2.actuators["Visibility"]
-            wheel3act = wheel3.actuators["Visibility"]
-            wheel4act = wheel4.actuators["Visibility"]        
-            deckact.visibility = True
-            trucksact.visibility = True
-            wheel1act.visibility = True
-            wheel2act.visibility = True
-            wheel3act.visibility = True
-            wheel4act.visibility = True  
-            cont.activate(deck.actuators['Visibility'])
-            cont.activate(trucks.actuators['Visibility'])
-            cont.activate(wheel1.actuators['Visibility'])
-            cont.activate(wheel2.actuators['Visibility'])
-            cont.activate(wheel3.actuators['Visibility'])
-            cont.activate(wheel4.actuators['Visibility']) 
-            own['throw_deck'] = False 
-            throw_deck_empty = scene.objects["throw_deck_empty"]
-            throw_deck_empty['kill_deck'] = 1 
-        if ((yBut == False and lasty == True) or dict['kb_q'] == 3):# and cont.sensors["vehicleNear"].positive == False: 
-            print('secondary get on board')              
-            own['getonboard'] = 1 
-            own['walk_idling'] = 0      
-            deckact = deck.actuators["Visibility"]
-            trucksact = trucks.actuators["Visibility"]
-            wheel1act = wheel1.actuators["Visibility"]
-            wheel2act = wheel2.actuators["Visibility"]
-            wheel3act = wheel3.actuators["Visibility"]
-            wheel4act = wheel4.actuators["Visibility"]        
-            deckact.visibility = True
-            trucksact.visibility = True
-            wheel1act.visibility = True
-            wheel2act.visibility = True
-            wheel3act.visibility = True
-            wheel4act.visibility = True  
-            cont.activate(deck.actuators['Visibility'])
-            cont.activate(trucks.actuators['Visibility'])
-            cont.activate(wheel1.actuators['Visibility'])
-            cont.activate(wheel2.actuators['Visibility'])
-            cont.activate(wheel3.actuators['Visibility'])
-            cont.activate(wheel4.actuators['Visibility']) 
-            own['throw_deck'] = False 
-            throw_deck_empty = scene.objects["throw_deck_empty"]
-            throw_deck_empty['kill_deck'] = 1 
+    #     if getonboard == 1:
+    #         fliplay3 = 6000 
+    #         onboard_speed = .1                                      
+    #         own['getonboard'] = 0 
+    #         own['walk_idling'] = 0
+    #     if (yBut == False and lasty == True) or (yBut == True or dict['kb_q'] == 3) and dropinCol.positive:
+    #         print('getting on board')
+    #         deckact = deck.actuators["Visibility"]
+    #         trucksact = trucks.actuators["Visibility"]
+    #         wheel1act = wheel1.actuators["Visibility"]
+    #         wheel2act = wheel2.actuators["Visibility"]
+    #         wheel3act = wheel3.actuators["Visibility"]
+    #         wheel4act = wheel4.actuators["Visibility"]        
+    #         deckact.visibility = True
+    #         trucksact.visibility = True
+    #         wheel1act.visibility = True
+    #         wheel2act.visibility = True
+    #         wheel3act.visibility = True
+    #         wheel4act.visibility = True  
+    #         cont.activate(deck.actuators['Visibility'])
+    #         cont.activate(trucks.actuators['Visibility'])
+    #         cont.activate(wheel1.actuators['Visibility'])
+    #         cont.activate(wheel2.actuators['Visibility'])
+    #         cont.activate(wheel3.actuators['Visibility'])
+    #         cont.activate(wheel4.actuators['Visibility']) 
+    #         own['throw_deck'] = False 
+    #         throw_deck_empty = scene.objects["throw_deck_empty"]
+    #         throw_deck_empty['kill_deck'] = 1 
+    #     if ((yBut == False and lasty == True) or dict['kb_q'] == 3):# and cont.sensors["vehicleNear"].positive == False: 
+    #         print('secondary get on board')              
+    #         own['getonboard'] = 1 
+    #         own['walk_idling'] = 0      
+    #         deckact = deck.actuators["Visibility"]
+    #         trucksact = trucks.actuators["Visibility"]
+    #         wheel1act = wheel1.actuators["Visibility"]
+    #         wheel2act = wheel2.actuators["Visibility"]
+    #         wheel3act = wheel3.actuators["Visibility"]
+    #         wheel4act = wheel4.actuators["Visibility"]        
+    #         deckact.visibility = True
+    #         trucksact.visibility = True
+    #         wheel1act.visibility = True
+    #         wheel2act.visibility = True
+    #         wheel3act.visibility = True
+    #         wheel4act.visibility = True  
+    #         cont.activate(deck.actuators['Visibility'])
+    #         cont.activate(trucks.actuators['Visibility'])
+    #         cont.activate(wheel1.actuators['Visibility'])
+    #         cont.activate(wheel2.actuators['Visibility'])
+    #         cont.activate(wheel3.actuators['Visibility'])
+    #         cont.activate(wheel4.actuators['Visibility']) 
+    #         own['throw_deck'] = False 
+    #         throw_deck_empty = scene.objects["throw_deck_empty"]
+    #         throw_deck_empty['kill_deck'] = 1 
 
 
 
-    def nextframe():
-        framenumber = own["framenum"]
-        framenumber = framenumber + 1
-        if framenumber == 900000:
-            framenumber = 0
-        own["framenum"] = framenumber
-        own['last_walk_frame'] = framenumber
+    # def nextframe():
+    #     framenumber = own["framenum"]
+    #     framenumber = framenumber + 1
+    #     if framenumber == 900000:
+    #         framenumber = 0
+    #     own["framenum"] = framenumber
+    #     own['last_walk_frame'] = framenumber
                 
-    def checkidle():
-        idle = cont.sensors["idle"]
-        idle_frame = own["walk_idle_frame"]
-        if idle.positive:
-            own["walk_idle_frame"] = 0
-            cont.deactivate(camobj.actuators['idle_camRight'])  
-            #camera.height = .5
-            camera.height = dict['cam_idle_height']
-        else: 
-            if idle_frame == 0:
-                own["walk_idle_frame"] = own["framenum"] 
-            diff = own["framenum"] - idle_frame
+    # def checkidle():
+    #     idle = cont.sensors["idle"]
+    #     idle_frame = own["walk_idle_frame"]
+    #     if idle.positive:
+    #         own["walk_idle_frame"] = 0
+    #         cont.deactivate(camobj.actuators['idle_camRight'])  
+    #         #camera.height = .5
+    #         camera.height = dict['cam_idle_height']
+    #     else: 
+    #         if idle_frame == 0:
+    #             own["walk_idle_frame"] = own["framenum"] 
+    #         diff = own["framenum"] - idle_frame
             
-            if (diff > 700 and idle_frame != 0 and dropinCol.positive == False and own['walk'] != 0) or own['sit'] == 1:
-                cont.activate(camobj.actuators['idle_camRight'])  
-                #camera.height = .9   
-                #camera.min = 2
-                #camera.max = 2.50
-                own['walk_idling'] = 1
-            else:
-                own['walk_idling'] = 0    
+    #         if (diff > 700 and idle_frame != 0 and dropinCol.positive == False and own['walk'] != 0) or own['sit'] == 1:
+    #             cont.activate(camobj.actuators['idle_camRight'])  
+    #             #camera.height = .9   
+    #             #camera.min = 2
+    #             #camera.max = 2.50
+    #             own['walk_idling'] = 1
+    #         else:
+    #             own['walk_idling'] = 0    
                 
-    def idle_anim():
-        if own['walk_idling'] == 1 and own['sit'] == 0:
-            walk_idle_frame = own['walk_idle_frame']
-            mod_num = (own["framenum"] - walk_idle_frame) % 240
-            idle_lay = 300
-            if mod_num == 0:
-                if own['idle_skipper'] > 0:
-                   own['idle_skipper'] -= 1 
-                ran_num = random.randint(1, 8)
-                if own['last_idle_num'] == ran_num:
-                    ran_num = 1
-                if own['idle_skipper'] == 0:
-                    own['last_idle_num'] = ran_num
-                    if ran_num == 1 or ran_num > 7:    
-                        killact(3)
-                        if STANCE == 0 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'reg_idle1'
-                        elif STANCE == 0 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'reg_idle1'
-                        elif STANCE == 1 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'fak_idle1'
-                        elif STANCE == 1 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'fak_idle1'
+    # def idle_anim():
+    #     if own['walk_idling'] == 1 and own['sit'] == 0:
+    #         walk_idle_frame = own['walk_idle_frame']
+    #         mod_num = (own["framenum"] - walk_idle_frame) % 240
+    #         idle_lay = 300
+    #         if mod_num == 0:
+    #             if own['idle_skipper'] > 0:
+    #                own['idle_skipper'] -= 1 
+    #             ran_num = random.randint(1, 8)
+    #             if own['last_idle_num'] == ran_num:
+    #                 ran_num = 1
+    #             if own['idle_skipper'] == 0:
+    #                 own['last_idle_num'] = ran_num
+    #                 if ran_num == 1 or ran_num > 7:    
+    #                     killact(3)
+    #                     if STANCE == 0 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'reg_idle1'
+    #                     elif STANCE == 0 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'reg_idle1'
+    #                     elif STANCE == 1 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'fak_idle1'
+    #                     elif STANCE == 1 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'fak_idle1'
                                                                                
-                    elif ran_num == 2:    
-                        killact(3)
-                        if STANCE == 0 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'reg_idle2'
-                        elif STANCE == 0 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'reg_idle2_nb'
-                        elif STANCE == 1 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'fak_idle1'
-                        elif STANCE == 1 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'fak_idle1'
-                    elif ran_num == 3:    
-                        killact(3)
-                        if STANCE == 0 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'reg_idle3'
-                        elif STANCE == 0 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'reg_idle3'
-                        elif STANCE == 1 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'fak_idle1'
-                        elif STANCE == 1 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'fak_idle1'
-                        own['idle_skipper'] = 2 
-                    elif ran_num == 4:    
-                        killact(3)
-                        if STANCE == 0 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'reg_idle4'
-                        elif STANCE == 0 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'reg_idle4'
-                        elif STANCE == 1 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'fak_idle4'
-                        elif STANCE == 1 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'fak_idle4' 
-                    elif ran_num == 5:    
-                        killact(3)
-                        if STANCE == 0 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'reg_idle5'
-                        elif STANCE == 0 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'reg_idle5'
-                        elif STANCE == 1 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'fak_idle5'
-                        elif STANCE == 1 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'fak_idle5'
-                    elif ran_num == 6:    
-                        killact(3)
-                        if STANCE == 0 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'reg_idle6'
-                        elif STANCE == 0 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'reg_idle6'
-                        elif STANCE == 1 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'fak_idle6'
-                        elif STANCE == 1 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'fak_idle6'
-                    elif ran_num == 7:    
-                        killact(3)
-                        if STANCE == 0 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'reg_idle7'
-                        elif STANCE == 0 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'reg_idle7'
-                        elif STANCE == 1 and own['throw_deck'] == 0:
-                            own['requestAction'] = 'fak_idle6'
-                        elif STANCE == 1 and own['throw_deck'] == 1:
-                            own['requestAction'] = 'fak_idle6'
+    #                 elif ran_num == 2:    
+    #                     killact(3)
+    #                     if STANCE == 0 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'reg_idle2'
+    #                     elif STANCE == 0 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'reg_idle2_nb'
+    #                     elif STANCE == 1 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'fak_idle1'
+    #                     elif STANCE == 1 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'fak_idle1'
+    #                 elif ran_num == 3:    
+    #                     killact(3)
+    #                     if STANCE == 0 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'reg_idle3'
+    #                     elif STANCE == 0 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'reg_idle3'
+    #                     elif STANCE == 1 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'fak_idle1'
+    #                     elif STANCE == 1 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'fak_idle1'
+    #                     own['idle_skipper'] = 2 
+    #                 elif ran_num == 4:    
+    #                     killact(3)
+    #                     if STANCE == 0 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'reg_idle4'
+    #                     elif STANCE == 0 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'reg_idle4'
+    #                     elif STANCE == 1 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'fak_idle4'
+    #                     elif STANCE == 1 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'fak_idle4' 
+    #                 elif ran_num == 5:    
+    #                     killact(3)
+    #                     if STANCE == 0 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'reg_idle5'
+    #                     elif STANCE == 0 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'reg_idle5'
+    #                     elif STANCE == 1 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'fak_idle5'
+    #                     elif STANCE == 1 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'fak_idle5'
+    #                 elif ran_num == 6:    
+    #                     killact(3)
+    #                     if STANCE == 0 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'reg_idle6'
+    #                     elif STANCE == 0 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'reg_idle6'
+    #                     elif STANCE == 1 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'fak_idle6'
+    #                     elif STANCE == 1 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'fak_idle6'
+    #                 elif ran_num == 7:    
+    #                     killact(3)
+    #                     if STANCE == 0 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'reg_idle7'
+    #                     elif STANCE == 0 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'reg_idle7'
+    #                     elif STANCE == 1 and own['throw_deck'] == 0:
+    #                         own['requestAction'] = 'fak_idle6'
+    #                     elif STANCE == 1 and own['throw_deck'] == 1:
+    #                         own['requestAction'] = 'fak_idle6'
 
-    def reset_pos():
-        #reset
-        if ddPad == 1:   
-            spawn_pos = own['spawn_pos']
-            spawn_rot = own['spawn_rot']
-            spawn_cam_pos = own['spawn_cam_pos']
-            spawn_cam_rot = own['spawn_cam_rot']            
-            try:
-                own.worldPosition = (spawn_pos[0], spawn_pos[1], (spawn_pos[2] + .1))
-                own.worldOrientation = [[spawn_rot[0][0],spawn_rot[0][1],spawn_rot[0][2]], [spawn_rot[1][0],spawn_rot[1][1],spawn_rot[1][2]], [0.0, 0.0, 1.0]]
-                cam.worldPosition = (spawn_cam_pos[0], spawn_cam_pos[1], (spawn_cam_pos[2]))
-                cam.worldOrientation = [[spawn_cam_rot[0][0],spawn_cam_rot[0][1],spawn_cam_rot[0][2]], [spawn_cam_rot[1][0],spawn_cam_rot[1][1],spawn_cam_rot[1][2]], [0.0, 0.0, 1.0]]            
-            except:    
-                own.worldPosition = (5, 2, .1)
-                own.worldOrientation = [[1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] 
-            own['stance'] = own['spawn_stance']                          
-            if own["spawn_stance"] == 1:
-                own.setLinearVelocity([.1,0,0], 1)
-            else: 
-                own.setLinearVelocity([-.1,0,0], 1)         
+    # def reset_pos():
+    #     #reset
+    #     if ddPad == 1:   
+    #         spawn_pos = own['spawn_pos']
+    #         spawn_rot = own['spawn_rot']
+    #         spawn_cam_pos = own['spawn_cam_pos']
+    #         spawn_cam_rot = own['spawn_cam_rot']            
+    #         try:
+    #             own.worldPosition = (spawn_pos[0], spawn_pos[1], (spawn_pos[2] + .1))
+    #             own.worldOrientation = [[spawn_rot[0][0],spawn_rot[0][1],spawn_rot[0][2]], [spawn_rot[1][0],spawn_rot[1][1],spawn_rot[1][2]], [0.0, 0.0, 1.0]]
+    #             cam.worldPosition = (spawn_cam_pos[0], spawn_cam_pos[1], (spawn_cam_pos[2]))
+    #             cam.worldOrientation = [[spawn_cam_rot[0][0],spawn_cam_rot[0][1],spawn_cam_rot[0][2]], [spawn_cam_rot[1][0],spawn_cam_rot[1][1],spawn_cam_rot[1][2]], [0.0, 0.0, 1.0]]            
+    #         except:    
+    #             own.worldPosition = (5, 2, .1)
+    #             own.worldOrientation = [[1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] 
+    #         own['stance'] = own['spawn_stance']                          
+    #         if own["spawn_stance"] == 1:
+    #             own.setLinearVelocity([.1,0,0], 1)
+    #         else: 
+    #             own.setLinearVelocity([-.1,0,0], 1)         
                 
-        if udPad == 1:        
-            own['spawn_pos'] = [own.worldPosition[0], own.worldPosition[1], own.worldPosition[2]] 
-            own['spawn_rot'] = [[own.worldOrientation[0][0],own.worldOrientation[0][1],own.worldOrientation[0][2]], [own.worldOrientation[1][0],own.worldOrientation[1][1],own.worldOrientation[1][2]], own.worldOrientation[2][2]]
-            own['spawn_cam_pos'] = [cam.worldPosition[0], cam.worldPosition[1], cam.worldPosition[2]] 
-            own['spawn_cam_rot'] = [[cam.worldOrientation[0][0],cam.worldOrientation[0][1],cam.worldOrientation[0][2]], [cam.worldOrientation[1][0],cam.worldOrientation[1][1],cam.worldOrientation[1][2]], cam.worldOrientation[2][2]]            
-            stance = own["stance"]
-            own["spawn_stance"] = stance   
-    def falldeck():
-        throw_deck_empty = scene.objects["throw_deck_empty"]
-        throw_deck_empty.worldPosition.y += .5
-        throw_deck_empty.worldPosition.x += .5
-        deckact = deck.actuators["Visibility"]
-        trucksact = trucks.actuators["Visibility"]
-        wheel1act = wheel1.actuators["Visibility"]
-        wheel2act = wheel2.actuators["Visibility"]
-        wheel3act = wheel3.actuators["Visibility"]
-        wheel4act = wheel4.actuators["Visibility"]
-        print('doing falldeck')        
-        if own['throw_deck'] == False:
-            own['throw_deck'] = True
-            deckact.visibility = False
-            trucksact.visibility = False
-            wheel1act.visibility = False
-            wheel2act.visibility = False
-            wheel3act.visibility = False
-            wheel4act.visibility = False
-            act = throw_deck_empty.actuators['throw_dec_act']
-            if STANCE == True:
-                act.linearVelocity = [0.0, 1.0, 1.0]
-            if STANCE == False:
-                act.linearVelocity = [0.0, 1.0, -1.0]  
-            cont.activate(act)
-            print('running falldeck()')
-        else:
-            own['throw_deck'] = False    
-            deckact.visibility = True
-            trucksact.visibility = True
-            wheel1act.visibility = True
-            wheel2act.visibility = True
-            wheel3act.visibility = True
-            wheel4act.visibility = True
-            throw_deck_empty['kill_deck'] = 1    
-        cont.activate(deck.actuators['Visibility'])
-        cont.activate(trucks.actuators['Visibility'])
-        cont.activate(wheel1.actuators['Visibility'])
-        cont.activate(wheel2.actuators['Visibility'])
-        cont.activate(wheel3.actuators['Visibility'])
-        cont.activate(wheel4.actuators['Visibility']) 
+    #     if udPad == 1:        
+    #         own['spawn_pos'] = [own.worldPosition[0], own.worldPosition[1], own.worldPosition[2]] 
+    #         own['spawn_rot'] = [[own.worldOrientation[0][0],own.worldOrientation[0][1],own.worldOrientation[0][2]], [own.worldOrientation[1][0],own.worldOrientation[1][1],own.worldOrientation[1][2]], own.worldOrientation[2][2]]
+    #         own['spawn_cam_pos'] = [cam.worldPosition[0], cam.worldPosition[1], cam.worldPosition[2]] 
+    #         own['spawn_cam_rot'] = [[cam.worldOrientation[0][0],cam.worldOrientation[0][1],cam.worldOrientation[0][2]], [cam.worldOrientation[1][0],cam.worldOrientation[1][1],cam.worldOrientation[1][2]], cam.worldOrientation[2][2]]            
+    #         stance = own["stance"]
+    #         own["spawn_stance"] = stance   
+    # def falldeck():
+    #     throw_deck_empty = scene.objects["throw_deck_empty"]
+    #     throw_deck_empty.worldPosition.y += .5
+    #     throw_deck_empty.worldPosition.x += .5
+    #     deckact = deck.actuators["Visibility"]
+    #     trucksact = trucks.actuators["Visibility"]
+    #     wheel1act = wheel1.actuators["Visibility"]
+    #     wheel2act = wheel2.actuators["Visibility"]
+    #     wheel3act = wheel3.actuators["Visibility"]
+    #     wheel4act = wheel4.actuators["Visibility"]
+    #     print('doing falldeck')        
+    #     if own['throw_deck'] == False:
+    #         own['throw_deck'] = True
+    #         deckact.visibility = False
+    #         trucksact.visibility = False
+    #         wheel1act.visibility = False
+    #         wheel2act.visibility = False
+    #         wheel3act.visibility = False
+    #         wheel4act.visibility = False
+    #         act = throw_deck_empty.actuators['throw_dec_act']
+    #         if STANCE == True:
+    #             act.linearVelocity = [0.0, 1.0, 1.0]
+    #         if STANCE == False:
+    #             act.linearVelocity = [0.0, 1.0, -1.0]  
+    #         cont.activate(act)
+    #         print('running falldeck()')
+    #     else:
+    #         own['throw_deck'] = False    
+    #         deckact.visibility = True
+    #         trucksact.visibility = True
+    #         wheel1act.visibility = True
+    #         wheel2act.visibility = True
+    #         wheel3act.visibility = True
+    #         wheel4act.visibility = True
+    #         throw_deck_empty['kill_deck'] = 1    
+    #     cont.activate(deck.actuators['Visibility'])
+    #     cont.activate(trucks.actuators['Visibility'])
+    #     cont.activate(wheel1.actuators['Visibility'])
+    #     cont.activate(wheel2.actuators['Visibility'])
+    #     cont.activate(wheel3.actuators['Visibility'])
+    #     cont.activate(wheel4.actuators['Visibility']) 
 
-    def throwdeck(strength, ud):
-        throw_deck_empty = scene.objects["throw_deck_empty"]
-        deckact = deck.actuators["Visibility"]
-        trucksact = trucks.actuators["Visibility"]
-        wheel1act = wheel1.actuators["Visibility"]
-        wheel2act = wheel2.actuators["Visibility"]
-        wheel3act = wheel3.actuators["Visibility"]
-        wheel4act = wheel4.actuators["Visibility"]
+    # def throwdeck(strength, ud):
+    #     throw_deck_empty = scene.objects["throw_deck_empty"]
+    #     deckact = deck.actuators["Visibility"]
+    #     trucksact = trucks.actuators["Visibility"]
+    #     wheel1act = wheel1.actuators["Visibility"]
+    #     wheel2act = wheel2.actuators["Visibility"]
+    #     wheel3act = wheel3.actuators["Visibility"]
+    #     wheel4act = wheel4.actuators["Visibility"]
                 
-        if own['throw_deck'] == False:
-            own['throw_deck'] = True
-            deckact.visibility = False
-            trucksact.visibility = False
-            wheel1act.visibility = False
-            wheel2act.visibility = False
-            wheel3act.visibility = False
-            wheel4act.visibility = False
-            act = throw_deck_empty.actuators['throw_dec_act']
-            hard = strength * .08
-            if hard > 9:
-                hard = 9
-            if hard < 1:
-                hard = 1    
-            ud = ud * 4
-            own['bbut_timer'] = 0
-            if STANCE == True:
-                own['requestAction'] = 'fak_throw'
-                act.linearVelocity = [0.0, ud, hard]
-            if STANCE == False:
-                own['requestAction'] = 'fak_throw'
-                act.linearVelocity = [0.0, ud, -hard]  
-            cont.activate(act)
-        else:
-            own['throw_deck'] = False    
-            deckact.visibility = True
-            trucksact.visibility = True
-            wheel1act.visibility = True
-            wheel2act.visibility = True
-            wheel3act.visibility = True
-            wheel4act.visibility = True
-            throw_deck_empty['kill_deck'] = 1     
-        cont.activate(deck.actuators['Visibility'])
-        cont.activate(trucks.actuators['Visibility'])
-        cont.activate(wheel1.actuators['Visibility'])
-        cont.activate(wheel2.actuators['Visibility'])
-        cont.activate(wheel3.actuators['Visibility'])
-        cont.activate(wheel4.actuators['Visibility'])            
-    def throwdeck_trigger():
-        lastb = own['lastb']
-        throw_deck_empty = scene.objects["throw_deck_empty"]
-        if bBut == True:
-            own['bbut_timer'] += 1
-            ud = (rUD * 10) +1
-        if bBut == False:
-            throw_deck_empty['kill_deck'] = 0
-        if bBut == False and own['lastb'] == True:        
-            strength = own['bbut_timer']
-            ud = (rUD * 10) +1
-            throwdeck(strength, ud)   
+    #     if own['throw_deck'] == False:
+    #         own['throw_deck'] = True
+    #         deckact.visibility = False
+    #         trucksact.visibility = False
+    #         wheel1act.visibility = False
+    #         wheel2act.visibility = False
+    #         wheel3act.visibility = False
+    #         wheel4act.visibility = False
+    #         act = throw_deck_empty.actuators['throw_dec_act']
+    #         hard = strength * .08
+    #         if hard > 9:
+    #             hard = 9
+    #         if hard < 1:
+    #             hard = 1    
+    #         ud = ud * 4
+    #         own['bbut_timer'] = 0
+    #         if STANCE == True:
+    #             own['requestAction'] = 'fak_throw'
+    #             act.linearVelocity = [0.0, ud, hard]
+    #         if STANCE == False:
+    #             own['requestAction'] = 'fak_throw'
+    #             act.linearVelocity = [0.0, ud, -hard]  
+    #         cont.activate(act)
+    #     else:
+    #         own['throw_deck'] = False    
+    #         deckact.visibility = True
+    #         trucksact.visibility = True
+    #         wheel1act.visibility = True
+    #         wheel2act.visibility = True
+    #         wheel3act.visibility = True
+    #         wheel4act.visibility = True
+    #         throw_deck_empty['kill_deck'] = 1     
+    #     cont.activate(deck.actuators['Visibility'])
+    #     cont.activate(trucks.actuators['Visibility'])
+    #     cont.activate(wheel1.actuators['Visibility'])
+    #     cont.activate(wheel2.actuators['Visibility'])
+    #     cont.activate(wheel3.actuators['Visibility'])
+    #     cont.activate(wheel4.actuators['Visibility'])            
+    # def throwdeck_trigger():
+    #     lastb = own['lastb']
+    #     throw_deck_empty = scene.objects["throw_deck_empty"]
+    #     if bBut == True:
+    #         own['bbut_timer'] += 1
+    #         ud = (rUD * 10) +1
+    #     if bBut == False:
+    #         throw_deck_empty['kill_deck'] = 0
+    #     if bBut == False and own['lastb'] == True:        
+    #         strength = own['bbut_timer']
+    #         ud = (rUD * 10) +1
+    #         throwdeck(strength, ud)   
             
-    def focus_deck():
-        since_air = own['framenum'] - own['lF_air_frame']
-        if cb_td.positive and since_air < 10:
-            object = 'focus_deckA'
-            object2 = 'focus_deckB'            
-            other = throw_deck_empty
-            throw_deck = scene.objects["throw_deck"]
-            throw_deck.endObject()
-            scene.addObject(object, other, 0)          
-            scene.addObject(object2, other, 0)
+    # def focus_deck():
+    #     since_air = own['framenum'] - own['lF_air_frame']
+    #     if cb_td.positive and since_air < 10:
+    #         object = 'focus_deckA'
+    #         object2 = 'focus_deckB'            
+    #         other = throw_deck_empty
+    #         throw_deck = scene.objects["throw_deck"]
+    #         throw_deck.endObject()
+    #         scene.addObject(object, other, 0)          
+    #         scene.addObject(object2, other, 0)
                     
-        if own['throw_deck'] == True:
-            if dict['ldPad'] == False and dict['last_ldPad'] == True: 
-                object = 'focus_deckA'
-                object2 = 'focus_deckB'            
-                other = throw_deck_empty
-                scene.addObject(object, other, 0)          
-                scene.addObject(object2, other, 0)          
+    #     if own['throw_deck'] == True:
+    #         if dict['ldPad'] == False and dict['last_ldPad'] == True: 
+    #             object = 'focus_deckA'
+    #             object2 = 'focus_deckB'            
+    #             other = throw_deck_empty
+    #             scene.addObject(object, other, 0)          
+    #             scene.addObject(object2, other, 0)          
                   
-    def fall():
-        if own['fall'] == True:
-            falldeck()        
-            if STANCE == 1:
-                own['requestAction'] = 'fak_air-walk_air'            
-                #own.setLinearVelocity([3,2,0], True)
-            else:
-                own['requestAction'] = 'reg_air-walk_air'
-                #own.setLinearVelocity([-3,-2,0], True)    
-            own['fall'] = False
-            own.worldPosition.z += .3
-            print('falling from walk.py')
+    # def fall():
+    #     if own['fall'] == True:
+    #         falldeck()        
+    #         if STANCE == 1:
+    #             own['requestAction'] = 'fak_air-walk_air'            
+    #             #own.setLinearVelocity([3,2,0], True)
+    #         else:
+    #             own['requestAction'] = 'reg_air-walk_air'
+    #             #own.setLinearVelocity([-3,-2,0], True)    
+    #         own['fall'] = False
+    #         own.worldPosition.z += .3
+    #         print('falling from walk.py')
 
-    def sit():
-        #turn off sit
-        if lup == 1 or ldown == 1 or lUD > sens or lUD < -sens:
-            if own['sit'] == 1:
-                killact(300)
-                killact(299)
-            own['sit'] = 0
+    # def sit():
+    #     #turn off sit
+    #     if lup == 1 or ldown == 1 or lUD > sens or lUD < -sens:
+    #         if own['sit'] == 1:
+    #             killact(300)
+    #             killact(299)
+    #         own['sit'] = 0
 
-        if aBut == True and lasta == False:
-            try:
-                if 'sit' in r_ground.hitObject:
-                    #print("sit")
-                    own['sit'] = 1
-                    killact(3)
-                    if STANCE == 0:
-                        own['requestAction'] = 'reg_sit'
-                    elif STANCE == 1:
-                        own['requestAction'] = 'fak_sit'                                        
-            except:
-                pass    
-        if own['sit'] == 1:
-            try:
-                killact(3)
-                sit_vect = r_ground.hitObject.getAxisVect( [0, 1, 0])
-                if STANCE == 0:
-                    own.alignAxisToVect(-sit_vect, 0, .2)
-                    own['requestAction'] = 'reg_sit'                               
+    #     if aBut == True and lasta == False:
+    #         try:
+    #             if 'sit' in r_ground.hitObject:
+    #                 #print("sit")
+    #                 own['sit'] = 1
+    #                 killact(3)
+    #                 if STANCE == 0:
+    #                     own['requestAction'] = 'reg_sit'
+    #                 elif STANCE == 1:
+    #                     own['requestAction'] = 'fak_sit'                                        
+    #         except:
+    #             pass    
+    #     if own['sit'] == 1:
+    #         try:
+    #             killact(3)
+    #             sit_vect = r_ground.hitObject.getAxisVect( [0, 1, 0])
+    #             if STANCE == 0:
+    #                 own.alignAxisToVect(-sit_vect, 0, .2)
+    #                 own['requestAction'] = 'reg_sit'                               
                     
-                elif STANCE == 1:
-                    own['requestAction'] = 'fak_sit'
-                    own.alignAxisToVect(sit_vect, 0, .2)                    
-            except:
-                pass    
+    #             elif STANCE == 1:
+    #                 own['requestAction'] = 'fak_sit'
+    #                 own.alignAxisToVect(sit_vect, 0, .2)                    
+    #         except:
+    #             pass    
                           
-    def switchcam():
-        if ltsBut == False and own['lastlts'] == True and rtsBut == False:
-            if own['camera'] == 1:
-                own['camera'] = 0
-            else:
-                own['camera'] = 1
-        if rtsBut == False and own['lastrts'] == True and ltsBut == False:
-            if own['camera'] == 2:
-                own['camera'] = 0
-            else:
-                own['camera'] = 2 
-    #followcam 
-    def move_followcam():
-        if own['camera'] == 2:
-            if own['lastbkBut'] == True and bkBut == False:
-                #print("activate move followcam") 
-                if own['move_followcam'] == False:
-                    own['move_followcam'] = True
-                else:
-                    own['move_followcam'] = False                       
-            if own['move_followcam'] == True:
-                camspeed1 = .015
-                camspeed2 = .055
-                camrot1 = .005
-                camrot2 = .02
-                #up
-                if lUD < -0.080:
-                    followcam.actuators["up"].dLoc = [ 0, 0, -camspeed2]
-                    cont.activate(followcam.actuators["up"])
-                    #print("fastup")
-                else:
-                    cont.deactivate(followcam.actuators["up"])    
-    #            #down    
-                if lUD > .080:
-                    followcam.actuators["down"].dLoc = [ 0, 0, camspeed2]
-                    cont.activate(followcam.actuators["down"])
-                else:
-                    cont.deactivate(followcam.actuators["down"])                    
-    #            #left
-                #if lLR < -0.080:
-                if lLR > 0.080:    
-                    followcam.actuators["left"].dLoc = [-camspeed2, 0, 0]                
-                    cont.activate(followcam.actuators["left"])
-                else:
-                    cont.deactivate(followcam.actuators["left"])                    
-    #            #right
-                #if lLR > 0.080: 
-                if lLR < -0.080:         
-                    followcam.actuators["right"].dLoc = [camspeed2, 0, 0]                
-                    cont.activate(followcam.actuators["right"])
-                else:
-                    cont.deactivate(followcam.actuators["right"])  
-                #up
-                if rUD < -0.080:
-                    followcam.actuators["rotup"].dLoc = [0, 0, camrot2]
-                    cont.activate(followcam.actuators["rotup"])
-                else:
-                    cont.deactivate(followcam.actuators["rotup"])    
-    #            #down    
-                if rUD > .080:
-                    followcam.actuators["rotdown"].dLoc = [0, 0, -camrot2]                
-                    cont.activate(followcam.actuators["rotdown"])
-                else:
-                    cont.deactivate(followcam.actuators["rotdown"])                    
-    #            #left
-                if rLR < -0.080:
-                    followcam.actuators["rotleft"].dRot = [0, 0, camrot2]                
-                    cont.activate(followcam.actuators["rotleft"])
-                else:
-                    cont.deactivate(followcam.actuators["rotleft"])                    
-    #            #right
-                if rLR > 0.080:         
-                    followcam.actuators["rotright"].dRot = [0, 0, -camrot2]
-                    cont.activate(followcam.actuators["rotright"])
-                else:
-                    cont.deactivate(followcam.actuators["rotright"]) 
-
-    #*********************************************                
-                    
-                if lUD > -0.080 and lUD < -0.030:
-                    followcam.actuators["up"].dLoc = [ 0, 0, -camspeed1]
-                    cont.activate(followcam.actuators["up"])
-                else:
-                    cont.deactivate(followcam.actuators["up"])    
-    #            #down    
-                if lUD < .080 and lUD > .03:
-                    followcam.actuators["down"].dLoc = [ 0, 0, camspeed1]                
-                    cont.activate(followcam.actuators["down"])
-                else:
-                    cont.deactivate(followcam.actuators["down"])                    
-    #            #left
-                if lLR > -0.080 and lLR < -0.030:
-                    followcam.actuators["left"].dLoc = [-camspeed1, 0, 0]                
-                    cont.activate(followcam.actuators["left"])
-                else:
-                    cont.deactivate(followcam.actuators["left"])                    
-    #            #right
-                if lLR < .080 and lLR > .03:       
-                    followcam.actuators["right"].dLoc = [camspeed1, 0, 0]
-                    cont.activate(followcam.actuators["right"])
-                else:
-                    cont.deactivate(followcam.actuators["right"])  
-                #up
-                if rUD > -0.080 and rUD < -0.030:
-                    followcam.actuators["rotup"].dRot = [camrot1, 0, 0]                
-                    cont.activate(followcam.actuators["rotup"])
-                else:
-                    cont.deactivate(followcam.actuators["rotup"])    
-    #            #down    
-                if rUD < .080 and rUD > .03:
-                    followcam.actuators["rotdown"].dRot = [-camrot1, 0, 0]                
-                    cont.activate(followcam.actuators["rotdown"])
-                else:
-                    cont.deactivate(followcam.actuators["rotdown"])                    
-    #            #left
-                if rLR > -0.080 and rLR < -0.030:
-                    followcam.actuators["rotleft"].dRot = [0, 0, camrot1]
-                    cont.activate(followcam.actuators["rotleft"])
-                else:
-                    cont.deactivate(followcam.actuators["rotleft"])                    
-    #            #right
-                if rLR < .080 and rLR > .03:         
-                    followcam.actuators["rotright"].dRot = [0, 0, -camrot1]
-                    cont.activate(followcam.actuators["rotright"])
-                else:
-                    cont.deactivate(followcam.actuators["rotright"])                       
-    def move_flycam():
-        if own['camera'] == 1:
-            if own['lastbkBut'] == True and bkBut == False: 
-                if own['move_freecam'] == False:
-                    own['move_freecam'] = True
-                else:
-                    own['move_freecam'] = False                       
-            if own['move_freecam'] == True:
-                camspeed1 = .015
-                camspeed2 = .055
-                camrot1 = .005
-                camrot2 = .02
-                #up
-                if lUD < -0.080:
-                    freecam.actuators["up"].dLoc = [ 0, 0, -camspeed2]
-                    cont.activate(freecam.actuators["up"])
-                else:
-                    cont.deactivate(freecam.actuators["up"])    
-    #            #down    
-                if lUD > .080:
-                    freecam.actuators["down"].dLoc = [ 0, 0, camspeed2]
-                    cont.activate(freecam.actuators["down"])
-                else:
-                    cont.deactivate(freecam.actuators["down"])                    
-    #            #left
-                if lLR < -0.080:
-                    freecam.actuators["left"].dLoc = [-camspeed2, 0, 0]                
-                    cont.activate(freecam.actuators["left"])
-                else:
-                    cont.deactivate(freecam.actuators["left"])                    
-    #            #right
-                if lLR > 0.080:         
-                    freecam.actuators["right"].dLoc = [camspeed2, 0, 0]                
-                    cont.activate(freecam.actuators["right"])
-                else:
-                    cont.deactivate(freecam.actuators["right"])  
-                #up
-                if rUD < -0.080:
-                    freecam.actuators["rotup"].dRot = [camrot2, 0, 0]
-                    cont.activate(freecam.actuators["rotup"])
-                else:
-                    cont.deactivate(freecam.actuators["rotup"])    
-    #            #down    
-                if rUD > .080:
-                    freecam.actuators["rotdown"].dRot = [-camrot2, 0, 0]                
-                    cont.activate(freecam.actuators["rotdown"])
-                else:
-                    cont.deactivate(freecam.actuators["rotdown"])                    
-    #            #left
-                if rLR < -0.080:
-                    freecam.actuators["rotleft"].dRot = [0, 0, camrot2]                
-                    cont.activate(freecam.actuators["rotleft"])
-                else:
-                    cont.deactivate(freecam.actuators["rotleft"])                    
-    #            #right
-                if rLR > 0.080:         
-                    freecam.actuators["rotright"].dRot = [0, 0, -camrot2]
-                    cont.activate(freecam.actuators["rotright"])
-                else:
-                    cont.deactivate(freecam.actuators["rotright"]) 
-
-    #*********************************************                
                     
-                if lUD > -0.080 and lUD < -0.030:
-                    freecam.actuators["up"].dLoc = [ 0, 0, -camspeed1]
-                    cont.activate(freecam.actuators["up"])
-                    #print(lUD)
-                else:
-                    cont.deactivate(freecam.actuators["up"])    
-    #            #down    
-                if lUD < .080 and lUD > .03:
-                    freecam.actuators["down"].dLoc = [ 0, 0, camspeed1]                
-                    cont.activate(freecam.actuators["down"])
-                else:
-                    cont.deactivate(freecam.actuators["down"])                    
-    #            #left
-                if lLR > -0.080 and lLR < -0.030:
-                    freecam.actuators["left"].dLoc = [-camspeed1, 0, 0]                
-                    cont.activate(freecam.actuators["left"])
-                else:
-                    cont.deactivate(freecam.actuators["left"])                    
-    #            #right
-                if lLR < .080 and lLR > .03:       
-                    freecam.actuators["right"].dLoc = [camspeed1, 0, 0]
-                    cont.activate(freecam.actuators["right"])
-                else:
-                    cont.deactivate(freecam.actuators["right"])  
-                #up
-                if rUD > -0.080 and rUD < -0.030:
-                    freecam.actuators["rotup"].dRot = [camrot1, 0, 0]                
-                    cont.activate(freecam.actuators["rotup"])
-                else:
-                    cont.deactivate(freecam.actuators["rotup"])    
-    #            #down    
-                if rUD < .080 and rUD > .03:
-                    freecam.actuators["rotdown"].dRot = [-camrot1, 0, 0]                
-                    cont.activate(freecam.actuators["rotdown"])
-                else:
-                    cont.deactivate(freecam.actuators["rotdown"])                    
-    #            #left
-                if rLR > -0.080 and rLR < -0.030:
-                    freecam.actuators["rotleft"].dRot = [0, 0, camrot1]
-                    cont.activate(freecam.actuators["rotleft"])
-                else:
-                    cont.deactivate(freecam.actuators["rotleft"])                    
-    #            #right
-                if rLR < .080 and rLR > .03:         
-                    freecam.actuators["rotright"].dRot = [0, 0, -camrot1]
-                    cont.activate(freecam.actuators["rotright"])
-                else:
-                    cont.deactivate(freecam.actuators["rotright"])                     
-    if r_ground.triggered == False:
-        cont.deactivate(own.actuators["walk_align"])
-    else:
-        cont.activate(own.actuators["walk_align"])                    
+    # if r_ground.triggered == False:
+    #     cont.deactivate(own.actuators["walk_align"])
+    # else:
+    #     cont.activate(own.actuators["walk_align"])                    
 
-    #walking on stairs
-    if r_ground.triggered:
-        try:
-            if 'stair' in r_ground.hitObject:
-                own['stair_counter'] = 20
+    # #walking on stairs
+    # if r_ground.triggered:
+    #     try:
+    #         if 'stair' in r_ground.hitObject:
+    #             own['stair_counter'] = 20
                 
-        except:
-            pass        
-        if own['stair_counter'] > 0:
-            own.linearVelocity.z += .1
-            own['stair_counter'] -= 1     
+    #     except:
+    #         pass        
+    #     if own['stair_counter'] > 0:
+    #         own.linearVelocity.z += .1
+    #         own['stair_counter'] -= 1     
 
-    if yBut == True:
-        own['walk_idling'] = 0
-        own["walk_idle_frame"] = 0
+    # if yBut == True:
+    #     own['walk_idling'] = 0
+    #     own["walk_idle_frame"] = 0
 
 
 
-    if own['stair_counter'] > 5 and r_ground.triggered == False:
-        own.applyForce([0,0,-200], True)                          
+    # if own['stair_counter'] > 5 and r_ground.triggered == False:
+    #     own.applyForce([0,0,-200], True)                          
        
-    if deck.visible:
-        own['deckvis'] = 1
-    else:
-        own['deckvis'] = 0       
+    # if deck.visible:
+    #     own['deckvis'] = 1
+    # else:
+    #     own['deckvis'] = 0       
 
-    if own['requestAction'] == 'empty' or own['requestAction'] == None:
-        if STANCE == 0:
-            own['requestAction'] = 'reg_idle1'
-        if STANCE == 1:
-            own['requestAction'] = 'fak_idle1'        
+    # if own['requestAction'] == 'empty' or own['requestAction'] == None:
+    #     if STANCE == 0:
+    #         own['requestAction'] = 'reg_idle1'
+    #     if STANCE == 1:
+    #         own['requestAction'] = 'fak_idle1'        
         
-    def onground():
-        if r_ground.positive:
-            own['lF_ground_frame'] = own['framenum']
-            if 'grind' in r_ground.hitObject:
-                if own['framenum'] - own['last_fall_frame'] < 90:
-                    #own.applyForce([0,100,0], True)
-                    pass
-                    #print('moving away from rail')
+    # def onground():
+    #     if r_ground.positive:
+    #         own['lF_ground_frame'] = own['framenum']
+    #         if 'grind' in r_ground.hitObject:
+    #             if own['framenum'] - own['last_fall_frame'] < 90:
+    #                 #own.applyForce([0,100,0], True)
+    #                 pass
+    #                 #print('moving away from rail')
                     
-            yvel = own.linearVelocity.y
-            yvel = yvel *.1
-            if own.linearVelocity.y > .01 or own.linearVelocity.y < -.01 and own['stair_counter'] == 0:
-                if STANCE == 0:
-                    own.applyRotation([0,0,-yvel], True) 
-                else:
-                    own.applyRotation([0,0,yvel], True) 
-            else:
-                own.linearVelocity.y = 0                           
+    #         yvel = own.linearVelocity.y
+    #         yvel = yvel *.1
+    #         if own.linearVelocity.y > .01 or own.linearVelocity.y < -.01 and own['stair_counter'] == 0:
+    #             if STANCE == 0:
+    #                 own.applyRotation([0,0,-yvel], True) 
+    #             else:
+    #                 own.applyRotation([0,0,yvel], True) 
+    #         else:
+    #             own.linearVelocity.y = 0                           
 
-        else:
-            #print('in air')            
-            if  own['framenum'] - own['lF_ground_frame'] > 10:
-                if STANCE == 0:            
-                    own['requestAction'] = 'reg_walk_air'
-                else:
-                    own['requestAction'] = 'fak_walk_air' 
-        #if control bottom is touching ground object, turn ground on            
-        if cb.positive:
-            if own['framenum'] - own['last_fall_frame'] < 90:
-                own['lF_ground_frame'] = own['framenum']
+    #     else:
+    #         #print('in air')            
+    #         if  own['framenum'] - own['lF_ground_frame'] > 10:
+    #             if STANCE == 0:            
+    #                 own['requestAction'] = 'reg_walk_air'
+    #             else:
+    #                 own['requestAction'] = 'fak_walk_air' 
+    #     #if control bottom is touching ground object, turn ground on            
+    #     if cb.positive:
+    #         if own['framenum'] - own['last_fall_frame'] < 90:
+    #             own['lF_ground_frame'] = own['framenum']
                 
                 
 
-    def get_in_car():
-        vehicleNear = cont.sensors["vehicleNear"]
-        #print('vh', vehicleNear.positive)
-        scene = bge.logic.getCurrentScene()
-        cam = scene.active_camera
-        #dict = bge.logic.globalDict 
-        if vehicleNear.positive and 'car' in vehicleNear.hitObject:
-            obj = vehicleNear.hitObject
-            if yBut == True:
-                obj['driving'] = True
-                own['driving'] = True
-                cube.suspendDynamics(True)
-                cube.worldPosition = obj.worldPosition
-                cube.worldOrientation = obj.worldOrientation
-                rot = [ 0.0, 0.0, 1.570796327]
-                cube.applyRotation(rot,False)            
-                compound = False
+    # def get_in_car():
+    #     vehicleNear = cont.sensors["vehicleNear"]
+    #     #print('vh', vehicleNear.positive)
+    #     scene = bge.logic.getCurrentScene()
+    #     cam = scene.active_camera
+    #     #dict = bge.logic.globalDict 
+    #     if vehicleNear.positive and 'car' in vehicleNear.hitObject:
+    #         obj = vehicleNear.hitObject
+    #         if yBut == True:
+    #             obj['driving'] = True
+    #             own['driving'] = True
+    #             cube.suspendDynamics(True)
+    #             cube.worldPosition = obj.worldPosition
+    #             cube.worldOrientation = obj.worldOrientation
+    #             rot = [ 0.0, 0.0, 1.570796327]
+    #             cube.applyRotation(rot,False)            
+    #             compound = False
 
-                # child is solid
-                ghost = True
+    #             # child is solid
+    #             ghost = True
 
-                # set parent
-                cube.setParent( obj, compound, ghost)            
+    #             # set parent
+    #             cube.setParent( obj, compound, ghost)            
                 
                 
 
-                #cam.target = obj
-                #cam.state = 2
-                cont.actuators['Camera'].object = obj
-                cont.actuators['Camera'].height = 3
-                cont.actuators['Camera'].min = 6
-                cont.actuators['Camera'].max = 10
-                own.state = 2
-            #print('near car')
+    #             #cam.target = obj
+    #             #cam.state = 2
+    #             cont.actuators['Camera'].object = obj
+    #             cont.actuators['Camera'].height = 3
+    #             cont.actuators['Camera'].min = 6
+    #             cont.actuators['Camera'].max = 10
+    #             own.state = 2
+    #         #print('near car')
             
-        if dict['last_driving'] == True:
-            cont.actuators['Camera'].object = scene.objects['camCube']    
-            cont.activate(cont.actuators['walk'])               
-        if own['driving'] == False:  
-            #cont.actuators['Camera'].object = scene.objects['camCube'] 
-            #cont.activate(cont.actuators['walk']) 
-            dict['last_driving'] = False
+    #     if dict['last_driving'] == True:
+    #         cont.actuators['Camera'].object = scene.objects['camCube']    
+    #         cont.activate(cont.actuators['walk'])               
+    #     if own['driving'] == False:  
+    #         #cont.actuators['Camera'].object = scene.objects['camCube'] 
+    #         #cont.activate(cont.actuators['walk']) 
+    #         dict['last_driving'] = False
             
-    def get_on_bike(dict, own):
-        #bikeCol = cont.sensors['bikeCol']
-        vehicleNear = cont.sensors["vehicleNear"]
-        #print('vh', vehicleNear.positive)
-        scene = bge.logic.getCurrentScene()
-        #cam = scene.active_camera
-        #dict = bge.logic.globalDict 
-        try:
-            if vehicleNear.positive and 'bike' in vehicleNear.hitObject:          
-                if yBut == True and dict['last_yBut'] == False and own['throw_deck'] == True:
-                    vehicleNear.hitObject.endObject()
-                    dict['bike'] = True 
-                    cont.activate(own.actuators['bike_state']) 
+    # def get_on_bike(dict, own):
+    #     #bikeCol = cont.sensors['bikeCol']
+    #     vehicleNear = cont.sensors["vehicleNear"]
+    #     #print('vh', vehicleNear.positive)
+    #     scene = bge.logic.getCurrentScene()
+    #     #cam = scene.active_camera
+    #     #dict = bge.logic.globalDict 
+    #     try:
+    #         if vehicleNear.positive and 'bike' in vehicleNear.hitObject:          
+    #             if yBut == True and dict['last_yBut'] == False and own['throw_deck'] == True:
+    #                 vehicleNear.hitObject.endObject()
+    #                 dict['bike'] = True 
+    #                 cont.activate(own.actuators['bike_state']) 
 
-                    object = "player_bike"
-                    # instantly add bullet
-                    newbike = scene.addObject(object, own, 0)
-                    #bike.localScale = 4.6            
-                    newbike.setParent(cube, False, False)
-                    #rot = [ 0.0, 0.0, 1.570796327]
-                    #bike.applyRotation(rot,False) 
-        except:
-            pass            
+    #                 object = "player_bike"
+    #                 # instantly add bullet
+    #                 newbike = scene.addObject(object, own, 0)
+    #                 #bike.localScale = 4.6            
+    #                 newbike.setParent(cube, False, False)
+    #                 #rot = [ 0.0, 0.0, 1.570796327]
+    #                 #bike.applyRotation(rot,False) 
+    #     except:
+    #         pass            
                                                   
-    if dict['driving_reset'] == True:
-        scene.resume()
-        cube.suspendDynamics(False)
-        cont.actuators['Camera'].object = camobj2
-        cont.activate(own.actuators['walk'])
-        #dict['driving_reset'] = False
-        #print('reseting driving')   
-    if own['walk_jump_timer'] != 0:
-        own['walk_jump_timer'] = own['walk_jump_timer'] - 1    
-    wts = own['walk_targ_speed'] +1                 
-    if own['requestAction'] == 'reg_walkFast' and own.linearVelocity.x > (wts * -1):
-        own['requestAction'] = 'reg_walk' 
-    if own['requestAction'] == 'fak_walkFast' and own.linearVelocity.x < wts:
-        own['requestAction'] = 'fak_walk' 
-    if own['requestAction'] == 'reg_walkFast_nb' and own.linearVelocity.x > (wts * -1):
-        own['requestAction'] = 'reg_walk_nb' 
-    if own['requestAction'] == 'fak_walkFast_nb' and own.linearVelocity.x < wts:
-        own['requestAction'] = 'fak_walk_nb'   
+    # if dict['driving_reset'] == True:
+    #     scene.resume()
+    #     cube.suspendDynamics(False)
+    #     cont.actuators['Camera'].object = camobj2
+    #     cont.activate(own.actuators['walk'])
+    #     #dict['driving_reset'] = False
+    #     #print('reseting driving')   
+    # if own['walk_jump_timer'] != 0:
+    #     own['walk_jump_timer'] = own['walk_jump_timer'] - 1    
+    # wts = own['walk_targ_speed'] +1                 
+    # if own['requestAction'] == 'reg_walkFast' and own.linearVelocity.x > (wts * -1):
+    #     own['requestAction'] = 'reg_walk' 
+    # if own['requestAction'] == 'fak_walkFast' and own.linearVelocity.x < wts:
+    #     own['requestAction'] = 'fak_walk' 
+    # if own['requestAction'] == 'reg_walkFast_nb' and own.linearVelocity.x > (wts * -1):
+    #     own['requestAction'] = 'reg_walk_nb' 
+    # if own['requestAction'] == 'fak_walkFast_nb' and own.linearVelocity.x < wts:
+    #     own['requestAction'] = 'fak_walk_nb'   
 
 
-    if r_ground.triggered:
-        #force2 = [0.0, 0, dict['antibounce']]
-        #own.applyForce(force2, True)
+    # if r_ground.triggered:
+    #     #force2 = [0.0, 0, dict['antibounce']]
+    #     #own.applyForce(force2, True)
 
-        gdist = ((own.worldPosition.z - r_ground.hitPosition[2]))  
-        #print(gdist)
-        if gdist < .28 and gdist > .1:
-            #move = 2.875 - gdist
-            move = (.28 - gdist)*.5
-            #move = (own.worldPosition.z + gdist)
-            if move > 0:
-                own.worldPosition.z = own.worldPosition.z + move
-            else:
-                own.worldPosition.z = own.worldPosition.z - move    
-            own.linearVelocity.z = 0        
+    #     gdist = ((own.worldPosition.z - r_ground.hitPosition[2]))  
+    #     #print(gdist)
+    #     if gdist < .28 and gdist > .1:
+    #         #move = 2.875 - gdist
+    #         move = (.28 - gdist)*.5
+    #         #move = (own.worldPosition.z + gdist)
+    #         if move > 0:
+    #             own.worldPosition.z = own.worldPosition.z + move
+    #         else:
+    #             own.worldPosition.z = own.worldPosition.z - move    
+    #         own.linearVelocity.z = 0        
 
     
-    jump()
-    #dropin()
-    throwdeck_trigger()
+    # jump()
+    # #dropin()
+    # throwdeck_trigger()
 
-    nextframe()
-    checkidle()
+    # nextframe()
+    # checkidle()
     
-    reset_pos()
-    switchcam()
-    move_flycam()
-    move_followcam()
-    fall()
-    idle_anim()
-    sit()
-    onground()
-    getonboard(dict, cont)
-    onboard() 
-    focus_deck()
-    get_in_car()
-    get_on_bike(dict, own)
+    # reset_pos()
+    # #switchcam()
+    # #move_flycam()
+    # #move_followcam()
+    # fall()
+    # idle_anim()
+    # sit()
+    # onground()
+    # getonboard(dict, cont)
+    # onboard() 
+    # focus_deck()
+    # get_in_car()
+    # get_on_bike(dict, own)
 
-    #printplaying() 
+    # #printplaying() 
 
-    own.alignAxisToVect([0.0,0.0,1.0], 2, .03)
-    #own.actuators["sroll"].stopSound() 
-    camobj['sndmgr'].stop_sound(['roll'])
-    wheel1 = scene.objects["wheel1"]
-    wheel2 = scene.objects["wheel2"]
-    wheel3 = scene.objects["wheel3"]
-    wheel4 = scene.objects["wheel4"]
-    wheel1.stopAction(2)
-    wheel2.stopAction(2)
-    wheel3.stopAction(2)
-    wheel4.stopAction(2)
-    own['lasty'] = yBut
-    own['lastb'] = bBut  
-    own['lasta'] = aBut
-    own['lastx'] = xBut   
-    own['lastlts'] = ltsBut
-    own['lastrts'] = rtsBut        
-    own['lastbkBut'] = bkBut
-    own['dropinCol'] = dropinCol
-    own['walk'] = 1
-    dict['walk'] = 1
-        
+    # own.alignAxisToVect([0.0,0.0,1.0], 2, .03)
+    # #own.actuators["sroll"].stopSound() 
+    # camobj['sndmgr'].stop_sound(['roll'])
+    # wheel1 = scene.objects["wheel1"]
+    # wheel2 = scene.objects["wheel2"]
+    # wheel3 = scene.objects["wheel3"]
+    # wheel4 = scene.objects["wheel4"]
+    # wheel1.stopAction(2)
+    # wheel2.stopAction(2)
+    # wheel3.stopAction(2)
+    # wheel4.stopAction(2)
+    # own['lasty'] = yBut
+    # own['lastb'] = bBut  
+    # own['lasta'] = aBut
+    # own['lastx'] = xBut   
+    # own['lastlts'] = ltsBut
+    # own['lastrts'] = rtsBut        
+    # own['lastbkBut'] = bkBut
+    # own['dropinCol'] = dropinCol
+    # own['walk'] = 1
+    # dict['walk'] = 1
+    #     

shuvit.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:509fc1002b193babf9301e78c96b23ab02e9c56f3fba19739b5e4ec4982beda1
-size 117092972
+oid sha256:990b6a53606aad8b319016525a494c1d4b0188e41fa6619000ad8a44f891dd6a
+size 126713928

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