making scripts external #90

.gitignore

@@ -38,4 +38,5 @@ Thumbs.db
 
 # User               #
 ######################
-.blend1
+.blend1
+shuvit_working.blend

config.ini

@@ -20,7 +20,7 @@ music_player = 1
 
 #level
 ######
-level = user1
+level = lot
 #------------
 
 #replay recorder

scripts/colors.py

@@ -1,46 +1,49 @@
 import bge
 from bge import texture
 
-dict = bge.logic.globalDict 
-scene = bge.logic.getCurrentScene()
-shirt = scene.objects["Char4:Zshirtt1"]
-deck = scene.objects["deck"]
-throw_deck = scene.objectsInactive["throw_deck"]
-throw_deck_trucks = scene.objectsInactive["throw_deck_trucks"]
-focus_deckA = scene.objectsInactive["focus_deckA"]
-focus_deckB = scene.objectsInactive["focus_deckB"]
-focus_deckA_trucks = scene.objectsInactive["focus_deckA_trucks"]
-focus_deckB_trucks = scene.objectsInactive["focus_deckB_trucks"]
-shoeR = scene.objects['Char4:Shoes02.R']
-shoeL = scene.objects['Char4:Shoes02.L']
-trucks = scene.objects['trucks']
-wheel1 = scene.objects['rollen.000']
-wheel2 = scene.objects['rollen.001']
-wheel3 = scene.objects['rollen.002']
-wheel4 = scene.objects['rollen.003']
-throw_deck_wheel1 = scene.objectsInactive["throw_deck_trucks_wheels"]
-throw_deck_wheel2 = scene.objectsInactive["throw_deck_trucks_wheels.001"]
-throw_deck_wheel3 = scene.objectsInactive["throw_deck_trucks_wheels.002"]
-throw_deck_wheel4 = scene.objectsInactive["throw_deck_trucks_wheels.003"]
-focus_deckA_wheel1 = scene.objectsInactive['focus_deckA_wheel1']
-focus_deckA_wheel2 = scene.objectsInactive['focus_deckA_wheel2']
-focus_deckB_wheel1 = scene.objectsInactive['focus_deckB_wheel1']
-focus_deckB_wheel2 = scene.objectsInactive['focus_deckB_wheel2']
 
-
-##
-white = [ .9, .9, .9, 1.0]
-yellow = [ 0.6, 0.33, 0, 1.0]
-grey = [ .5, .5, .5, 1.0]
-red = [ .2, 0, 0, 1]
-orange = [.47, .1, 0, 1]
-deckbrown = [.2, .075, .001, 1]
-lightblue = [.375, .6, 1, 1]
-## set colors
-shirtC = white
-deckC = red
-shoesC = grey
 def main():
+    
+    
+    dict = bge.logic.globalDict 
+    scene = bge.logic.getCurrentScene()
+    shirt = scene.objects["Char4:Zshirtt1"]
+    deck = scene.objects["deck"]
+    throw_deck = scene.objectsInactive["throw_deck"]
+    throw_deck_trucks = scene.objectsInactive["throw_deck_trucks"]
+    focus_deckA = scene.objectsInactive["focus_deckA"]
+    focus_deckB = scene.objectsInactive["focus_deckB"]
+    focus_deckA_trucks = scene.objectsInactive["focus_deckA_trucks"]
+    focus_deckB_trucks = scene.objectsInactive["focus_deckB_trucks"]
+    shoeR = scene.objects['Char4:Shoes02.R']
+    shoeL = scene.objects['Char4:Shoes02.L']
+    trucks = scene.objects['trucks']
+    wheel1 = scene.objects['rollen.000']
+    wheel2 = scene.objects['rollen.001']
+    wheel3 = scene.objects['rollen.002']
+    wheel4 = scene.objects['rollen.003']
+    throw_deck_wheel1 = scene.objectsInactive["throw_deck_trucks_wheels"]
+    throw_deck_wheel2 = scene.objectsInactive["throw_deck_trucks_wheels.001"]
+    throw_deck_wheel3 = scene.objectsInactive["throw_deck_trucks_wheels.002"]
+    throw_deck_wheel4 = scene.objectsInactive["throw_deck_trucks_wheels.003"]
+    focus_deckA_wheel1 = scene.objectsInactive['focus_deckA_wheel1']
+    focus_deckA_wheel2 = scene.objectsInactive['focus_deckA_wheel2']
+    focus_deckB_wheel1 = scene.objectsInactive['focus_deckB_wheel1']
+    focus_deckB_wheel2 = scene.objectsInactive['focus_deckB_wheel2']
+
+
+    ##
+    white = [ .9, .9, .9, 1.0]
+    yellow = [ 0.6, 0.33, 0, 1.0]
+    grey = [ .5, .5, .5, 1.0]
+    red = [ .2, 0, 0, 1]
+    orange = [.47, .1, 0, 1]
+    deckbrown = [.2, .075, .001, 1]
+    lightblue = [.375, .6, 1, 1]
+    ## set colors
+    shirtC = white
+    deckC = red
+    shoesC = grey    
 
     cont = bge.logic.getCurrentController()
     own = cont.owner

