after the freeze

Settings.py

     dict['shadow_on'] = int(data[48])
     dict['ambient_strength'] = float(data[49]) 
     dict['fullscreen_on'] = int(data[51]) 
-    dict['bloom_on'] = int(data[53])        
+    dict['bloom_on'] = int(data[53]) 
+    dict['cam_height'] = float(data[55]) 
+    dict['focal_length'] = int(data[56])        
     
     
     
         writing.write(str("//fullscreen on (0,1)")+"\n")
         writing.write(str(dict["fullscreen_on"])+"\n") 
         writing.write(str("//bloom on (0,1)")+"\n")
-        writing.write(str(dict["bloom_on"])+"\n")         
+        writing.write(str(dict["bloom_on"])+"\n")  
+        writing.write(str("//cam")+"\n")
+        writing.write(str(dict["cam_height"])+"\n") 
+        writing.write(str(dict["focal_length"])+"\n")                 
         
         
         

Startup.py

     dict['kb_la'] = 0
     dict['kb_ra'] = 0
     dict['kb_ua'] = 0
-    dict['kb_da'] = 0    
+    dict['kb_da'] = 0 
+    dict['kb_lsh'] = 0
+    dict['kb_space'] = 0    
     
     dict['aBut'] = 0.0
     dict['bBut'] = 0.0

co_ActionState.py

         own['requestAction'] = 'empty'              
 #================
     #stance change detection
-    if (requestAction == 'reg_roll' and l_actionState in ('fak_roll', 'fak_land', 'fak_pump_out', 'fak_nopos_out', 'fak_opos_out')) or l_actionState == 'fak_land' and (requestAction == 'reg_turnLeft' or requestAction == 'reg_turnRight' or requestAction == 'reg_turnLeft_out' or requestAction == 'reg_turnRight_out' or requestAction == 'reg_opos' or requestAction == 'reg_nopos' or requestAction == 'reg_pump' or requestAction == 'reg_push' or requestAction == 'reg_push_goof' or requestAction == 'fak_5050-roll') and requestAction not in ['reg_push', 'reg_push_goof', 'fak_push', 'fak_push_goof'] or (requestAction in ('reg_turnLeft', 'reg_turnRight') and l_actionState in ('fak_turnLeft', 'fak_turnRight')):
+    if (requestAction == 'reg_roll' and l_actionState in ('fak_roll', 'fak_land', 'fak_pump_out', 'fak_nopos_out', 'fak_opos_out', 'fak_air-roll')) or l_actionState == 'fak_land' and (requestAction == 'reg_turnLeft' or requestAction == 'reg_turnRight' or requestAction == 'reg_turnLeft_out' or requestAction == 'reg_turnRight_out' or requestAction == 'reg_opos' or requestAction == 'reg_nopos' or requestAction == 'reg_pump' or requestAction == 'reg_push' or requestAction == 'reg_push_goof' or requestAction == 'fak_5050-roll') and requestAction not in ['reg_push', 'reg_push_goof', 'fak_push', 'fak_push_goof'] or (requestAction in ('reg_turnLeft', 'reg_turnRight') and l_actionState in ('fak_turnLeft', 'fak_turnRight')):
         #print("fak-reg_roll")
         requestAction = 'fak-reg_roll'
         own['requestAction'] = 'fak-reg_roll' 