scripts/grindV2.py

@@ -718,4 +718,4 @@ def main():
     own['last_z'] = own.worldPosition.z
     own["manual"] = manual
 
-main()
+

scripts/joy_sens.py

@@ -0,0 +1,14 @@
+import bge
+
+def main():
+    dict = bge.logic.globalDict #Get the global dictionary
+    if bge.logic.joysticks[0] == None:
+        dict['joy_1'] = True
+    else:
+        dict['joy_1'] = False 
+    if bge.logic.joysticks[1] == None:
+        dict['joy_2'] = True
+    else:
+        dict['joy_2'] = False           
+
+main()

scripts/linkEmpty.blend

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d23a889cdc9c2ca661b49ccac257e3be73980f6c444f699db0149a3a5487ef60
+size 459492

scripts/logo_fades.py

@@ -0,0 +1,51 @@
+import bge
+import Settings
+
+def main():
+
+    cont = bge.logic.getCurrentController()
+    own = cont.owner
+    dict = bge.logic.globalDict
+    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()

scripts/stance.py

@@ -1,52 +1,28 @@
 import bge
 from bge import logic
-cont = bge.logic.getCurrentController()
-own = cont.owner
 
+def main(cont):
+    own = cont.owner
+    STANCE_SENS = 0.05
+    STANCE = own["stance"]
+    jumpstance = own['jump_stance']
+    grindpos = own['grindpos']
+    # use game object axis
+    local = True
+    try:
+        #stance detection   
+        if own['ground'] == True and (own['grindpos'] != 'reg_board' or own['grindOld'] == False) and own['invert_on'] == False:
+            #print("detect stance") 
+            LVX = own.localLinearVelocity.x
+            if LVX > STANCE_SENS:
+                STANCE = 1
+                
+            if LVX < (-STANCE_SENS):
+                STANCE = 0
+    except:
+        print("no stance")
 
-#scene = bge.logic.getCurrentScene()
-#control_bottom = scene.objects['control_bottom']
-#grindTouch = control_bottom.sensors['grindCol_bottom']
-#edge = 0
-#try:
-#    if 'edge' in grindTouch.hitObject:
-#        print('Edge')
-#        edge = 1
-#except:
-#    pass        
-
-#constants
-STANCE_SENS = 0.05
-STANCE = own["stance"]
-jumpstance = own['jump_stance']
-grindpos = own['grindpos']
-# use game object axis
-local = True
-try:
-    #stance detection   
-    if own['ground'] == True and (own['grindpos'] != 'reg_board' or own['grindOld'] == False) and own['invert_on'] == False:
-        #print("detect stance") 
-        LVX = own.localLinearVelocity.x
-        if LVX > STANCE_SENS:
-            STANCE = 1
-            
-        if LVX < (-STANCE_SENS):
-            STANCE = 0
-except:
-    print("no stance")
-#if jumpstance == 3:
-#    if own["grindOld"] == 0:
-#        own["stance"] = STANCE
-#else:
-#    if grindpos == "reg_5050":
-#        own["stance"] = STANCE
-#    else:
-#        STANCE = jumpstance
-own["stance"] = STANCE           
-dict = bge.logic.globalDict #Get the global dictionary
-dict['stance'] = STANCE #Store the new score
-#print(STANCE)
-#stance = dict.get('stance') #Get the current score or the number 0
-#print(LVX)    
-#print(STANCE)
+    own["stance"] = STANCE           
+    dict = bge.logic.globalDict #Get the global dictionary
+    dict['stance'] = STANCE #Store the new score
 

scripts/walk.py

@@ -7,1252 +7,1256 @@ import ctypes
 import random
 import math
 
-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
+def main(cont):
+    
+    scene = bge.logic.getCurrentScene()
+    objList = scene.objects
 
-try:
-    own['walk_timer'] = own['walk_timer'] +1
-except:
-    own['walk_timer'] = 1
-    own['walk_targ_speed'] = 2.0
+    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
 
-truckon = 450
-deckon = 460
+    try:
+        own['walk_timer'] = own['walk_timer'] +1
+    except:
+        own['walk_timer'] = 1
+        own['walk_targ_speed'] = 2.0
 
-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']
+    truckon = 450
+    deckon = 460
 
-#user
-sens = .04
-fliplay = 30
-dropinCol = own.sensors['dropinCol']
-cube = scene.objects['control_cube.002']
-skater = scene.objects["Char4"]
-deck = scene.objects["deck"]
-trucks = scene.objects["trucks"]
-camobj2 = scene.objects['camobj']
-throw_deck_empty = scene.objects["throw_deck_empty"]
-wheel1 = scene.objects["rollen.000"]
-wheel2 = scene.objects["rollen.001"]
-wheel3 = scene.objects["rollen.002"]
-wheel4 = scene.objects["rollen.003"]
-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"]
+    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']
 
-control_bottom = scene.objects['control_bottom']
-cb = control_bottom.sensors['grindCol_bottom']
-cb_td = control_bottom.sensors['td_bottom']
+    #user
+    sens = .04
+    fliplay = 30
+    dropinCol = own.sensors['dropinCol']
+    cube = scene.objects['control_cube.002']
+    skater = scene.objects["Char4"]
+    deck = scene.objects["deck"]
+    trucks = scene.objects["trucks"]
+    camobj2 = scene.objects['camobj']
+    throw_deck_empty = scene.objects["throw_deck_empty"]
+    wheel1 = scene.objects["rollen.000"]
+    wheel2 = scene.objects["rollen.001"]
+    wheel3 = scene.objects["rollen.002"]
+    wheel4 = scene.objects["rollen.003"]
+    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"]
 
-noidle = 0
+    control_bottom = scene.objects['control_bottom']
+    cb = control_bottom.sensors['grindCol_bottom']
+    cb_td = control_bottom.sensors['td_bottom']
 
-#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
+    noidle = 0
 
-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 skater.isPlayingAction(460):  
+    #    noidle = 1  
 
-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'
+    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 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 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 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        
+    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'
 
+    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'
 
-#turning
-turning = False
-if r_ground.positive:
-    num = .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,.05], True)
-            else:
-                own.applyRotation([0,0,-.05], True)                
-        else:
-            own.applyRotation([-tilt, 0, 0], True)
-        turning = True
+    if lUD < -sens:
+        lup = 1
     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,.05], True)
-            else:
-                own.applyRotation([0,0,-.05], True)                                
-        else:        
-            own.applyRotation([tilt, 0, 0], True)        
-        turning = True
+        lup = 0
+    if lUD > sens:
+        ldown = 1
     else:
-        #cont.deactivate(own.actuators['left'])        
-        pass
+        ldown = 0 
+    if lLR < -sens:
+        lLeft = 1
+    else:
+        lLeft = 0
+    if lLR > sens:
+        lRight = 1
+    else:
+        lRight = 0        
 
-#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()
 
-    
-#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)
-    
-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"
-    
-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
+    #turning
+    turning = False
+    if r_ground.positive:
+        num = .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,.05], True)
+                else:
+                    own.applyRotation([0,0,-.05], True)                
+            else:
+                own.applyRotation([-tilt, 0, 0], True)
+            turning = True
         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      
+            #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,.05], True)
+                else:
+                    own.applyRotation([0,0,-.05], True)                                
+            else:        
+                own.applyRotation([tilt, 0, 0], True)        
+            turning = True
         else:
-            own.linearVelocity.x = -own['walk_fast_targ_speed'] 
+            #cont.deactivate(own.actuators['left'])        
+            pass
 
-if walking == None and r_ground.positive and own['walk_jump_timer'] == 0:      
-    if own['walk_timer'] < 50 and turning == False:
+    #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()
+
+        
+    #walking
+
+    #new walking
+    vel = own.getLinearVelocity(True)
+    if own['walk_timer'] < 50:
         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'
-               
-    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'
+        #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   
        
-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
-    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'
+    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
+       
+    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:
-            own['requestAction'] = 'reg_walkFast'
-         
-    if stance == 1 and skater.isPlayingAction(fliplay) == False:        
-        if own['throw_deck'] == True:
-            own['requestAction'] = 'fak_walkFast_nb'          
+            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:
-            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'])     
-                
-#----------------
-#camera.height = .01 #.9
-#camera.min = 1.75
-#camera.max = 2.25
-lasty = own['lasty']     
+            if linvel.x > -own['walk_fast_targ_speed']:
+                own.linearVelocity.x = linvel.x - walk_inc      
+            else:
+                own.linearVelocity.x = -own['walk_fast_targ_speed'] 
 