-    if (requestAction == 'fak_roll' and l_actionState in ('reg_roll', 'reg_land', 'reg_pump_out', 'reg_nopos_out', 'reg_opos_out')) or l_actionState == 'reg_land' and (requestAction == 'fak_turnLeft' or requestAction == 'fak_turnRight' or requestAction == 'fak_turnLeft_out' or requestAction == 'fak_turnRight_out' or requestAction == 'fak_opos' or requestAction == 'fak_nopos' or requestAction == 'fak_pump' or requestAction == 'fak_push' or requestAction == 'reg_push_goof' or requestAction == 'reg_5050-roll') and requestAction not in ['reg_push', 'reg_push_goof', 'fak_push', 'fak_push_goof'] or (requestAction in ('fak_turnLeft', 'fak_turnRight') and l_actionState in ('reg_turnLeft', 'reg_turnRight')):
+    if (requestAction == 'fak_roll' and l_actionState in ('reg_roll', 'reg_land', 'reg_pump_out', 'reg_nopos_out', 'reg_opos_out', 'reg_air-roll')) or l_actionState == 'reg_land' and (requestAction == 'fak_turnLeft' or requestAction == 'fak_turnRight' or requestAction == 'fak_turnLeft_out' or requestAction == 'fak_turnRight_out' or requestAction == 'fak_opos' or requestAction == 'fak_nopos' or requestAction == 'fak_pump' or requestAction == 'fak_push' or requestAction == 'reg_push_goof' or requestAction == 'reg_5050-roll') and requestAction not in ['reg_push', 'reg_push_goof', 'fak_push', 'fak_push_goof'] or (requestAction in ('fak_turnLeft', 'fak_turnRight') and l_actionState in ('reg_turnLeft', 'reg_turnRight')):
         #print("reg-fak_roll")
         requestAction = 'reg-fak_roll'
         own['requestAction'] = 'reg-fak_roll'
             actionState = requestAction
             own['actionTimer'] = 0
             actionTimer = 0 
+            
+    if requestAction == 'reg_land' and l_actionState == 'reg_back_invert_out' and actionTimer > 0:
+        requestAction = 'reg_back_invert_out' 
+    if requestAction == 'fak_land' and l_actionState == 'fak_fr_invert_out' and actionTimer > 0:
+        requestAction = 'fak_fr_invert_out'                
+        
     #print(own['manual_v2_timer'], 'man_timer###@!')                   
 #    if (own['l_requestAction'] == 'reg_air_nose' or own['l_requestAction'] == 'reg_air_tail' or own['l_requestAction'] == 'fak_air_nose' or own['l_requestAction'] == 'fak_air_tail') and (requestAction == 'reg_land' or requestAction == 'fak_land') and own['manual_v2_timer'] > 2:
 #    #if (requestAction == 'reg_land' or requestAction == 'fak_land') and own['manual_v2_timer'] > 2:
             requestAction = 'reg-fak_roll'             
                                              
                                              
-        if l_actionState in ('reg_noseslide_out', 'regtailslide_out') and requestAction == ' fak_roll':
-            requestAction = 'reg-fak_roll'
-        if l_actionState in ('fak_noseslide_out', 'faktailslide_out') and requestAction == ' reg_roll':
-            requestAction = 'fak-reg_roll'     
+#        if l_actionState in ('reg_noseslide_out', 'reg_tailslide_out', 'reg_air-roll') and requestAction == 'fak_roll':
+#            requestAction = 'reg-fak_roll'
+#            print('this is new ______________________')
+#        if l_actionState in ('fak_noseslide_out', 'fak_tailslide_out', 'fak_air-roll') and requestAction == 'reg_roll':
+#            requestAction = 'fak-reg_roll'
+#            print('this is new ______________________')   
+            
+        if l_actionState == 'reg_back_invert_out' and requestAction == 'fak_roll' and actionTimer < 1:
+            requestAction = 'reg_air-roll'              
+            
+            
             
             
 #        if (l_actionState == 'fak_air-roll' and requestAction == 'fak_manual'):
             #reg_jump
             if requestAction == 'reg_jump':
                 actionState = 'reg_jump'
-                own['actionTimer'] = 9                
+                own['actionTimer'] = 19                
                 skater.playAction("reg_jump", 1,10, layer=trans_layer, play_mode=0, speed=.5)
                 deck.playAction("a_reg_jump2", 1,10, layer=trans_layer, play_mode=0, speed=.5)
                 trucks.playAction("a_reg_jump2", 1,10, layer=trans_layer, play_mode=0, speed=.5)
             #fak_jump    
             if requestAction == 'fak_jump':
                 actionState = 'fak_jump'
-                own['actionTimer'] = 9                
+                own['actionTimer'] = 19                
                 skater.playAction("fak_jump", 1,10, layer=trans_layer, play_mode=0, speed=.5)
                 trucks.playAction("a_fak_jump", 1,10, layer=trans_layer, play_mode=0, speed=.5)
                 deck.playAction("a_fak_jump", 1,10, layer=trans_layer, play_mode=0, speed=.5)
                 trucks.playAction("a_reg", 30,40, layer=trans_layer, play_mode=0, speed=.5) 
                      
             if requestAction == 'reg_back_invert_out':
-                own['actionTimer'] = 60
+                own['actionTimer'] = 30
                 actionState = 'reg_back_invert_out'
                 skater.playAction("reg_back_invert_in", 30,1, layer=trans_layer, play_mode=0, speed=1)
                 deck.playAction("a_reg_back_invert_in", 30,1, layer=trans_layer, play_mode=0, speed=1)
                 trucks.playAction("a_reg_back_invert_in", 30,1, layer=trans_layer, play_mode=0, speed=1)            
             if requestAction == 'fak_fr_invert_out':  
-                own['actionTimer'] = 60
+                own['actionTimer'] = 30
                 actionState = 'fak_fr_invert_out'
                 skater.playAction("fak_fr_invert", 30,1, layer=trans_layer, play_mode=0, speed=1)
                 deck.playAction("a_fak_fr_invert", 30,1, layer=trans_layer, play_mode=0, speed=1)
             if requestAction == 'reg_judo':
                 actionState = 'reg_judo'
                 if l_actionState != 'reg_judo':
-                    skater.playAction("reg_judo", 1,10, layer=trans_layer, play_mode=0, speed=1)
-                    deck.playAction("a_reg", 1,10, layer=trans_layer, play_mode=0, speed=1)
-                    trucks.playAction("a_reg", 1,10, layer=trans_layer, play_mode=0, speed=1)    
+                    skater.playAction("reg_judo", 1,10, layer=trans_layer, play_mode=0, speed=.5)
+                    deck.playAction("a_reg", 1,10, layer=trans_layer, play_mode=0, speed=.5)
+                    trucks.playAction("a_reg", 1,10, layer=trans_layer, play_mode=0, speed=.5)    
                 else:
                     skater.playAction("reg_judo", 10,30, layer=loop_layer, play_mode=1, speed=1)
                     deck.playAction("a_reg", 10,30, layer=loop_layer, play_mode=1, speed=1)
             if requestAction == 'fak_judo':
                 actionState = 'fak_judo'
                 if l_actionState != 'fak_judo':
-                    skater.playAction("fak_judo", 1,10, layer=trans_layer, play_mode=0, speed=1)
-                    deck.playAction("a_reg", 1,10, layer=trans_layer, play_mode=0, speed=1)
-                    trucks.playAction("a_reg", 1,10, layer=trans_layer, play_mode=0, speed=1)    
+                    skater.playAction("fak_judo", 1,10, layer=trans_layer, play_mode=0, speed=.5)
+                    deck.playAction("a_reg", 1,10, layer=trans_layer, play_mode=0, speed=.5)
+                    trucks.playAction("a_reg", 1,10, layer=trans_layer, play_mode=0, speed=.5)    
                 else:
                     skater.playAction("fak_judo", 10,30, layer=loop_layer, play_mode=1, speed=1)
                     deck.playAction("a_reg", 10,30, layer=loop_layer, play_mode=1, speed=1)
 #        own['actionTimer'] = 0
                   
     if (own['actionTimer'] == 0 or requestAction == 'reg_land' or requestAction == 'fak_land') or requestAction in jump_overrideList:
+        
         actionState = updateAction(requestAction, actionState)
         
 #    if (own['actionState'] == 'reg_land' or own['actionState'] == 'reg_land') and own['actionTimer'] > 0:
         cur_frame = skater.getActionFrame(trans_layer)  
         cur_frame = round(cur_frame, 2)     
     #print("oG: ", og_request, "rA:", requestAction, "|aS:", own['actionState'], "q", queueAction, own['actionTimer'], 'cf', cur_frame)
+    print("rA:", requestAction, "|aS:", own['actionState'], own['actionTimer'], 'cf', cur_frame)
     cur_frame = skater.getActionFrame(trans_layer)
     #print(cur_frame)
     def printplaying():

controller2.py

     def wallhit():
         linvelx = linVelocity.x
         lastx = own["linvelx"]
-        if frames_since_ground > 20 and (abs(lastx) - abs(linvelx)) > .5:
-            #print('::::::wallhit')
-            force = (linVelocity.x * -.7, linVelocity.y, linVelocity.z )                    
+        wallsens = cont.sensors['wall']
+        #print(wallsens.positive, 'wallsens')
+        if frames_since_ground > 20 and (abs(lastx) - abs(linvelx)) > .5 and wallsens.positive:
+            print('::::::wallhit')
+            velx = linVelocity.x * -1.5
+            if velx > 0 and velx < 1:
+                velx = 1
+            if velx < 0 and velx > -1:
+                velx = -1    
+            force = (velx, linVelocity.y, linVelocity.z )                    
             own.setLinearVelocity(force, True)        
     
     def land_boost():
         linvelx = linVelocity.x
         lastx = own["linvelx"]
-        if frames_since_ground < 2 and (abs(lastx) - abs(linvelx)) > .5:
-            #print('**_____________land boost')
+        if frames_since_ground < 10 and (abs(lastx) - abs(linvelx)) > .5:
+            print('**_____________land boost')
             force = (lastx, linVelocity.y, linVelocity.z )                    
             own.setLinearVelocity(force, True)             
         
     air_mover()
     dropinRotate()    
     onboard()   
-    #wallhit() 
+    wallhit() 
     linvelx = own.getLinearVelocity(True)
     land_boost()
     own["linvelx"] = linvelx.x

inputs.py

     
     joy_con = dict['joy_con']  
     scenes = bge.logic.getSceneList()
-    
+        
 #hard controller mappings    
     lar_lts = 0
     uad_lts = 1
     reduction = 400000
     axisTh = 0.03   
     
+    
+    keyboard = G.keyboard.events
+    # KEY BINDINGS
+    kb_a = events.AKEY 
+    kb_d = events.DKEY 
+    kb_w = events.WKEY
+    kb_s = events.SKEY
+    kb_q = events.QKEY
+    kb_e = events.EKEY
+    kb_z = events.ZKEY
+    kb_c = events.CKEY      
+    kb_en = events.ENTERKEY   
+    kb_la = events.LEFTARROWKEY
+    kb_ra = events.RIGHTARROWKEY
+    kb_ua = events.UPARROWKEY
+    kb_da = events.DOWNARROWKEY
+    kb_lsh = events.LEFTSHIFTKEY
+    kb_space = events.SPACEKEY
+    #if keyboard[kb_a]:
+    #print(keyboard[kb_a])
+    
+    dict['last_kb_a'] = dict['kb_a']
+    dict['last_kb_d'] = dict['kb_d']
+    dict['last_kb_w'] = dict['kb_w']
+    dict['last_kb_s'] = dict['kb_s']
+    dict['last_kb_q'] = dict['kb_q']
+    dict['last_kb_e'] = dict['kb_e']
+    dict['last_kb_z'] = dict['kb_z']
+    dict['last_kb_c'] = dict['kb_c']  
+    dict['last_kb_en'] = dict['kb_en']  
+    dict['last_kb_la'] = dict['kb_la']
+    dict['last_kb_ra'] = dict['kb_ra']
+    dict['last_kb_ua'] = dict['kb_ua']
+    dict['last_kb_da'] = dict['kb_da'] 
+    dict['last_kb_lsh'] = dict['kb_lsh'] 
+    dict['last_kb_space'] = dict['kb_space']    
+    
+    dict['kb_a'] = keyboard[kb_a]
+    dict['kb_d'] = keyboard[kb_d]
+    dict['kb_w'] = keyboard[kb_w]
+    dict['kb_s'] = keyboard[kb_s]
+    dict['kb_q'] = keyboard[kb_q]
+    dict['kb_e'] = keyboard[kb_e]
+    dict['kb_z'] = keyboard[kb_z]
+    dict['kb_c'] = keyboard[kb_c]    
+    dict['kb_en'] = keyboard[kb_en]
+    dict['kb_la'] = keyboard[kb_la]
+    dict['kb_ra'] = keyboard[kb_ra]
+    dict['kb_ua'] = keyboard[kb_ua]
+    dict['kb_da'] = keyboard[kb_da] 
+    dict['kb_lsh'] = keyboard[kb_lsh]
+    dict['kb_space'] = keyboard[kb_space]      
+    
+    
     if not any(bge.logic.joysticks):
         #print("joystick not connnected")
         dict['joy_con'] = 0
         else: mTrig = 0
         #    
 
-        keyboard = G.keyboard.events
-        # KEY BINDINGS
-        kb_a = events.AKEY 
-        kb_d = events.DKEY 
-        kb_w = events.WKEY
-        kb_s = events.SKEY
-        kb_q = events.QKEY
-        kb_e = events.EKEY
-        kb_z = events.ZKEY
-        kb_c = events.CKEY      
-        kb_en = events.ENTERKEY   
-        kb_la = events.LEFTARROWKEY
-        kb_ra = events.RIGHTARROWKEY
-        kb_ua = events.UPARROWKEY
-        kb_da = events.DOWNARROWKEY
-        #if keyboard[kb_a]:
-        #print(keyboard[kb_a])
-        
-        dict['last_kb_a'] = dict['kb_a']
-        dict['last_kb_d'] = dict['kb_d']
-        dict['last_kb_w'] = dict['kb_w']
-        dict['last_kb_s'] = dict['kb_s']
-        dict['last_kb_q'] = dict['kb_q']
-        dict['last_kb_e'] = dict['kb_e']
-        dict['last_kb_z'] = dict['kb_z']
-        dict['last_kb_c'] = dict['kb_c']  
-        dict['last_kb_en'] = dict['kb_en']  
-        dict['last_kb_la'] = dict['kb_la']
-        dict['last_kb_ra'] = dict['kb_ra']
-        dict['last_kb_ua'] = dict['kb_ua']
-        dict['last_kb_da'] = dict['kb_da']    
-        
-        dict['kb_a'] = keyboard[kb_a]
-        dict['kb_d'] = keyboard[kb_d]
-        dict['kb_w'] = keyboard[kb_w]
-        dict['kb_s'] = keyboard[kb_s]
-        dict['kb_q'] = keyboard[kb_q]
-        dict['kb_e'] = keyboard[kb_e]
-        dict['kb_z'] = keyboard[kb_z]
-        dict['kb_c'] = keyboard[kb_c]    
-        dict['kb_en'] = keyboard[kb_en]
-        dict['kb_la'] = keyboard[kb_la]
-        dict['kb_ra'] = keyboard[kb_ra]
-        dict['kb_ua'] = keyboard[kb_ua]
-        dict['kb_da'] = keyboard[kb_da]        
+      
         
         
         dict['last_aBut'] = dict['aBut']

menuV3.py

         
         
         
+    if funct == 'cam height':
+        b = dict['cam_height']
+        if motion == 'inc':
+            b += .1
+        else:
+            b -= .1    
+        dict['cam_height'] = round(b,2)  
+        
+    if funct == 'focal length':
+        b = dict['focal_length']
+        if motion == 'inc':
+            b += 2
+        else:
+            b -= 2    
+        dict['focal_length'] = b                   
+        
+        
+        
+        
     #levels
     if funct == 'Demo Scene':
         if motion == 'inc':
         if dict['lv1_opt'] == 'level':
         #if opt == 'settings':
             dict['current_list'] = ['sun strength', 'ambient strength', 'sun rot x', 'sun rot y', 'shadow on']
+            
+    if dict['mlevel'] == 2:
+        if dict['lv1_opt'] == 'camera':
+        #if opt == 'settings':
+            dict['current_list'] = ['cam height', 'focal length', 'min dist', 'max dist']            
+            
 
     if dict['mlevel'] == 3:
         if dict['lv2_opt'] == 'ao':
             dict['current_list'] = ['bloom on']                
 
 def get_inputs(dict, cont):
+    import aud
+    obj = cont.owner
     #opt = dict['current_list'][dict['current_index']]
     #b
+    
+    obj['sound'] = aud.Factory(bge.logic.expandPath('//sounds/select.wav'))
+    obj['sound_a'] = aud.Factory(bge.logic.expandPath('//sounds/a.wav'))
+    obj['sound_b'] = aud.Factory(bge.logic.expandPath('//sounds/b.wav')) 
+    
     if keyboard.events[bge.events.LEFTARROWKEY] == JUST_ACTIVATED or (dict['bBut'] == False and dict['last_bBut'] == True):
+        
+        aud.device().play(obj['sound_b'])
         if dict['current_index'] not in dict['menu_end_points']:
             #print('lkey')
             if dict['mlevel'] == 2:
 #            endpoint(funct, motion, dict)                               
         #a
     if (keyboard.events[bge.events.RIGHTARROWKEY] == JUST_ACTIVATED) or (dict['aBut'] == False and dict['last_aBut'] == True):
+        aud.device().play(obj['sound_a'])
         if dict['current_opt'] not in dict['menu_end_points']:
             if dict['mlevel'] == 0: 
                 dict['lv0_opt'] = dict['current_list'][dict['current_index']]
             endpoint(funct, motion, dict, cont)                          
     #down     
     if keyboard.events[bge.events.DOWNARROWKEY] == JUST_ACTIVATED or (dict['ddPad'] == False and dict['last_ddPad'] == True):
+        aud.device().play(obj['sound'])
         if dict['current_index'] < (len(dict['current_list']) - 1):
             dict['current_index'] += 1  
             if dict['mlevel'] == 0:
                 dict['lv3_index'] = dict['current_index']                                                
     #up    
     if keyboard.events[bge.events.UPARROWKEY] == JUST_ACTIVATED or (dict['udPad'] == False and dict['last_udPad'] == True):
+        aud.device().play(obj['sound'])
         if dict['current_index'] > 0:
             dict['current_index'] -= 1  
             if dict['mlevel'] == 0:
                 
     #left
     if dict['ldPad'] == False and dict['last_ldPad'] == True:
+        aud.device().play(obj['sound_a'])
         if dict['current_opt'] in dict['menu_end_points']:
             funct = dict['current_opt']
             motion = 'dec'
     
     #right
     if dict['rdPad'] == False and dict['last_rdPad'] == True:
+        aud.device().play(obj['sound_b'])
         if dict['current_opt'] in dict['menu_end_points']:
             funct = dict['current_opt']
             motion = 'inc'
     dict['mlevel'] = 0
     dict['current_opt'] = ''
     dict['pause_menu_text'] = ''
-    dict['menu_end_points'] = ['exit', 'restart', 'shirt color r', 'shirt color g', 'shirt color b', 'shoe color r', 'shoe color g', 'shoe color b','deck color r', 'deck color g', 'deck color b', 'shirt logo', 'brightness / contrast on', 'brightness value', 'contrast value', 'hdr on', 'avgL', 'hdr strength', 'ao on', 'ao radius', 'ao width', 'ao only', 'dof on', 'sun strength', 'sun rot x', 'sun rot y', 'shadow on', 'ambient strength', 'Demo Scene', 'Empty Lot', 'Park A', 'Training', 'Spine', 'Warehouse', '1920x1080', '1280x720', '1024x768', '800x600', 'fullscreen', 'bloom on']
+    dict['menu_end_points'] = ['exit', 'restart', 'shirt color r', 'shirt color g', 'shirt color b', 'shoe color r', 'shoe color g', 'shoe color b','deck color r', 'deck color g', 'deck color b', 'shirt logo', 'brightness / contrast on', 'brightness value', 'contrast value', 'hdr on', 'avgL', 'hdr strength', 'ao on', 'ao radius', 'ao width', 'ao only', 'dof on', 'sun strength', 'sun rot x', 'sun rot y', 'shadow on', 'ambient strength', 'Demo Scene', 'Empty Lot', 'Park A', 'Training', 'Spine', 'Warehouse', '1920x1080', '1280x720', '1024x768', '800x600', 'fullscreen', 'bloom on', 'cam height', 'focal length', 'min dist', 'max dist']
     
 def output(dict):
     try:
         if dict['current_opt'] ==  'fullscreen':
             outp = outp + ': ' + str(dict['fullscreen_on'])  
         if dict['current_opt'] ==  'bloom on':
-            outp = outp + ': ' + str(dict['bloom_on'])                                                 
+            outp = outp + ': ' + str(dict['bloom_on'])  
+            
+        if dict['current_opt'] ==  'cam height':
+            outp = outp + ': ' + str(dict['cam_height']) 
+        if dict['current_opt'] ==  'focal length':
+            outp = outp + ': ' + str(dict['focal_length'])                                                                         
             
     dict['pause_menu_text'] = outp
 def main(cont):

walk.py

 
 control_bottom = scene.objects['control_bottom']
 cb = control_bottom.sensors['grindCol_bottom']
+cb_td = control_bottom.sensors['td_bottom']
 
 noidle = 0
 
 if lUD > sens:
     ldown = 1
 else:
-    ldown = 0    
+    ldown = 0 
+if lLR < -sens:
+    lLeft = 1
+else:
+    lLeft = 0
+if lLR > sens:
+    lRight = 1
+else:
+    lRight = 0        
     
 #walking
 
 if own['last_walk_frame'] - own['last_roll_frame'] > 55:
     wf = 0
    
-if (lup == 1 and aBut == 0 and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0) and wf == 0:    
+   
+if dict['kb_lsh'] == 2 and dict['kb_w'] == 2:   
+    print('wtf')   
+   
+if ((lup == 1 and aBut == 0) or (dict['kb_w'] == 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 and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0 and wf == 0:
+elif ((lup == 1 and aBut == 1) or (dict['kb_lsh'] == 2 and dict['kb_w'] == 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:
         #print("set 0 vel")    
     
 #old walking
-if (lup == 1 and aBut == 0 and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0):
+if (lup == 1 and aBut == 0) or (dict['kb_w'] == 2 and dict['kb_lsh'] == 0)  and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0:
     own.actuators["walkondirt"].volume = .2
     own.actuators["walkondirt"].pitch = 1
     cont.activate(own.actuators["walkondirt"])
         else:
             own['requestAction'] = 'fak_walk'
        
-elif lup == 1 and aBut == 1 and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0:
+elif ((lup == 1 and aBut == 1) or (dict['kb_lsh'] == 2 and dict['kb_w'] == 2)) and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0:
     own.actuators["walkondirt"].volume = .2
     own.actuators["walkondirt"].pitch = 1.3
     cont.activate(own.actuators["walkondirt"])
     vel = own.getLinearVelocity(True)
     cont.deactivate(own.actuators["walkondirt"])       
 
+#turning
+if lRight == 1 or dict['kb_d'] == 2:
+    cont.activate(own.actuators['right'])
+else:
+    cont.deactivate(own.actuators['right'])    
+    
+if lLeft == 1 or dict['kb_a'] == 2:
+    cont.activate(own.actuators['left'])    
+else:
+    cont.deactivate(own.actuators['left'])        
+
+
+
 #in air        
-if lup == 1 and r_ground.positive == False:
+if (lup == 1 or dict['kb_w'] != 0) and r_ground.positive == False:
     
     if stance == 0:
         cont.deactivate(own.actuators['forward'])
         killact(6)
         killact(7)        
         velx = linvel.x + 1
-        own.setLinearVelocity([1.5, linvel.y, linvel.z], 1)       
+        own.setLinearVelocity([1.5, linvel.y, linvel.z], 1)  
+        
+    own['lF_air_frame'] = own['framenum']         
 #---------------
 if rLR > .05:
     cont.activate(camobj.actuators['camRight'])
             trucks.stopAction(truckon)
             own['requestAction'] = 'fak_offboard'                          
 def jump():
-    if xBut == True:
+    if xBut == True or dict['kb_space'] == 1:
+    #if xBut == True:    
         if own['lastx'] == 0:
             killact(3)
             killact(4)
             killact(6)
             killact(7)      
             if STANCE == 0:  
-                own['requestAction'] ='reg_jump'   
+                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
         hard = strength * .08
         if hard > 9:
             hard = 9
+        if hard < 1:
+            hard = 1    
         ud = ud * 4
         own['bbut_timer'] = 0
         if STANCE == True:
     if bBut == False and own['lastb'] == True:        
         strength = own['bbut_timer']
         ud = (rUD * 10) +1
-        throwdeck(strength, ud)        
+        throwdeck(strength, ud)   
+        
+def focus_deck():
+    since_air = own['framenum'] - own['lF_air_frame']
+    if cb_td.positive and since_air < 10:
+        print('focus!!!!!')
+        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:
+            #focus  
+            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:
     if r_ground.positive:
         own['lF_ground_frame'] = own['framenum']
         if 'grind' in r_ground.hitObject:
-            if own['framenum'] - own['last_fall_frame'] < 60:
+            if own['framenum'] - own['last_fall_frame'] < 90:
                 own.applyForce([0,100,0], True)
-                print('moving away from rail')
+                #print('moving away from rail')
 
     else:
-        print('in air')    
+        #print('in air')    
         
         if  own['framenum'] - own['lF_ground_frame'] > 10:
             if STANCE == 0:            
 idle_anim()
 sit()
 onground()
+focus_deck()
 #printplaying() 
 
 own.alignAxisToVect([0.0,0.0,1.0], 2, .03)