-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'])
-        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   
+    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) 
         
-        #camobj.worldPosition.z += 4              
-        try:
-            vel = own['offboard_vel']
-            vel = [velx, vel.y, vel.z]           
-        except: 
-            pass
-         
-        if STANCE == 0:
-            own['requestAction'] = 'reg_offboard'             
-            
-        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'] = 20
-        own['lastx'] = 1
+    #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'
+           
+    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
+        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:
-        own['lastx'] = 0
-def dropin():
-    if dropinCol.positive == True:
-        pass       
-        
-def getonboard(dict):
-    #print(dict['kb_q'])
-    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 
-        if dropinCol.positive == True: 
-            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 
+        vel = own.getLinearVelocity(True)
+        cont.deactivate(own.actuators["walkondirt"])       
 
-            if STANCE == 0: 
-                own['requestAction'] ='reg_dropin_pos' 
-                own['dropinTimer'] = 60                                     
+           
+    #---------------
+    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 STANCE == 1: 
-                own['requestAction'] ='fak_dropin_pos'  
-                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'] == 2) and dropinCol.positive:
+    #----------------
+    #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'])
+            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
+             
+            if STANCE == 0:
+                own['requestAction'] = 'reg_offboard'             
+                
+            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'] = 20
+            own['lastx'] = 1
+        else:
+            own['lastx'] = 0
+    def dropin():
+        if dropinCol.positive == True:
+            pass       
+            
+    def getonboard(dict):
+        #print(dict['kb_q'])
+        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 
+            if dropinCol.positive == True: 
+                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 
+
+                if STANCE == 0: 
+                    own['requestAction'] ='reg_dropin_pos' 
+                    own['dropinTimer'] = 60                                     
+                        
+                if STANCE == 1: 
+                    own['requestAction'] ='fak_dropin_pos'  
+                    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'] == 2) and dropinCol.positive:
+            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:               
+            own['getonboard'] = 1 
+            own['walk_idling'] = 0      
+
+    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
+            
+            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'
+                                                                               
+                    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 = (0, 0, .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"]
         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  
+        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']
+            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)
+        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']) 
-        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:               
-        own['getonboard'] = 1 
-        own['walk_idling'] = 0      
 
-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
-        
-        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
+    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['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'
-                                                                           
-                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 = (0, 0, .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"]
-    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']
-        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)
-    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"]
+            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)
-                
-    if own['throw_deck'] == True:
-        if dict['ldPad'] == False and dict['last_ldPad'] == True: 
+    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 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
+            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
 
-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 == False and lasta == True:
-        try:
-            if 'sit' in r_ground.hitObject:
-                #print("sit")
-                own['sit'] = 1
+        if aBut == False and lasta == True:
+            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['requestAction'] = 'reg_sit'
+                    own.alignAxisToVect(-sit_vect, 0, .2)
+                    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    
-                      
-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:
-                followcam.actuators["left"].dLoc = [-camspeed2, 0, 0]                
-                cont.activate(followcam.actuators["left"])
+                    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:
-                cont.deactivate(followcam.actuators["left"])                    
-#            #right
-            if lLR > 0.080:         
-                followcam.actuators["right"].dLoc = [camspeed2, 0, 0]                
-                cont.activate(followcam.actuators["right"])
+                own['camera'] = 1
+        if rtsBut == False and own['lastrts'] == True and ltsBut == False:
+            if own['camera'] == 2:
+                own['camera'] = 0
             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"]) 
+                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:
+                    followcam.actuators["left"].dLoc = [-camspeed2, 0, 0]                
+                    cont.activate(followcam.actuators["left"])
+                else:
+                    cont.deactivate(followcam.actuators["left"])                    
+    #            #right
+                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:
+                    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"])                    
 
-#*********************************************                
+    #walking on stairs
+    if r_ground.triggered:
+        try:
+            if 'stair' in r_ground.hitObject:
+                own['stair_counter'] = 20
                 
-            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"])                    
+        except:
+            pass        
+        if own['stair_counter'] > 0:
+            own.linearVelocity.z += .1
+            own['stair_counter'] -= 1     
 
-#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     
+    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 deck.visible:
+        own['deckvis'] = 1
+    else:
+        own['deckvis'] = 0       
 
-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 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)
+                    #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                           
 
-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:
+        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.applyForce([0,100,0], True)
-                #print('moving away from rail')
+                own['lF_ground_frame'] = own['framenum']
+                
                 
-        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: