shuvit/scripts/controller2.py

#shuvit.org

# control script
    

import bge
import GameLogic
import ctypes
import math 
from sys import platform   
from mathutils import Vector
    
def main():
    #scale = .3
    #action layers
    #0-14 rolling
    #fliplay = 500
    #grindlay = 700
#    os = 'Windows'
#    
#    if platform != "win32":
#     os = 'Linux'
#    def onWindows():
#     return os == 'Windows'
    


    scene = bge.logic.getCurrentScene()
    try:
        GameLogic.DictObjects
        init=1
    except:
        init=0
#    if init:
#        cont.GameLogic.getCurrentController()
#        own = cont.getOwner()
#        name = own.getName()
#        if not GameLogic.DictObjects.has_key(name):
#            GameLogic.DictObjects[name]=cont
#        own.init=0
    #reduction = 400000
    #axisTh = 0.03 

    #initialize quadrant variables
    q1on = 0
    q2on = 0
    q3on = 0
    q4on = 0
    q5on = 0
    q6on = 0
    q7on = 0
    q8on = 0
    lq1on = 0
    lq2on = 0
    lq3on = 0
    lq4on = 0
    lq5on = 0
    lq6on = 0
    lq7on = 0
    lq8on = 0

    #number of frames / length of the location timers
    countdown = 20


    cont = GameLogic.getCurrentController() 
    char = bge.constraints.getCharacter
    own = cont.owner
    dict = bge.logic.globalDict #Get the global dictionary
    #dict['trick_string'] = ''

    #last frame stuff
    lGRAB_ON = own["lGRAB_ON"]
    lastgrab = own["lastGrab"]
    lastpump = own["lastPump"]
    lf_ground = own["lF_ground"]
    lastopos = own["last_Opos"]
    lastnopos = own["last_nOpos"]
    LAST_STANCE = own["last_stance"]
    LAST_GROUND = own["last_ground"]
    lastStop = own["lastStop"]
    LAST_LEFT = own["LAST_LEFT"]
    last_trick_string = dict.get('last_trick_sting')
    lasta = own["lasta"]
    lastx = own["lastx"]
    lastaf = own["lastaf"]
    lastxf = own["lastxf"]
    lgf = own['last_grind_frame']
    frame = own['framenum']
    frames_since_grinding = frame - lgf
    ground_since = own["framenum"] - own['lF_air_frame']
    gsf = frame - own['grind_start_frame']
    own['last_footplant'] = own['footplant_on']
    lastaBut_ground = own['lastaBut_ground'] 
    lastxBut_ground = own['lastxBut_ground'] 
    aBut_ground = own['aBut_ground']
    xBut_ground = own['xBut_ground']
    own['last_manual_v2'] = own['manual_v2']
    lRequest = own['requestAction']
    lAs = own['actionState']


    #current frame stuff
    GRAB_ON = own["GRAB_ON"]
    pumpon = own["Pump"]
    vib_countdown = own["vib_Countdown"]
    grindold = own['grindOld']
    #grindHit = own["LAST_GRIND"]
    LAST_GRIND = own["LAST_GRIND"]
    #grindTouch = cont.sensors['grindCol']
    grindTouch = cont.sensors['grindCol_bottom']
    touched = grindTouch.triggered
    leftgrabon = own["Leftgrabon"]
    rightgrabon = own["Rightgrabon"]
    linvel = own.getLinearVelocity
    zvel = own.worldLinearVelocity.z
    own["Zvel"] = zvel
    r_ground = cont.sensors["r_Ground"]
    trigger = r_ground.triggered
    STANCE = own["stance"]
    motion = cont.actuators['MotionPump']
    linVelocity = own.getLinearVelocity(True)
    countdown = own['countdown']
    jump_timer = own['jump_timer']
    pos = own.localPosition
    rot = own.getAxisVect( [0.0, 0.0, 1.0])
    gray = cont.sensors["gRay"]
    #airconst = cont.actuators["airConst"]
    pop = cont.actuators["pop"]
    grindHit = own["grindHit"]
    grindCement = cont.actuators["grind_cement"]
    grindRail = cont.actuators["grind_rail"]
    grindSound = own["grindSound"]
    skater = scene.objects["Char4"]
    deck = scene.objects["deck"]
    trucks = scene.objects["trucks"]
    wheel1 = scene.objects["rollen.000"]
    wheel2 = scene.objects["rollen.001"]
    wheel3 = scene.objects["rollen.002"]
    wheel4 = scene.objects["rollen.003"]
    turnsens = .04
    turnsens2 = .06 #air_turn_boost
    grindDar = own["grindDar_hit"]
    grindEmpty = scene.objects["grindEmpty"]
    grindDar2 = grindEmpty.sensors["grindDar2"]
    #invertCol = cont.sensors["invertCol"]
    cam = scene.objects["Camera.003"]
    freecam = scene.objects["freecam"]
    followcam = scene.objects["followcam"]
    coping_on = own["coping"]
    invert_on = own['invert_on']
    grab_type = own['grab_type']
    c_ground = cont.sensors['c_ground']
    #
    control_bottom = scene.objects['control_bottom']
    invertTouch = control_bottom.sensors['grindCol_bottom']
    wallride = own["wallride"]
    wallride_col = cont.sensors['wallride']
    wallrideL = cont.sensors['wallrideL']
    wallrideR = cont.sensors['wallrideR']
    wallrideconstL = cont.actuators['wallrideconstL']
    wallrideconstR = cont.actuators['wallrideconstR']
    if r_ground.triggered: own['wallride_off'] = 0
    own['pop_sound'] = 0
    own['land_sound'] = 0
    own['revert_sound'] = 0
    #own['fall'] = 0 

    #joystick location timers
    q1oncd = own["Q1oncd"]
    q2oncd = own["Q2oncd"]
    q3oncd = own["Q3oncd"]
    q4oncd = own["Q4oncd"]
    q5oncd = own["Q5oncd"]
    q6oncd = own["Q6oncd"]
    q7oncd = own["Q7oncd"]
    q8oncd = own["Q8oncd"]
    q1oncdl = own["Q1oncdl"]
    q2oncdl = own["Q2oncdl"]
    q3oncdl = own["Q3oncdl"]
    q4oncdl = own["Q4oncdl"]
    q5oncdl = own["Q5oncdl"]
    q6oncdl = own["Q6oncdl"]
    q7oncdl = own["Q7oncdl"]
    q8oncdl = own["Q8oncdl"]
    fliplay = 4

    #setable
    MAX_VEL = dict['MAX_VEL']
    SPEEDUP = dict['SPEEDUP']
    SPEEDPUMP = dict['SPEEDPUMP']
    SPEEDPUMPFAST = dict['SPEEDPUMPFAST']
    PUMP_SPEED_SENS = dict['PUMP_SPEED_SENS']
    PUMP_SENS = dict['PUMP_SENS']
    ACCEL = dict['ACCEL']
    CRUISE = dict['CRUISE']
    COUNTDOWN = dict['COUNTDOWN'] #pump and speed stuff
    JUMPHEIGHT = dict['JUMPHEIGHT'] #775#750
    JUMPSTRENGTH = 0
    own['flip_manual_stance'] = 0
    LAND_LAYER = 100
    LAND_END = 20

    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']

    #fliptricks after manuals
    if (frame - own['last_manual_frame']) < 25:
        flip_start_lay = 8
        flipspeed = .4
        own['flipspeed'] = .4
        own['flip_start_lay'] = 8
        #print("chopping flip start")
    else:
        flip_start_lay = 1 
        own['flip_start_lay'] = 1
        flipspeed = .6   
        own['flipspeed'] = .6
    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)   

    if aBut == True and lasta == False and r_ground.triggered:
        aBut_ground = True
        own['aBut_ground'] = True
    #else:
    if aBut == False:
        aBut_ground = False    
        own['aBut_ground'] = False
    if xBut == True and lastx == False and r_ground.triggered:
        xBut_ground = True
        own['xBut_ground'] = True
    #else:
    if xBut == False:
        xBut_ground = False    
        own['xBut_ground'] = False    
        
    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(9000):
            skater.stopAction(x)
            deck.stopAction(x)
            trucks.stopAction(x) 

    def reset_rtimers_done():
        pass
        #print('rtimer reset:', q1oncd, q2oncd, q3oncd, q4oncd, q5oncd, q6oncd, q7oncd, q8oncd)

    def reset_rtimers():
        own["Q1oncd"] = 0
        own["Q2oncd"] = 0
        own["Q3oncd"] = 0
        own["Q4oncd"] = 0
        own["Q5oncd"] = 0
        own["Q6oncd"] = 0
        own["Q7oncd"] = 0
        own["Q8oncd"] = 0
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0 
        reset_rtimers_done()   

    def check_fall():
        playing_frame = 20
        if skater.isPlayingAction(fliplay):
            playing_frame = skater.getActionFrame(fliplay)
        if r_ground.triggered == True and skater.isPlayingAction(fliplay) and own['jump_timer'] < 40 and playing_frame < 14 and playing_frame > 3:
            own['fall'] = 1
            own['last_fall_frame'] = frame
            if STANCE == 0:
                own['requestAction'] = 'reg_air-walk_air'
            if STANCE == 1:             
                own['requestAction'] = 'fak_air-walk_air'
    check_fall()

    def check_landing():
        lf_ground = own["lF_ground"]
        STANCE = own["stance"]
        playing_action_frame = skater.getActionFrame(LAND_LAYER)
        if lf_ground == False and r_ground.triggered == True:
            own['no_grind'] = False
            own['jump_from_trans'] = 0
            nearestObject = None
            minDist = None
            detectedObjects = grindDar2.hitObjectList
            if grindDar == 0:
                lastheight = own["air_height"]
                pos = own.worldPosition.z
                dist = lastheight - pos
                dist = dist * 2
                if dist > 1:
                    dist = 1
                own.actuators["land"].volume = dist 
                sact = own.actuators["land"]
                sact.stopSound()   
                cont.activate(own.actuators["land"])
                own['land_sound'] = 1
            if grindDar == 1:
                pass
            own["vib_Countdown"] = 14
            cont.activate(own.actuators["Vibration"])
            if own['manual_v2'] == 0 and grindDar == 0:          
                if STANCE == 0:
                    own['requestAction'] = 'reg_land'
                elif STANCE == 1:
                    own['requestAction'] = 'fak_land'                  
        lf_ground = r_ground.triggered
        own["lF_ground"] = lf_ground
        vib_countdown = own["vib_Countdown"]
        if vib_countdown > 0:
            vib_countdown = vib_countdown - 1
            own["vib_Countdown"] = vib_countdown
        if vib_countdown == 1:
            stopAnims()
            stance()

    #air anim
    if r_ground.triggered == False:
        if STANCE == 0:
            own['requestAction'] = 'reg_air'
        if STANCE == 1:
            own['requestAction'] = 'fak_air'
    else:
        if STANCE == 0:
            own['requestAction'] = 'reg_roll'
        if STANCE == 1:
            own['requestAction'] = 'fak_roll'

    #check manual_v2
    if (rUD > dict['man_sens_l'] and rUD < dict['man_sens_r']) or (rUD < -dict['man_sens_l'] and rUD > -dict['man_sens_r']):
    #if (rUD > .04 and rUD < .07):
        #print("zoned")    
        timer = own['manual_v2_timer']
        timer = timer + 1
        if timer > 20:
            own['manual_v2'] = 1
        own['manual_v2_timer'] = timer    
    if rUD < .04 and rUD > -.04:
        own['manual_v2_timer'] = 0
        own['manual_v2'] = 0 
        own['manual_v2_type'] = None
    if own['manual_v2'] == 1:    
        if own['last_manual_v2'] == 0:
            if STANCE == 0:
                if rUD > .04 and rUD < .07:
                    #print("reg manual")
                    own['manual_v2_type'] = 'reg manual'     
                if rUD < -.04 and rUD > -.07:
                    own['manual_v2_type'] = 'reg nose manual'

            if STANCE == 1:
                if rUD > .04 and rUD < .07:
                    own['manual_v2_type'] = 'fak manual'
                    if lRequest == 'reg_air_tail to manual':
                        #print('chaaaaange init')
                        own['manual_v2_type'] = 'fak nose manual'
                if rUD < -.04 and rUD > -.07:
                    own['manual_v2_type'] = 'fak nose manual'
                                
        else:
            #print("flip stance")
            if own['jump_stance'] == 0:
                #print('flipstance 0')
                if own['manual_v2_type'] == 'fak manual':
                    own['manual_v2_type'] = 'reg nose manual'
                if own['manual_v2_type'] == 'fak nose manual':
                    own['manual_v2_type'] = 'reg manual'
                if lAs == 'fak_air_tail to manual' and own['manual_v2_type'] == 'reg manual':
                    #print('---requesting reg nose manual')
                    own['manual_v2_type'] = 'reg nose manual' 
                if lAs == 'fak_air_nose to nmanual' and own['manual_v2_type'] == 'reg nose manual':
                    #print('---requesting reg nose manual')
                    own['manual_v2_type'] = 'reg manual'                                          
            if own['jump_stance'] == 1:
                #print('flipstance 1')
                if own['manual_v2_type'] == 'reg manual':
                    own['manual_v2_type'] = 'fak nose manual'
                if own['manual_v2_type'] == 'reg nose manual':
                    #print("asdfasdfasdfsdfasdfasdf")
                    own['manual_v2_type'] = 'fak manual'   
                if lAs == 'reg_air_tail to manual' and own['manual_v2_type'] == 'fak manual':
                    #print('---requesting fak nose manual')
                    own['manual_v2_type'] = 'fak nose manual'
                if lAs == 'reg_air_nose to nmanual' and own['manual_v2_type'] == 'fak nose manual':
                    #print('---requesting fak nose manual')
                    own['manual_v2_type'] = 'fak manual' 
                    
        if STANCE == 0 and (own['manual_v2_type'] == 'fak manual' or own['actionState'] == 'fak-reg_nmanual'):
            own['manual_v2_type'] = 'reg nose manual'  
        if STANCE == 1 and (own['manual_v2_type'] == 'reg manual' or own['actionState'] == 'reg-fak_nmanual'):
            own['manual_v2_type'] = 'fak nose manual'
        if STANCE == 0 and (own['manual_v2_type'] == 'fak nose manual' or own['actionState'] == 'fak-reg_manual'):
            own['manual_v2_type'] = 'reg manual' 
        if STANCE == 1 and (own['manual_v2_type'] == 'reg nose manual' or own['actionState'] == 'reg-fak_manual'):
            own['manual_v2_type'] = 'fak manual'               
 
    #check manual
    ####
    #reg
    if rUD > dict['man_sens_l'] and rUD < dict['man_sens_r'] and STANCE == 0 and rLR < dict['man_sens_side'] and rLR > -dict['man_sens_side']:
        timer = own["reg_manual_timer"]
        timer = timer + 1
        own["reg_manual_timer"] = timer
        if timer > 20 and rUD < .04:
            own["reg_manual"] = 0
    if rUD <= dict['man_sens_l'] and (STANCE == 1 or STANCE == 0) and rUD >= -.04:
        own["reg_manual_timer"] = 0
        own["reg_manual"] = 0 
    #####
    if own["reg_manual_timer"] > 10 and own["fak_manual"] == 0 and own['reg_nmanual'] == 0:
        own["reg_manual"] = 1
    ######
    if own["reg_manual_timer"] == 0:
        own["reg_manual"] = 0 
          
    ####   
    #fak
    if rUD > dict['man_sens_l'] and rUD < dict['man_sens_r'] and STANCE == 1 and rLR < dict['man_sens_side'] and rLR > -dict['man_sens_side']:
        timer = own["fak_manual_timer"]
        timer = timer + 1
        own["fak_manual_timer"] = timer
        if timer > 20:
            own["fak_manual"] = 0
    if rUD <= dict['man_sens_l'] and (STANCE == 1 or STANCE == 0) and rUD >= -.04:
        own["fak_manual_timer"] = 0
        own["fak_manual"] = 0
    if own["fak_manual_timer"] > 10 and own["reg_manual"] == 0:
        own["fak_manual"] = 1
    if own["fak_manual_timer"] == 0:
        own["fak_manual"] = 0  
     
    #####
    #reg nmanual
    if rUD < -dict['man_sens_l'] and rUD > -dict['man_sens_r'] and STANCE == 0 and rLR < dict['man_sens_side'] and rLR > -dict['man_sens_side']:
        timer = own["reg_nmanual_timer"]
        timer = timer + 1
        own["reg_nmanual_timer"] = timer
        if timer > 20:
            own["reg_nmanual"] = 0
    if rUD >= -dict['man_sens_l'] and (STANCE == 1 or STANCE == 0) and rUD <= .04:
        own["reg_nmanual_timer"] = 0
        own["reg_nmanual"] = 0

    if own["reg_nmanual_timer"] > 10 and own["fak_nmanual"] == 0 and own['reg_manual'] == 0 and own['fak_manual'] == 0:  
        if own['last_fak_manual'] == False and own['last_reg_manual'] == False and own['last_fak_manual'] == False:
            own["reg_nmanual"] = 1

    if own["reg_nmanual_timer"] == 0:
        own["reg_nmanual"] = 0 
     
    #####
    #fak nmanual
    #print (rUD)
    if rUD < -dict['man_sens_l'] and rUD > -dict['man_sens_r'] and STANCE == 1 and rLR < dict['man_sens_side'] and rLR > -dict['man_sens_side']:
        timer = own["fak_nmanual_timer"]
        timer = timer + 1
        own["fak_nmanual_timer"] = timer
        if timer > 20:
            own["fak_nmanual"] = 0
    if rUD >= -dict['man_sens_l'] and (STANCE == 1 or STANCE == 0) and rUD <= .04:
        own["fak_nmanual_timer"] = 0
        own["fak_nmanual"] = 0
    if own["fak_nmanual_timer"] > 10 and own["reg_nmanual"] == 0 and own['fak_manual'] == 0 and own ['reg_manual'] == 0:
        own["fak_nmanual"] = 1
    if own["fak_nmanual_timer"] == 0 and own['reg_manual'] == 0:
        own["fak_nmanual"] = 0 
    if own['last_fak_nmanual'] == 1 and own['fak_nmanual'] == 0:
        pass  

    def reg_stance_left_off():
        LAST_LEFT = own["LAST_LEFT"]
        own["LAST_LEFT"] = 0   

    def reg_stance_right_off():
        LAST_RIGHT = own["LAST_RIGHT"]
        own["LAST_RIGHT"] = 0  
        
    def reg_stance_on(inc):
        playing = deck.isPlayingAction(40)
        if own["revert_timer"] < 1 and own['manual_v2'] == 0 and playing == 0:
            own['requestAction'] = 'reg_roll'
        
    def reg_manual_on():
        own['requestAction'] = 'reg_manual'
        
    def fak_manual_on():
        own['requestAction'] = 'fak_manual'

    def reg_nmanual_on():
        own['requestAction'] = 'reg_nmanual'   
        
    def fak_nmanual_on():
        own['requestAction'] = 'fak_nmanual'    
        
    if own['l_actionState'] == 'reg_manual_revert_ccw':
        own['manual_v2_type'] = 'fak nose manual'
        fak_nmanual_on()  
    if own['l_actionState'] == 'reg_manual_revert_cw':
        own['manual_v2_type'] = 'fak nose manual'
        fak_nmanual_on()          
              
    
    ###########
        
    def reg_stanceinc_on():
        pass

    def reg_stanceinc_off():
        pass       
                    
    def reg_stance_left_on():
        if own['manual_v2'] == 0 and own["revert_timer"] < 1 and own['gt_cd2'] < 1 and ground_since > 30:
            if own["Pump"] == 1:
                own['requestAction'] = 'reg_pump_left'
            else:    
                own['requestAction'] = 'reg_turnLeft'    
            LAST_LEFT = own["LAST_LEFT"]
            playing_action_frame = skater.getActionFrame(LAND_LAYER)
            if LAST_LEFT == 0 or (playing_action_frame > (LAND_END - 2) and playing_action_frame < (LAND_END - 1)):
                LAST_LEFT = 1
            own["LAST_LEFT"] = 1                        
             
    def reg_stance_right_on():
        if own['manual_v2'] == 0 and own["revert_timer"] < 1 and own['gt_cd2'] < 1 and ground_since > 30:
            if own["Pump"] == 1:
                own['requestAction'] = 'reg_pump_right'
            else:               
                own['requestAction'] = 'reg_turnRight' 
            LAST_RIGHT = own["LAST_RIGHT"]
            playing_action_frame = skater.getActionFrame(LAND_LAYER)
            if LAST_RIGHT == 0 or (playing_action_frame > (LAND_END - 2) and playing_action_frame < (LAND_END - 1)):
                LAST_RIGHT = 1
            own["LAST_RIGHT"] = 1                   
       
    def fak_stance_on(inc):
        playing = deck.isPlayingAction(40)
        if own['manual_v2'] == 0 and own["revert_timer"] < 1 and playing == 0 and own['gt_cd2'] < 1:   
            own['requestAction'] = 'fak_roll'
        
    def fak_stance_left_on():
        if own['manual_v2'] == 0 and own["revert_timer"] < 1 and own['gt_cd2'] < 1 and ground_since > 30:
            if own["Pump"] == 1:
                own['requestAction'] = 'fak_pump_left'
            else:               
                own['requestAction'] = 'fak_turnLeft'     
            LAST_LEFT_FAK = own["LAST_LEFT_FAK"]
            playing_action_frame = skater.getActionFrame(LAND_LAYER)
            if LAST_LEFT_FAK == 0 or (playing_action_frame > (LAND_END - 2) and playing_action_frame < (LAND_END - 1)):
                LAST_LEFT_FAK = 1
            own["LAST_LEFT_FAK"] = 1                      
    def fak_stance_left_off():
        LAST_LEFT_FAK = own["LAST_LEFT_FAK"]
        own["LAST_LEFT_FAK"] = 0
        
    def fak_stance_right_on():
        if own['manual_v2'] == 0 and own["revert_timer"] < 1 and own['gt_cd2'] < 1 and ground_since > 30:
            if own["Pump"] == 1:
                own['requestAction'] = 'fak_pump_right'
            else:               
                own['requestAction'] = 'fak_turnRight' 
            LAST_RIGHT_FAK = own["LAST_RIGHT_FAK"]
            own["LAST_RIGHT_FAK"] = 1        
    def fak_stance_right_off():
        LAST_RIGHT_FAK = own["LAST_RIGHT_FAK"]
        own["LAST_RIGHT_FAK"] = 0    
        
    def reg_air_on():
        playing = deck.isPlayingAction(fliplay)
        if playing == False:
            own['requestAction'] = 'reg_air'        

    def reg_air_off():
        pass   
    def fak_air_on():
        flipping = skater.isPlayingAction(fliplay)
        if flipping == False:
            own['requestAction'] = 'fak_air' 
      
    def fak_air_off():
        pass   
    def stance():  
        rotation = .96
        turnsens = 0.06
        if rot.z < .9: inc = 1
        else: inc = 0
        flipping = False
        #ground
        ground_since = own["framenum"] - own['lF_air_frame']
        inc = 0
        if rot.z < .98:
            inc = 1
        
        if r_ground.triggered == True and grindHit == False and flipping == False and own["wallride"] == None and own['revert_timer'] < 2:    
            if STANCE == 0:
                reg_manual = own['reg_manual']
                fak_manual = own["fak_manual"]
                reg_nmanual = own['reg_nmanual']
                fak_nmanual = own["fak_nmanual"]             
                if LAST_STANCE != STANCE or LAST_GROUND != r_ground.triggered:
                    reg_air_off()
                    fak_air_off()
                if reg_manual == 0 and fak_manual == 0:  
                    last_manual = own['last_reg_manual']
                    reg_stance_on(inc)
                if own['manual_v2_type'] == 'reg manual':    
                    reg_manual_on()                   
                elif own['manual_v2_type'] == 'reg nose manual':    
                    reg_nmanual_on()
                elif own['manual_v2_type'] == 'fak manual':
                    fak_manual_on()
                elif own['manual_v2_type'] == 'fak nose manual':
                    fak_nmanual_on()
            if STANCE == 1:
                reg_manual = own['reg_manual']
                fak_manual = own["fak_manual"]
                reg_nmanual = own['reg_nmanual']
                fak_nmanual = own["fak_nmanual"]
                if LAST_STANCE != STANCE or LAST_GROUND != r_ground.triggered:    
                    reg_air_off()
                    fak_air_off 
                if fak_manual == 0:                    
                    last_manual = own['last_fak_manual']
                    fak_stance_on(inc)                    
                if own['manual_v2_type'] == 'fak manual':
                    fak_manual_on()
                elif own['manual_v2_type'] == 'fak nose manual':
                    fak_nmanual_on()
                elif own['manual_v2_type'] == 'reg manual':
                    reg_manual_on()
                elif own['manual_v2_type'] == 'reg nose manual':
                    reg_nmanual_on()                     
            #if own["Pump"] == False:
            if (lLR < -turnsens or dict['kb_la'] == 2) and STANCE == 0:
                reg_stance_left_on()
            if lLR > -turnsens or LAST_GRIND != grindHit or dict['kb_la'] == 0:
                reg_stance_left_off()    
            if (lLR > turnsens or dict['kb_ra'] == 2) and STANCE == 0:
                reg_stance_right_on()
            if lLR < turnsens or LAST_GRIND != grindHit or dict['kb_ra'] == 0:
                reg_stance_right_off()   
            if (lLR < -turnsens or dict['kb_la'] == 2) and STANCE == 1: 
                fak_stance_left_on()
            if lLR > -turnsens or LAST_GRIND != grindHit or dict['kb_la'] == 0:
                fak_stance_left_off()    
            if (lLR > turnsens or dict['kb_ra'] == 2) and STANCE == 1:
                fak_stance_right_on()
            if lLR < turnsens or LAST_GRIND != grindHit or dict['kb_ra'] == 0:
                fak_stance_right_off()                       
        #air
        playing = deck.isPlayingAction(fliplay)
        if r_ground.triggered == False and playing == False and flipping == False:
            if STANCE == 0:
                if LAST_STANCE != STANCE or LAST_GROUND != r_ground.triggered:                
                    fak_air_off()
                    reg_stance_left_off() 
                    reg_stance_right_off()
                    fak_stance_left_off()  
                    fak_stance_right_off() 
                reg_air_on()
            if STANCE == 1:
                if LAST_STANCE != STANCE or LAST_GROUND != r_ground.triggered:
                    reg_air_off()   
                    reg_stance_left_off()
                    reg_stance_right_off()
                    fak_stance_left_off()  
                    fak_stance_right_off()  
                fak_air_on()
       
                           
    ###################
    #trick definitions#
    ###################
    def jump():
        #print("jump funct")
        jump_timer = own['jump_timer']          
        cont.deactivate(wallrideconstL)
        cont.deactivate(wallrideconstR) 
        own['last_jump_frame'] = frame    
        own['no_grind_timer'] = 0
           
        if JUMPSTRENGTH != 0:
            height = JUMPSTRENGTH * JUMPHEIGHT
        else:
            height = JUMPHEIGHT    
        #if jump_timer == 0:
        if jump_timer < 50:    
            jump_timer = 60
            own['jump_timer'] = jump_timer
                
        if zvel < 7 and jump_timer == 60:
            cont.activate(own.actuators["pop"])
            own['pop_sound'] = 1
            #print("jump")
            #
            posx = own.worldPosition[0]
            posy = own.worldPosition[1]
            posz = own.worldPosition[2]
            jumppos = Vector((posx, posy, posz))
            own['jumpPos'] = jumppos  
            force = [ 0.0, 0.0, height]
            # use local axis
            local = False
            # apply force
            try:
                if 'trans' in r_ground.hitObject:
                    #print('jump from trans')
                    own['jump_from_trans'] = 1
                    own['trans_jump_obj'] = r_ground.hitObject
            except:
                #print('trans jump broke')
                pass
            if grindHit == False:    
                if rot.z < .7:
                    rotamt = rot.z * .5
                    own.applyRotation([0, rotamt,0], True)
                    own['no_grind'] = True
                    own['no_grind_pull'] = 1
                 
                own.applyForce(force, local)
                force2 = [0.0, 0, 150]
                own.applyForce(force2, True)
                #print("apply jump force1")
            if grindHit == True:
                linvelloc = own.getLinearVelocity(True)
                own.applyForce(force, True)
                force2 = [0.0, 0, 150]            
                own.applyForce(force2, True) 
                linvelloc2 = own.getLinearVelocity(True)
                force = (linvelloc.x, linvelloc.y, linvelloc2.z)
                own.setLinearVelocity(force, True) 
                #print("apply jump force2 grindHit")          
                    
            own['jump_stance'] = STANCE
            if STANCE == True:
                own["jump_stance"] = 1
            if STANCE == False:
                own["jump_stance"] = 0        
            own["jump_stance"] = own["stance"]
            if grindHit == True:
                own['grind_jump'] = 1
                if lLR > turnsens or lLR < -turnsens or lUD > turnsens or lUD < -turnsens:
                    own['grindjumpturn'] = True
        num = 1            
        if num ==1:                
            rString = "R"        
            lString = "L"
            cont.deactivate(wallrideconstL)
            cont.deactivate(wallrideconstR)
            if own["wallride"] == "R":
                force = [0,170,0]
                own.applyForce(force, True)
                cont.activate(own.actuators["pop2"])
                jump_timer = 60
                own['jump_timer'] = jump_timer            
            if own["wallride"] == "L":
                force = [0,-170,0] #325
                own.applyForce(force, True)                    
                cont.activate(own.actuators["pop2"])
                jump_timer = 60
                own['jump_timer'] = jump_timer
                
                own["Q1oncd"] = 0
            own["Q2oncd"] = 0
            own["Q3oncd"] = 0
            own["Q4oncd"] = 0
            own["Q5oncd"] = 0
            own["Q6oncd"] = 0
            own["Q7oncd"] = 0
            own["Q8oncd"] = 0         
        if own['jump_timer'] == 60:
            own['jump_timer'] = 59

    def jump_Timer():
        jump_timer = own['jump_timer']
        if jump_timer > 0:
            jump_timer = jump_timer - 1
            own['jump_timer'] = jump_timer 
        if own['grindjumpturn'] == True:
            jump_timer = 30
            own['jump_timer'] = jump_timer           
            
    def pump():
        velocity = own['velocity']
        #switch
        local = True
        downforce = dict['pump_downforce']       
        lF_air_frame = own['lF_air_frame']
        frames_since_ground = own['framenum'] - own['lF_air_frame']     
        if linVelocity.x < MAX_VEL and linVelocity.x >= -0 and STANCE == 1 and grindHit == False and frames_since_ground > 30 and own['last_manual_v2'] == 0:            
            countdown = COUNTDOWN
            yvel = linVelocity.x + SPEEDPUMP
            yvel2 = linVelocity.x + SPEEDPUMPFAST
            own['countdown'] = countdown
            force = [(yvel), 0, linVelocity.z + downforce]
            force2 = [(yvel2), 0, linVelocity.z + downforce]
            if rot.z < PUMP_SENS and rot.z > PUMP_SPEED_SENS:
                own.setLinearVelocity(force, local)
            if rot.z < PUMP_SENS and rot.z <= PUMP_SPEED_SENS:
                own.setLinearVelocity(force2, local)
            if own['requestAction'] not in ['fak_pump_left', 'fak_pump_right'] and own['l_actionState'] not in ['fak_turnLeft', 'fak_turnRight']:
                own['requestAction'] = 'fak_pump'
        #reg
        if linVelocity.x > -MAX_VEL and linVelocity.x <= 0 and STANCE == 0 and grindHit == False and frames_since_ground > 30 and own['last_manual_v2'] == 0:
            countdown = COUNTDOWN
            yvel = linVelocity.x - SPEEDPUMP
            yvel2 = linVelocity.x - SPEEDPUMPFAST
            own['countdown'] = countdown
            force = [(yvel), 0, linVelocity.z + downforce]
            force2 = [(yvel2), 0, linVelocity.z + downforce]
            if rot.z < PUMP_SENS and rot.z > PUMP_SPEED_SENS:
                own.setLinearVelocity(force, local)
            if rot.z < PUMP_SENS and rot.z <= PUMP_SPEED_SENS:
                own.setLinearVelocity(force2, local)
            if own['requestAction'] not in ['reg_pump_left', 'reg_pump_right'] and own['l_actionState'] not in ['reg_turnLeft', 'reg_turnRight']:  
                own['requestAction'] = 'reg_pump'    
        own["Pump"] = True
        own["lastPump"] = True
                
    def roll():
        if r_ground.triggered == 1:  
            pass      
    def stop():
        if linVelocity.x < .05 and linVelocity.x > -.05:
            can_stop = 0
            own["lastStop"] = True
        else:
            can_stop = 1    
        if r_ground.triggered == 1 and STANCE == False and can_stop == 1:
            own['requestAction'] = 'reg_stop'        
            yvel = linVelocity.x * .985
            force = [(yvel), 0, linVelocity.z]
            own.setLinearVelocity(force, True)
        elif r_ground.triggered == 1 and STANCE == True and can_stop == 1:
            own['requestAction'] = 'fak_stop'
            yvel = linVelocity.x * .985
            force = [(yvel), 0, linVelocity.z]
            own.setLinearVelocity(force, True)    
        
        if linVelocity.x < .05 and linVelocity.x > -.05 and own["lastStop"] == True:
            own["lastStop"] == False       

    def oposin(): 
        if ground_since > 30:       
            if (r_ground.triggered == 1) and STANCE == False and own['manual'] == 0:
                if grindold == 0:
                    own['requestAction'] = 'reg_opos'
            elif (r_ground.triggered == 1) and STANCE == True and own['manual'] == 0:
                if grindold == 0:
                    own['requestAction'] = 'fak_opos'         
            own["last_Opos"] = True
        
    def noposin():  
        if ground_since > 30:
            if (r_ground.triggered == 1) and STANCE == False and own['manual'] == 0:
                if grindold == 0:
                    own['requestAction'] = 'reg_nopos'
            elif (r_ground.triggered == 1) and STANCE == True and own['manual'] == 0:
                if grindold == 0:
                    own['requestAction'] = 'fak_nopos'      
            own["last_nOpos"] = True    
                
    def aollie():
        print("ollie")
        #dict['trick_string'] = 'Ollie'
        r_ground = cont.sensors["r_Ground"]
        trigger = r_ground.triggered
        STANCE = own["stance"]
        wallride = own["wallride"]
        dict['trick_string'] = 'Ollie'
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_ollie'
            jump()  
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_ollie'
            jump()

    def nollie():
        print("nollie")
        dict['trick_string'] = 'Nollie'
        r_ground = cont.sensors["r_Ground"]
        trigger = r_ground.triggered
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own['requestAction'] = 'fak_nollie'
            own["wallride_off"] = 1
            jump()  
        elif (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_nollie'
            jump()  
      

    def kickflip():
        print("kickflip")
        
        STANCE = own["stance"]
        print(flip_start_lay)
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_kickflip'       
            jump()
            dict['trick_string'] = 'Kickflip'
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_heelflip'       
            jump()
            if own["wallride"] !=1: jump()
            dict['trick_string'] = 'Heelflip'
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_kickflip'
            if own["wallride"] != None: 
                jump()  
            dict['trick_string'] = 'Kickflip'
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_heelflip'
            if own["wallride"] != None: 
                jump()
            dict['trick_string'] = 'Heelflip'    

    def inward_heelflip():
        print("inward heelflip")
        dict['trick_string'] = 'Inward Heelflip'
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_inward_heelflip'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_inward_heelflip'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()              
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()              

    def hardflip():
        print("hardflip")
        dict['trick_string'] = 'Hardflip'
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_hardflip'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_hardflip'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()              
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()
                
    def nollie_inward_heelflip():
        print("nollie inward heelflip")
        dict['trick_string'] = 'Nollie Inward Heelflip'
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_nollie_inward_heelflip'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_nollie_inward_heelflip'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()              
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()

    def nollie_hardflip():
        print("nollie hardflip")
        dict['trick_string'] = 'Nollie Hardflip'
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_nollie_hardflip'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_nollie_hardflip'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()              
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()                  

                
    def varial_kickflip():
        print("varial kickflip")
        dict['trick_string'] = 'Varial Kickflip'
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_varial_kickflip'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_varial_kickflip'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()              
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()
                
    def nollie_varial_kickflip():
        print("nollie varial kickflip")
        dict['trick_string'] = 'Nollie Varial Kickflip'
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_nollie_varial_kickflip'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_nollie_varial_kickflip'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()              
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()
                
    def nollie_varial_heelflip():
        print("nollie varial heelflip")
        dict['trick_string'] = 'Nollie Varial Heelflip'
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_nollie_varial_heelflip'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_nollie_varial_heelflip'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()              
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()            
                            
    def varial_heelflip():
        print("varial heelflip")
        dict['trick_string'] = 'Varial Heelflip'
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_varial_heelflip'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_varial_heelflip'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()              
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()            
                
    def nollie_kickflip():
        print("kickflip")
        STANCE = own["stance"]
        dict['trick_string'] = 'Nollie Kickflip'
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_nollie_kickflip'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_nollie_kickflip'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
        
    def heelflip():
        print("heelflip")
        
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_heelflip'
            jump()
            dict['trick_string'] = 'Heelflip'
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_kickflip'
            jump()
            dict['trick_string'] = 'Kickflip'
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            
    def nollie_heelflip():
        print("heelflip")
        dict['trick_string'] = 'Nollie Heelflip'
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_nollie_heelflip'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or (grindHit == True and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_nollie_heelflip'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()        
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()       

    def shuvit():
        print("shuvit")
        dict['trick_string'] = 'Shuvit'
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_shuvit'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_shuvit'
            jump()
        if r_ground.triggered == 0 and STANCE == False:     
            if own["wallride"] != None: 
                jump()  
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()

    def shuvit360():
        print("360shuvit")
        dict['trick_string'] = '360 Shuvit'
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_shuvit360'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_shuvit360'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()       
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()    

    def fsshuvit360():
        print("360shuvit")
        dict['trick_string'] = 'FS 360 Shuvit'
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_fsshuvit360'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_fsshuvit360'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()       
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()

    def nollie_shuvit():
        print("shuvit")
        dict['trick_string'] = 'Nollie Shuvit'
        STANCE = own["stance"]
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_nollie_shuvit'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_nollie_shuvit'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()       
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()        

    def fsshuvit():
        dict['trick_string'] = 'FS Shuvit'
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_fsshuvit'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_fsshuvit'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()        
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()
            
    def nollie_fsshuvit():
        dict['trick_string'] = 'Nollie FS Shuvit'
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_nollie_fsshuvit'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or (grindHit == True and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_nollie_fsshuvit'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()       
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()
     
    #nollie_shuvit360()
    def nollie_shuvit360():
        dict['trick_string'] = 'Nollie FS Shuvit 360'
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_nollie_shuvit360'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or (grindHit == True and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_nollie_shuvit360'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()       
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump() 

    #nollie_fsshuvit360()
    def nollie_fsshuvit360():
        dict['trick_string'] = 'Nollie FS Shuvit 360'
        if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
            own["wallride_off"] = 1
            own['requestAction'] = 'reg_nollie_fsshuvit_360'
            jump()
        elif (r_ground.triggered == 1 and STANCE == True) or (grindHit == True and STANCE == True):
            own["wallride_off"] = 1
            own['requestAction'] = 'fak_nollie_fsshuvit_360'
            jump()
        if r_ground.triggered == 0 and STANCE == False:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()       
        elif r_ground.triggered == 0 and STANCE == True:
            own["wallride_off"] = 1
            if own["wallride"] != None: 
                jump()             
#-------
    def reg_frigid_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'Frigid'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
            own['requestAction'] = 'reg_frigid'
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED
    def reg_fsonefoot_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'FS One Foot'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
            own['requestAction'] = 'reg_fsonefoot'
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED
    def reg_onefoot_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'One Foot'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
            own['requestAction'] = 'reg_onefoot'
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED

    def fak_frigid_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'Frigid'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
            own['requestAction'] = 'fak_frigid'
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED
    def fak_fsonefoot_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'FS One Foot'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
            own['requestAction'] = 'fak_fsonefoot'
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED
    def fak_onefoot_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'One Foot'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
            own['requestAction'] = 'fak_onefoot'
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED

#----        
    def reg_judo_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'Judo'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
            own['requestAction'] = 'reg_judo'
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED

    def fak_judo_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'Judo'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
            own['requestAction'] = 'fak_judo'
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED            
                
    def frontside_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'Mute'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
            own['requestAction'] = 'frontside_grab'
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED
                
    def backside_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'Backside'
        if GRAB_ON == True and r_ground.triggered == 0 and aBut == True:
            own['requestAction'] = 'reg_fp_rback'          
        elif GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:
            own['requestAction'] = 'backside_grab'        
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED            
            
    def fakfrontside_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'Mute'
        if GRAB_ON == True and r_ground.triggered == 0 and aBut == True:
            own['requestAction'] = 'fak_fp_rback'         
        
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:           
            own['requestAction'] = 'fak_frontside_grab' 
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED
        
    def fakbackside_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'Backside'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
            own['requestAction'] = 'fak_backside_grab' 
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED
            
    #nose/tail grabs        
    def frontside_nose_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'FS Nose'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:
            own['requestAction'] = 'frontside_nose_grab' 
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED
    def frontside_tail_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'FS Tail'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0: 
            own['requestAction'] = 'frontside_tail_grab' 
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED     
    def backside_nose_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'BS Nose'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:   
            own['requestAction'] = 'backside_nose_grab' 
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED 
    def backside_tail_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'BS Tail'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0: 
            own['requestAction'] = 'backside_tail_grab' 
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED
            
    def reg_airwalk():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'Airwalk'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0: 
            own['requestAction'] = 'reg_airwalk' 
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED            
            
    #switch    
    def fak_frontside_nose_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'FS Nose'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:  
            own['requestAction'] = 'fak_frontside_nose_grab' 
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED

    def fak_frontside_tail_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'FS Tail'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:           
            own['requestAction'] = 'fak_frontside_tail_grab' 
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED
 
    def fak_backside_nose_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'BS Nose'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:           
            own['requestAction'] = 'fak_backside_nose_grab' 
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED

    def fak_backside_tail_grab_on():
        GRAB_PLAYED = own["GRAB_PLAYED"]
        GRAB_ON = own["GRAB_ON"]
        dict['trick_string'] = 'BS Tail'
        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:           
            own['requestAction'] = 'fak_backside_tail_grab' 
            GRAB_PLAYED = True
            own["GRAB_PLAYED)"] = GRAB_PLAYED
    
    #--------------------
            
    def SWAG():
        if r_ground.triggered == 1:
            SWAG = own["swag"]
            SWAG = own.getLinearVelocity(True)
            SWAG = SWAG[1]
            own["swag"] = SWAG
            if STANCE == True:
                if SWAG > 1 and SWAG < 2:
                    rotation = [ 0.0, 0, (SWAG / 200)]
                    own.applyRotation( rotation, True)        
                elif SWAG > 2:
                    rotation = [ 0.0, 0, (SWAG / 50)]
                    own.applyRotation( rotation, True)
                elif SWAG < -1 and SWAG > -2:
                    rotation = [ 0.0, 0, (SWAG / 200)]
                    own.applyRotation( rotation, True)
                elif SWAG < -2:
                    rotation = [ 0.0, 0, (SWAG / 50)]
                    own.applyRotation( rotation, True)
            if STANCE == False:
                if SWAG > 1 and SWAG < 2:
                    rotation = [ 0.0, 0, (-SWAG / 200)]
                    own.applyRotation( rotation, True)        
                elif SWAG > 2:
                    rotation = [ 0.0, 0, (-SWAG / 50)]
                    own.applyRotation( rotation, True)
                elif SWAG < -1 and SWAG > -2:
                    rotation = [ 0.0, 0, (-SWAG / 200)]
                    own.applyRotation( rotation, True)
                elif SWAG < -2:
                    rotation = [ 0.0, 0, (-SWAG / 50)]
                    own.applyRotation( rotation, True) 
                    
    def air():
        if r_ground.triggered == False and own['airup'] == 1:
            own.alignAxisToVect(gray.hitNormal, 2, .03)
        if r_ground.triggered == False and own['airup'] == 0:
             
            distance = own.getDistanceTo(gray.hitPosition)
            since_grind_buf = 3
            if gray.hitObject != None and grindDar2.triggered == False and (frame - lgf) > since_grind_buf:
                #add or colliding
                if distance < .5:  
                    own.alignAxisToVect(gray.hitNormal, 2, .1)
                elif distance >= .5 and distance < 1.75:  
                    own.alignAxisToVect(gray.hitNormal, 2, .05)
                elif distance >= 1.75:  
                    own.alignAxisToVect([0.0,0.0,1.0], 2, .03)
            if grindDar2.triggered and (frame - lgf) > since_grind_buf:
                if distance < .5:  
                    own.alignAxisToVect(gray.hitNormal, 2, .1)
                elif distance >= .5 and distance < 1.75:  
                    own.alignAxisToVect(gray.hitNormal, 2, .03)
                elif distance >= 1.75:  
                    own.alignAxisToVect([0.0,0.0,1.0], 2, .03)            
        elif r_ground.triggered == True:
            pass
    def stopAnims():
        pass       
        
    def isplaying():
    #    for x in range(9000):
    #        l1 = deck.isPlayingAction(x)
    #        if l1 == True:
    #            print(x)
        pass

    def nextframe():
        framenumber = own["framenum"]
        framenumber = framenumber + 1
        if framenumber == 900000:
            framenumber = 0
        own["framenum"] = framenumber
        own['last_roll_frame'] = framenumber
        
    def push():
        local = True
        #print("push")
        linVelocity15 = own.linearVelocity
        if linVelocity15.x < MAX_VEL and linVelocity15.x >= -0 and r_ground.triggered == True and own['hippy'] == 0 and own['last_hippy'] == 0 and own['last_footplant'] == False:
            countdown = COUNTDOWN
            yvel = linVelocity15.x + SPEEDUP
            own['countdown'] = countdown
            force = [(yvel), 0, linVelocity15.z]
            own.setLinearVelocity(force, local)
            own['requestAction'] = 'fak_push_goof'
        #switch
        if linVelocity15.x > -MAX_VEL and linVelocity15.x < 0 and r_ground.triggered == True and own['hippy'] == 0 and own['last_hippy'] == 0:
            countdown = COUNTDOWN
            yvel = linVelocity15.x - SPEEDUP
            own['countdown'] = countdown
            force = [(yvel), 0, linVelocity15.z]
            own.setLinearVelocity(force, local)
            own['requestAction'] = 'reg_push'

    def push_goof():
        linVelocity15 = own.linearVelocity
        local = True
        #print("push goof")
        if linVelocity15.x < MAX_VEL and linVelocity15.x >= -0 and r_ground.triggered == True and own['hippy'] == 0 and own['last_hippy'] == 0:
            countdown = COUNTDOWN
            yvel = linVelocity15.x + SPEEDUP
            own['countdown'] = countdown
            force = [(yvel), 0, linVelocity15.z]
            own.setLinearVelocity(force, local)
            own['requestAction'] = 'fak_push'
        #switch
        if linVelocity15.x > -MAX_VEL and linVelocity15.x < 0 and r_ground.triggered == True and own['hippy'] == 0 and own['last_hippy'] == 0:
            countdown = COUNTDOWN
            yvel = linVelocity15.x - SPEEDUP
            own['countdown'] = countdown
            force = [(yvel), 0, linVelocity15.z]
            own.setLinearVelocity(force, local)
            own['requestAction'] = 'reg_push_goof'

    def brfoot():
        if STANCE == 0:
            own['requestAction'] = 'reg_brfoot'
        if STANCE == 1:
            own['requestAction'] = 'fak_brfoot' 
        jump()   

    def frfoot():
        if STANCE == 0:
            own['requestAction'] = 'reg_frfoot'
        if STANCE == 1:
            own['requestAction'] = 'fak_frfoot'
        jump()         

    def blfoot():
        if STANCE == 0:
            own['requestAction'] = 'reg_blfoot'
        if STANCE == 1:
            own['requestAction'] = 'fak_blfoot'
        jump() 

    def flfoot():
        if STANCE == 0:
            own['requestAction'] = 'reg_flfoot'
        if STANCE == 1:
            own['requestAction'] = 'fak_flfoot'
        jump()  

    def rollsound():
        #onground
        if r_ground.triggered == 1 and grindDar == 0 and own['invert_on'] == 0:
            num1 = .05
            num2 = .25
            if linVelocity.x <= -num1 and linVelocity.x >= num1:
                own.actuators["sroll"].volume = .0001
                cont.deactivate(own.actuators["sroll"])
                own.actuators["sroll"].stopSound()
            if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):   
                own.actuators["sroll"].volume = .02
                own.actuators["sroll"].pitch = .65
            num1 = .25
            num2 = .5
            if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):   
                own.actuators["sroll"].volume = .03
                own.actuators["sroll"].pitch = .7             
            num1 = .5
            num2 = .75
            if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):   
                own.actuators["sroll"].volume = .04
                own.actuators["sroll"].pitch = .75   
            num1 = .75
            num2 = 1
            if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):   
                own.actuators["sroll"].volume = .05
                own.actuators["sroll"].pitch = .8 
            num1 = 1
            num2 = 1.5
            if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):   
                own.actuators["sroll"].volume = .06
                own.actuators["sroll"].pitch = .85             
            num1 = 1.5
            num2 = 2
            if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):   
                own.actuators["sroll"].volume = .07
                own.actuators["sroll"].pitch = .9  
            num1 = 2
            num2 = 3
            if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):   
                own.actuators["sroll"].volume = .08
                own.actuators["sroll"].pitch = .95   
            num1 = 3
            num2 = 4
            if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):   
                own.actuators["sroll"].volume = .09
                own.actuators["sroll"].pitch = 1
            num1 = 4
            num2 = 5
            if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):   
                own.actuators["sroll"].volume = .11
                own.actuators["sroll"].pitch = 1.05                                                                 
            num1 = 5
            num2 = 6
            if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):   
                own.actuators["sroll"].volume = .1
                own.actuators["sroll"].pitch = 1.1 
            own.actuators['sroll'].mode = 2
            cont.activate(own.actuators["sroll"]) 
        if grindDar == 1 or own['invert_on'] == 1:  
            own.actuators["sroll"].volume = .0001  
            cont.deactivate(own.actuators["sroll"])     
            own.actuators["sroll"].stopSound() 
        #in air        
        if r_ground.triggered == False:
            own.actuators["sroll"].volume = .0001
            cont.deactivate(own.actuators["sroll"])     
            own.actuators["sroll"].stopSound()      
        act = cont.actuators["sroll"]
        own['sroll_vol'] = act.volume
        own['sroll_pitch'] = act.pitch    
            
    def wheelroll():
        #still
        if linVelocity.x <= -0.05 and linVelocity.x >= 0.05:
            wheel1.stopAction(2)
            wheel2.stopAction(2)
            wheel3.stopAction(2)
            wheel4.stopAction(2)
        #regular
        if linVelocity.x > 0.05 and linVelocity.x < .5:
            wheel2.playAction("roll1.001", 1,20, layer=2, play_mode=0, speed=.25)
            wheel3.playAction("roll2.001", 1,20, layer=2, play_mode=0, speed=.25)
            wheel4.playAction("roll3.001", 1,20, layer=2, play_mode=0, speed=.25)
            wheel1.playAction("roll4.001", 1,20, layer=2, play_mode=0, speed=.25)
        if linVelocity.x > 0.5 and linVelocity.x < 1:
            wheel2.playAction("roll1.001", 1,20, layer=2, play_mode=1, speed=1)
            wheel3.playAction("roll2.001", 1,20, layer=2, play_mode=1, speed=1)
            wheel4.playAction("roll3.001", 1,20, layer=2, play_mode=1, speed=1)
            wheel1.playAction("roll4.001", 1,20, layer=2, play_mode=1, speed=1)
        if linVelocity.x > 1 and linVelocity.x < 4:
            wheel2.playAction("roll1.001", 1,20, layer=2, play_mode=1, speed=1.5)
            wheel3.playAction("roll2.001", 1,20, layer=2, play_mode=1, speed=1.5)
            wheel4.playAction("roll3.001", 1,20, layer=2, play_mode=1, speed=1.5)
            wheel1.playAction("roll4.001", 1,20, layer=2, play_mode=1, speed=1.5)
        if linVelocity.x > 4:
            wheel2.playAction("roll1.001", 1,20, layer=2, play_mode=1, speed=2)
            wheel3.playAction("roll2.001", 1,20, layer=2, play_mode=1, speed=2)
            wheel4.playAction("roll3.001", 1,20, layer=2, play_mode=1, speed=2)
            wheel1.playAction("roll4.001", 1,20, layer=2, play_mode=1, speed=2)
        #switch
        if linVelocity.x < -0.05 and linVelocity.x > -.5:
            wheel2.playAction("roll1.001", 20,1, layer=2, play_mode=0, speed=.25)
            wheel3.playAction("roll2.001", 20,1, layer=2, play_mode=0, speed=.25)
            wheel4.playAction("roll3.001", 20,1, layer=2, play_mode=0, speed=.25)
            wheel1.playAction("roll4.001", 20,1, layer=2, play_mode=0, speed=.25)
        if linVelocity.x < -0.5 and linVelocity.x > -1:
            wheel2.playAction("roll1.001", 20,1, layer=2, play_mode=1, speed=1)
            wheel3.playAction("roll2.001", 20,1, layer=2, play_mode=1, speed=1)
            wheel4.playAction("roll3.001", 20,1, layer=2, play_mode=1, speed=1)
            wheel1.playAction("roll4.001", 20,1, layer=2, play_mode=1, speed=1)
        if linVelocity.x < -1 and linVelocity > -4:
            wheel2.playAction("roll1.001", 20,1, layer=2, play_mode=1, speed=1.5)
            wheel3.playAction("roll2.001", 20,1, layer=2, play_mode=1, speed=1.5)
            wheel4.playAction("roll3.001", 20,1, layer=2, play_mode=1, speed=1.5)
            wheel1.playAction("roll4.001", 20,1, layer=2, play_mode=1, speed=1.5)       
        if linVelocity.x < -4:
            wheel2.playAction("roll1.001", 20,1, layer=2, play_mode=1, speed=2)
            wheel3.playAction("roll2.001", 20,1, layer=2, play_mode=1, speed=2)
            wheel4.playAction("roll3.001", 20,1, layer=2, play_mode=1, speed=2)
            wheel1.playAction("roll4.001", 20,1, layer=2, play_mode=1, speed=2) 
        
    def turn():   
        #rotamt = .02
        rotamt = dict['turn_rotation']
        linVelocity2 = own.getLinearVelocity(True)
        #speed = .004
        speed = dict['turn_addx']
        manual = 0
        if own['manual_v2'] == 1:     
            manual = 1       
            if abs(linVelocity.x) < 2:
                speed = dict['turn_addx'] + .001
                
        jumpstance = own['jump_stance']
        if lLR > turnsens or lLR < -turnsens:
            own["turn"] = 1
        else:
            own["turn"] = 0
        if lUD > turnsens or lUD < -turnsens:
            own["turnud"] = 1
        else:
            own["turnud"] = 0

        turnVel = .01                
    #light  
    #if manual and grindhit = true  
        if lLR > turnsens and lLR < (turnsens * 1.3) and (grindHit == False or (manual == 1 and grindHit == True)):       
            rotation = [ 0.0, 0.0, (-rotamt)]        
            local = False # use world axis
            own.applyRotation( rotation, local)
        
            if r_ground.triggered == True:
                #print("light turn")
                if STANCE == 0:   
                    own.setLinearVelocity([linVelocity2.x - speed, linVelocity2.y, linVelocity2.z], 1)
                if STANCE == 1:   
                    own.setLinearVelocity([linVelocity2.x + speed, linVelocity2.y, linVelocity2.z], 1)           
        if lLR < -turnsens and lLR > (turnsens * -1.3) and (grindHit == False or (manual == 1 and grindHit == True)):       
            rotation = [ 0.0, 0.0, rotamt]        
            local = False # use world axis
            own.applyRotation( rotation, local) 
            
            if r_ground.triggered == True:
                #print("light turn")
                if STANCE == 0:   
                    own.setLinearVelocity([linVelocity2.x - speed, linVelocity2.y, linVelocity2.z], 1)
                if STANCE == 1:   
                    own.setLinearVelocity([linVelocity2.x + speed, linVelocity2.y, linVelocity2.z], 1)        
    #medium
        if (lLR > (turnsens * 1.3) or dict['kb_ra'] == 2) and (grindHit == False or (manual == 1 and grindHit == True)):
            #turn left
            if rot.z < .4:
                rotation = [ 0.0, 0.0, (-rotamt * 5)] 
            if rot.z < .6 and rot.z > .4:    
                rotation = [ 0.0, 0.0, (-rotamt * 2)]        
            else:
                rotation = [ 0.0, 0.0, (-rotamt * 1.6)]        
            local = True # use world axis
            own.applyRotation( rotation, local)
            if r_ground.triggered == True:
                #print("med turn")
                if STANCE == 0:   
                    own.setLinearVelocity([linVelocity2.x - speed, linVelocity2.y - turnVel, linVelocity2.z], 1)
                if STANCE == 1:   
                    own.setLinearVelocity([linVelocity2.x + speed, linVelocity2.y - turnVel, linVelocity2.z], 1)  
        if (lLR < (-turnsens * 1.3) or dict['kb_la'] == 2) and (grindHit == False or (manual == 1 and grindHit == True)):
            #turn right
            if rot.z < .4:
                rotation = [ 0.0, 0.0, (rotamt * 5)]
            if rot.z < .6 and rot.z > .4:    
                rotation = [ 0.0, 0.0, (rotamt * 2)]             
            else:            
                rotation = [ 0.0, 0.0, (rotamt * 1.6)]        
            local = True # use world axis
            own.applyRotation( rotation, local) 
            if r_ground.triggered == True:
                #print("med turn")
                if STANCE == 0:   
                    own.setLinearVelocity([linVelocity2.x - speed, linVelocity2.y, linVelocity2.z], 1)
                if STANCE == 1:   
                    own.setLinearVelocity([linVelocity2.x + speed, linVelocity2.y, linVelocity2.z], 1)        
             
    #air   
        if r_ground.triggered == False and (lLR > turnsens or dict['kb_ra'] == 2) and (grindHit == False or (manual == 1 and grindHit == True)) and own["wallride"] == None:
            if STANCE == 0:
                own.applyRotation([0,0,-dict['turn_air_rotation']], 1)
            if STANCE == 1:
                own.applyRotation([0,0,-dict['turn_air_rotation']], 1) 
        if r_ground.triggered == False and (lLR < -turnsens or dict['kb_la'] == 2) and (grindHit == False or (manual == 1 and grindHit == True)) and own["wallride"] == None:
            if STANCE == 0:
                own.applyRotation([0,0,dict['turn_air_rotation']], 1)
            if STANCE == 1:
                own.applyRotation([0,0,dict['turn_air_rotation']], 1)                      

    ###########
    def grindsound():
        dropin = own['dropinTimer']
        lif = own['last_invert_frame'] 
        if grindSound != None and grindHit == True and own['nogrindsound'] == 0:    
            if abs(linVelocity.x) > abs(linVelocity.y):
                vel = linVelocity.x
            elif abs(linVelocity.x) < abs(linVelocity.y):
                vel = linVelocity.y    
            else:
                vel = 0    
            if grindSound == "rail":
                cont.deactivate(own.actuators['grind_cement'])
                num1 = .000
                num2 = .05
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_rail"].volume = .0001
                    own.actuators["grind_rail"].pitch = .6
                num1 = .05
                num2 = .25
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_rail"].volume = .05
                    own.actuators["grind_rail"].pitch = .7 
                
                num1 = .25
                num2 = .5
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_rail"].volume = .1
                    own.actuators["grind_rail"].pitch = .75 
                num1 = .5
                num2 = .75
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_rail"].volume = .14
                    own.actuators["grind_rail"].pitch = .8 
                num1 = .75
                num2 = 1
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_rail"].volume = .17
                    own.actuators["grind_rail"].pitch = .85 
                num1 = 1
                num2 = 1.25
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_rail"].volume = .18
                    own.actuators["grind_rail"].pitch = .9      
                num1 = 1.25
                num2 = 2
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_rail"].volume = .19
                    own.actuators["grind_rail"].pitch = .95                                            
                num1 = 2
                num2 = 40
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_rail"].volume = .19
                    own.actuators["grind_rail"].pitch = 1                         
                cont.activate(own.actuators['grind_rail'])           

            if grindSound == "concrete":
            #play sound
                cont.deactivate(own.actuators['grind_rail'])
                num1 = .000
                num2 = .05
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_cement"].volume = .01
                    own.actuators["grind_cement"].pitch = .6
                num1 = .05
                num2 = .25
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_cement"].volume = .05
                    own.actuators["grind_cement"].pitch = .7 
                
                num1 = .25
                num2 = .5
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_cement"].volume = .1
                    own.actuators["grind_cement"].pitch = .75 
                num1 = .5
                num2 = .75
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_cement"].volume = .14
                    own.actuators["grind_cement"].pitch = .8 
                num1 = .75
                num2 = 1
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_cement"].volume = .17
                    own.actuators["grind_cement"].pitch = .85 
                num1 = 1
                num2 = 1.25
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_cement"].volume = .18
                    own.actuators["grind_cement"].pitch = .9      
                num1 = 1.25
                num2 = 2
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_cement"].volume = .19
                    own.actuators["grind_cement"].pitch = .95                                            
                num1 = 2
                num2 = 40
                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):   
                    own.actuators["grind_cement"].volume = .19
                    own.actuators["grind_cement"].pitch = 1 
                cont.activate(own.actuators['grind_cement'])
        else:
            cont.deactivate(own.actuators['grind_cement'])    
            cont.deactivate(own.actuators['grind_rail']) 

    def record_grindsound():
        dropin = own['dropinTimer']
        lif = own['last_invert_frame']     
        if grindHit == True and dropin == 0 and own['invert_on'] == 0 and own["LAST_GRIND"] == True and own["nogrindsound"] == 0 and (frame - lif > 13):
            if grindSound == "concrete":
                act = own.actuators["grind_cement"]
                own['grindcement_vol'] = act.volume
                own['grindcement_pitch'] = act.pitch 
            elif grindSound == "rail":       
                act = own.actuators["grind_rail"]
                own['grindrail_vol'] = act.volume
                own['grindrail_pitch'] = act.pitch
        if own["LAST_GRIND"] == False:    
            own['grindcement_vol'] = 0
            own['grindcement_pitch'] = 0
            own['grindrail_vol'] = 0
            own['grindrail_pitch'] = 0    
        
    def grind():
        grindsound()
        STANCE = own["stance"]
        jumpstance = own["jump_stance"]
        lif = frame - own['last_invert_frame']
        giniter = 0
        if own['LAST_GRIND'] == False and grindHit == True:
            own['grindstartFrame'] = own['framenum']
            giniter = 1
        if grindHit == True and own['invert_on'] == 0 and own['footplant_on'] == False and own['manual'] == 0 and lif > 40 and own['dropinTimer'] < 30 and giniter == 0: 
            
            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               
             
            gblend = 1    
            if LAST_GRIND == 0:
                gt = own['grindType']
            tempstance = 3
            if jumpstance != 3:
                tempstance = jumpstance
            else:
                tempstance = STANCE  
            grindpos = own['grindpos']
            if grindpos == "reg_5050" and own['grindType'] == "empty":
                own['grindType'] = grindpos
            if own['grindType'] == "empty" and grindpos == 'reg_board':
                if STANCE == 0:
                    own['grindType'] = "reg_bsboard"
                else:
                    own['grindType'] = "fak_bsboard"    
        
            if STANCE == True:    
                if own['grindType'] == "reg_bsboard":
                    own['grind_stance'] = 0
                    own['requestAction'] = 'reg_bsboard'
                elif own['grindType'] == "fak_bsboard":
                    own['grind_stance'] = 1
                    own['requestAction'] = 'fak_bsboard'
                elif own['grindType'] == "reg_fsboard":
                    own['grind_stance'] = 0
                    own['requestAction'] = 'reg_fsboard'               
                elif own['grindType'] == "fak_noseg":
                    own['requestAction'] = 'fak_noseg'                
                elif own['grindType'] == "fak_nosegR": 
                    own['requestAction'] = 'fak_nosegr'               
                elif own['grindType'] == "fak_nosegL":
                    own['requestAction'] = 'fak_nosegl'                
                elif own['grindType'] == "fak_tailg":
                    own['requestAction'] = 'fak_tailg' 
                elif own['grindType'] == "fak_tailgR": 
                    own['requestAction'] = 'fak_tailgr'
                elif own['grindType'] == "fak_tailgL":
                    own['requestAction'] = 'fak_tailgl'
                
                elif own['grindType'] == "reg_tailg":
                    own['requestAction'] = 'fak_noseg'
                elif own['grindType'] == "reg_tailgR":
                    own['requestAction'] = 'fak_nosegr'
                elif own['grindType'] == "reg_tailgL":
                    own['requestAction'] = 'fak_nosegl'
                elif own['grindType'] == "reg_noseg":
                    own['requestAction'] = 'fak_tailg'                
                elif own['grindType'] == "reg_nosegR":
                    own['requestAction'] = 'fak_tailgr'                
                elif own['grindType'] == "reg_nosegL":
                    own['requestAction'] = 'fak_tailgl'                        
                    
                elif own['grindType'] == "reg_tailslide":
                    own['requestAction'] = 'reg_tailslide'
                elif own['grindType'] == "reg_noseslide":
                    own['requestAction'] = 'reg_noseslide' 
                elif own['grindType'] == "fak_tailslide":
                    own['requestAction'] = 'fak_tailslide'
                elif own['grindType'] == "fak_noseslide":
                    own['requestAction'] = 'fak_noseslide'                     
                
                elif own['grindType'] == "reg_tailslide" and edge == 1:
                    own['requestAction'] = 'fak_noseslide'  
                    STANCE = 0                
                elif own['grindType'] == "fak_tailslide":
                    own['requestAction'] = 'fak_tailslide'                
                    own['grind_stance'] = 1
                elif own['grindType'] == "reg_noseslide" and edge == 1:
                    own['requestAction'] = 'fak_tailslide'  
                    own['grind_stance'] = 0
                elif own['grindType'] == "fak_noseslide":
                    own['requestAction'] = 'fak_noseslide'  
                    own['grind_stance'] = 1               
                else:
                    if STANCE == 0:
                        own['requestAction'] = 'reg_5050'
                        dict['trick_string'] = '5050'
                    if STANCE == 1:
                        own['requestAction'] = 'fak_5050'
                        dict['trick_string'] = '5050'
                
            elif STANCE == False:
                if own['grindType'] == "reg_bsboard":
                    own['grind_stance'] = 0
                    own['requestAction'] = 'reg_bsboard'
                elif own['grindType'] == "fak_bsboard":
                    own['grind_stance'] = 1
                    own['requestAction'] = 'fak_bsboard'
                elif own['grindType'] == "reg_tailg":
                    own['grind_stance'] = 0
                    own['requestAction'] = 'reg_tailg'
                elif own['grindType'] == "reg_tailgR":
                    own['requestAction'] = 'reg_tailgr'
                elif own['grindType'] == "reg_tailgL":
                    own['requestAction'] = 'reg_tailgl'
                elif own['grindType'] == "reg_noseg":
                    own['requestAction'] = 'reg_noseg'
                elif own['grindType'] == "reg_nosegR":
                    own['requestAction'] = 'reg_nosegr'             
                elif own['grindType'] == "reg_nosegL":
                    own['requestAction'] = 'reg_nosegl'              
                elif own['grindType'] == "reg_tailslide":
                    own['requestAction'] = 'reg_tailslide'
                elif own['grindType'] == "reg_noseslide":
                    own['requestAction'] = 'reg_noseslide' 
                elif own['grindType'] == "fak_tailslide":
                    own['requestAction'] = 'fak_tailslide'
                elif own['grindType'] == "fak_noseslide":
                    own['requestAction'] = 'fak_noseslide'                                        
                    
                elif own['grindType'] == "fak_noseg":
                    own['requestAction'] = 'reg_tailg'
                elif own['grindType'] == "fak_nosegR": 
                    own['requestAction'] = 'reg_tailgr'               
                elif own['grindType'] == "fak_nosegL":
                    own['requestAction'] = 'reg_tailgl'                
                elif own['grindType'] == "fak_tailg":
                    own['requestAction'] = 'reg_noseg'
                elif own['grindType'] == "fak_tailgR": 
                    own['requestAction'] = 'reg_nosegr'
                elif own['grindType'] == "fak_tailgL":
                    own['requestAction'] = 'reg_nosegl'                     
                    
                elif own['grindType'] == "fak_tailslide" and edge == 1:
                    own['grind_stance'] = 1
                    own['requestAction'] = 'reg_noseslide'
                elif own['grindType'] == "reg_noseslide":
                    own['grind_stance'] = 0
                    own['requestAction'] = 'reg_noseslide'
                elif own['grindType'] == "fak_noseslide" and edge == 1:  
                    own['grind_stance'] = 1              
                    own['requestAction'] = 'reg_tailslide'                                
                else:
                    if STANCE == 0:
                        own['requestAction'] = 'reg_5050'
                    if STANCE == 1:
                        own['requestAction'] = 'fak_5050'
                        
                        
            if 'fak' in own['l_actionState']:
                STANCE = 1
                own['lg_stance'] = 1
                lg_stance = 1
            if 'reg' in own['l_actionState']:
                STANCE = 0 
                own['lg_stance'] = 0
                lg_stance = 0              
            own['stance'] = STANCE                         
                      
    def rotmult():
        if r_ground.triggered:
            num = ((rot.z * -1) +1)
            num = num * 100

    def airup():
        if r_ground.triggered == False:
            pos = own.worldPosition
            pos = own.worldPosition.z
            last_pos = own['last_posz']
            if last_pos - pos > 0:
                own['airup'] = 0
            if last_pos - pos < 0:    
                own['airup'] = 1
            if pos > own['last_posz']:
                own["air_height"] = pos  
            own['last_posz'] = pos   
        else:
            own['airup'] = 0  
              
    def onramp():
        if r_ground.positive:
            if 'ramp' in r_ground.hitObject:
                own['onramp'] = 60
                own['last_ramp'] = frame
                own['no_grind_timer'] = 60 
                #print('on ramp')
            else:
                own['onramp'] = 0 
                 
        else:
            
            if own['onramp'] > 0:
                own['onramp'] -= 1  
    
    def grindtype(gtype):
        own['grindType'] = gtype
        
    def transmult():
        lastrotz = own["rotz"]
        linvel = own.getLinearVelocity(True)
        newx = (linvel.x + (linvel.x * .039))
        if linvel.x < 7 and linvel.x > -7 and rot.z > lastrotz and r_ground.triggered == 1 and rot.z > .3 and rot.z < .93:
            own.setLinearVelocity([newx, linvel.y, linvel.z], True)    
            
    def speedmult():
        vel = own.getLinearVelocity(True)
        xyz = own.worldOrientation.to_euler()
        roty = math.degrees(xyz[1])     
        roty = abs(roty) 
        roty = roty * .0005
        
        if abs(vel.x) > 1:
            mult = .0015 + roty
        else:
            mult = .000       
        mult2 = .018
        mult3 = .007
        lastrotz = own["rotz"]
        x = vel.x * mult
        x2 = x + vel.x
        x3 = vel.x * mult2
        x4 = x3 + vel.x
        x5 = vel.x * mult3
        x6 = x5 + vel.x
        if r_ground.triggered and vel.x < 4 and vel.x > -4:
            own.setLinearVelocity([x2, vel.y, vel.z], True)

    def coping():
        if invertTouch.positive:
            own["coping"] = 1
        else:
            own["coping"] = 0    

    def onboard():
        if own['walk'] == 1 and own['lasty'] == False and own['requestAction'] not in ['reg_dropin', 'fak_dropin']:
            cont.deactivate(cam.actuators['replayCam'])
            cont.activate(cam.actuators['Camera'])
            killall()
            walklay = 40 
            ob_speed = .5
            if STANCE == 0:
                killall() 
                if own['dropinCol'] == True:
                    own['requestAction'] = 'reg_dropin'
                    own['dropinTimer'] = 60
                else:
                    own['requestAction'] = 'reg_onboard'    
                    force = (linVelocity.x -1, linVelocity.y, linVelocity.z)
                    if own['dropinTimer'] == 0:
                        own.setLinearVelocity(force, True)
            if STANCE == 1:
                killall() 
                if own['dropinCol'] == True:
                    own['requestAction'] = 'fak_dropin'
                    own['dropinTimer'] = 60
                else: 
                    own['requestAction'] = 'fak_onboard'
                    force = (linVelocity.x +1, linVelocity.y, linVelocity.z)
                    if own['dropinTimer'] == 0:
                        own.setLinearVelocity(force, True)                    
                        
        else:
            num = own['dropinTimer']
            if num > 0:
                num = num - 1
            own['dropinTimer'] = num            
            
    def offboard():
            wheel1.stopAction(2)
            wheel2.stopAction(2)
            wheel3.stopAction(2)
            wheel4.stopAction(2)    
            cont.deactivate(own.actuators["sroll"])
            sact = own.actuators["sroll"]
            sact.volume = .0001   
            own.actuators["sroll"].stopSound()
            own['offboard_vel'] = own.linearVelocity
            own['walk_timer'] = 0               
        
    def resetjumpstance():
        if LAST_GRIND == True and grindHit == False:
            own["lF_ground_frame"] = own['framenum']
            lfg = own["lF_ground_frame"]
            #print(lfg, "----- this?")  
            if own['jump_stance'] != 3:
                own['jump_stance'] = 3
        
    def grass():
        try:
            if 'grass' in r_ground.hitObject:
                linVel = own.getLinearVelocity(True)
                linvelx = linVel.x * dict['grass_mult']
                own.setLinearVelocity((linvelx, linVel.y, linVel.z), 1)
        except:
            pass    

    def grindoutair():
        skippy = 0
        linVel = own.getLinearVelocity(True)
        STANCE = own['stance']
        if own['LAST_GRIND'] == True and grindHit == True:
            own['lg_stance'] = STANCE
        lg_stance = own['lg_stance']
        own.actuators["grindoutair"].useLocalLinV = True        
        if own['grindjumpturn'] == True and own['grindCountdown'] > 12 and skippy == 0: 
            if 'fak' in own['l_actionState']:
                STANCE = 1
                own['lg_stance'] = 1
                lg_stance = 1
                #print('changing stance 1')
            if 'reg' in own['l_actionState']:
                STANCE = 0 
                own['lg_stance'] = 0
                lg_stance = 0
                #print('changing stance 0') 
            own['stance'] = STANCE                                        
            grindoutspeed = .1  
            grindoutspeed2 = 5.4  
            if lLR > turnsens:
                if own['last_grindpos'] == 'reg_5050':
                    if STANCE == 0:
                        own.actuators["grindoutair"].linV = [0, grindoutspeed, 0]                    
                    else:
                        own.actuators["grindoutair"].linV = [0, -grindoutspeed, 0] 
                    cont.activate(own.actuators["grindoutair"]) 

            if lLR < -turnsens:
                if own['last_grindpos'] == 'reg_5050':
                    if STANCE == 0:
                        own.actuators["grindoutair"].linV = [0, -grindoutspeed, 0]
                    else: 
                        own.actuators["grindoutair"].linV = [0, grindoutspeed, 0] 
                    cont.activate(own.actuators["grindoutair"])
            if lUD > turnsens:
                js = own['lg_stance']
                linvelx = own.getLinearVelocity(True)                
                if own['last_grindpos'] == 'reg_board':
                    if js == 1:
                       own.actuators["grindoutair"].linV = [-grindoutspeed, 0, 0]
                       cont.activate(own.actuators["grindoutair"])
                    else:
                        own.actuators["grindoutair"].linV = [grindoutspeed, 0, 0] 
                        cont.activate(own.actuators["grindoutair"]) 
            if lUD < -turnsens:  
                js = own['lg_stance']      
                if own['last_grindpos'] == 'reg_board':    
                    if js == 0:
                        own.actuators["grindoutair"].linV = [-grindoutspeed, 0, 0]
                        cont.activate(own.actuators["grindoutair"])
                    else:
                        own.actuators["grindoutair"].linV = [grindoutspeed, 0, 0]
                        cont.activate(own.actuators["grindoutair"])
                    
        if LAST_GRIND == False and r_ground.triggered and own['grindjumpturn'] == True and own['grindCountdown'] < 1:
            own['grindjumpturn'] = False
        if r_ground.triggered:
            own['grind_jump'] = False 
        
        if own['grindjumpturn'] == False or own['grindCountdown'] < 19:
            cont.deactivate(own.actuators["grindoutair"])
    #print(STANCE)
    def set_last_grindpos():
        if own['grindpos'] != None:
            own['last_grindpos'] = own['grindpos']
    def air_pos():
        grindpos = own['grindpos']
        GRAB_ON = own["GRAB_ON"]
        wr = own["wallride"]
        jump_timer = own['jump_timer']
        if rUD > .040 and r_ground.triggered == False and GRAB_ON == False and wr == None and jump_timer < 30:
            if STANCE == 0:
                own['requestAction'] = 'reg_air_tail' 
            else:
                own['requestAction'] = 'fak_air_tail' 
        elif rUD < -.040 and r_ground.triggered == False and GRAB_ON == False and wr == None and jump_timer < 30:
            if STANCE == 0:
                own['requestAction'] = 'reg_air_nose' 
            else:
                own['requestAction'] = 'fak_air_nose' 

    def air_turn_boost():
        pass

    def revert():
        own["Q3oncdl"] = 0
        own["Q4oncdl"] = 0
        own["Q5oncdl"] = 0
        own["Q6oncdl"] = 0
        own["Q7oncdl"] = 0
        local = True
        rot = [ 0.0, 0.0, 3.14]
        own.applyRotation(rot,local)
        framenum = own['framenum']
        last_ground_frame = own['lF_ground_frame']
        lF_air_frame = own['lF_air_frame']
        frames_since_ground = framenum - lF_air_frame    
        if own['manual_v2_type'] == 'reg manual': 
            own['requestAction'] = 'reg_manual_revert_ccw'   
        elif own['manual_v2_type'] == 'reg nose manual':
            own['requestAction'] = 'reg_nmanual_revert_ccw'              
        elif own['manual_v2_type'] == 'fak manual': 
            own['requestAction'] = 'fak_manual_revert_ccw'   
        elif own['manual_v2_type'] == 'fak nose manual': 
            own['requestAction'] = 'fak_nmanual_revert_ccw'            
        else:
            if STANCE == 0:
                own['requestAction'] = 'revert1'            
            else:
                own['requestAction'] = 'fak_revert1'           
        own['revert_timer'] = 20 
        cont.activate(own.actuators["revertSound"]) 
        own['revert_sound'] = 1 
        dict['trick_string'] = 'Revert'

    def revert2():
        own["Q3oncdl"] = 0
        own["Q4oncdl"] = 0
        own["Q5oncdl"] = 0
        own["Q6oncdl"] = 0
        own["Q7oncdl"] = 0 
        local = True
        rot = [ 0.0, 0.0, -3.14]
        own.applyRotation(rot,local)
        if own['manual_v2_type'] == 'reg manual': 
            own['requestAction'] = 'reg_manual_revert_cw'   
        elif own['manual_v2_type'] == 'reg nose manual':    
            own['requestAction'] = 'reg_nmanual_revert_cw'            
        elif own['manual_v2_type'] == 'fak manual':    
            own['requestAction'] = 'fak_manual_revert_cw'
        elif own['manual_v2_type'] == 'fak nose manual':    
            own['requestAction'] = 'fak_nmanual_revert_cw'
        else:     
            if STANCE == 0:
                own['requestAction'] = 'revert2'       
            else:
                own['requestAction'] = 'fak_revert2'                           
        own['revert_timer'] = 20 
        cont.activate(own.actuators["revertSound"])   
        own['revert_sound'] = 1 
        dict['trick_string'] = 'Revert'

    def revert3():
        own["Q7oncdl"] = 0
        own["Q8oncdl"] = 0
        own["Q1oncdl"] = 0
        own["Q2oncdl"] = 0
        own["Q3oncdl"] = 0
        local = True
        rot = [ 0.0, 0.0, 3.14]
        own.applyRotation(rot,local)  
        if own['manual_v2_type'] == 'reg manual':  
            own['requestAction'] = 'reg_manual_revert_ccw'  
        elif own['manual_v2_type'] == 'reg nose manual':    
            own['requestAction'] = 'reg_nmanual_revert_ccw'            
        elif own['manual_v2_type'] == 'fak manual': 
            own['requestAction'] = 'fak_manual_revert_ccw'   
        elif own['manual_v2_type'] == 'fak nose manual':
            own['requestAction'] = 'fak_nmanual_revert_ccw'    
        else:  
            if STANCE == 0:     
                own['requestAction'] = 'revert3' 
            else:
                own['requestAction'] = 'fak_revert1'     
        own['revert_timer'] = 20 
        cont.activate(own.actuators["revertSound"]) 
        own['revert_sound'] = 1  
        dict['trick_string'] = 'Revert'

    def revert4():
        own["Q7oncdl"] = 0
        own["Q8oncdl"] = 0
        own["Q1oncdl"] = 0
        own["Q2oncdl"] = 0
        own["Q3oncdl"] = 0
        local = True
        rot = [ 0.0, 0.0, 3.14]
        own.applyRotation(rot,local)  
        if own['manual_v2_type'] == 'reg manual':    
            own['requestAction'] = 'reg_manual_revert_cw'
        elif own['manual_v2_type'] == 'reg nose manual':    
            own['requestAction'] = 'reg_nmanual_revert_cw'           
        elif own['manual_v2_type'] == 'fak manual':    
            own['requestAction'] = 'fak_manual_revert_cw'
        elif own['manual_v2_type'] == 'fak nose manual':    
            own['requestAction'] = 'fak_nmanual_revert_cw'
        else:
            if STANCE == 0:
                own['requestAction'] = 'revert4'
            else:
                own['requestAction'] = 'fak_revert2'           
        own['revert_timer'] = 20 
        cont.activate(own.actuators["revertSound"]) 
        own['revert_sound'] = 1      
        dict['trick_string'] = 'Revert'

    def powerslide():
        own['powerslide_counter'] = own['powerslide_counter'] + 1
        since_walk = own['framenum'] - own['last_walk_frame']
        since_grind = own['framenum'] - own['last_grind_frame']
        if own['powerslide_counter'] > 15 and since_walk > 100 and since_grind > 40:
            own['powerslide_on'] = 1
            if STANCE == 0:
                own['powerslide'] = "reg2"
            if STANCE == 1:
                own['powerslide'] = "fak1" 
            linVelocity4 = own.getLinearVelocity(True)    
            if own['powerslide_counter'] > 15 and own['powerslide_counter'] < 18:         
                newx = linVelocity4.x * .9 
            else:
                newx = linVelocity4.x * .98        
            force = [newx, linVelocity4.y, linVelocity4.z]
            own.setLinearVelocity(force, True)
    def powerslide2():
        own['powerslide_counter'] = own['powerslide_counter'] + 1
        since_walk = own['framenum'] - own['last_walk_frame']
        since_grind = own['framenum'] - own['last_grind_frame']
        if own['powerslide_counter'] > 15 and since_walk > 100 and since_grind > 100:
            own['powerslide_on'] = 1
            if STANCE == 0:
                own['powerslide'] = "reg1"
            if STANCE == 1:
                own['powerslide'] = "fak2" 
            linVelocity4 = own.getLinearVelocity(True)    
            if own['powerslide_counter'] > 15 and own['powerslide_counter'] < 18:         
                newx = linVelocity4.x * .9 
            else:
                newx = linVelocity4.x * .98        
            force = [newx, linVelocity4.y, linVelocity4.z]
            own.setLinearVelocity(force, True)        
    
    def powerslide_state():
        if own['powerslide_on'] == 1:   
            if own['powerslide'] == "reg2":                               
                own['requestAction'] = 'reg_fs_powerslide'
            if own['powerslide'] == "fak1":                               
                own['requestAction'] = 'fak_fs_powerslide'
            if own['powerslide'] == "reg1":                               
                own['requestAction'] = 'reg_powerslide'
            if own['powerslide'] == "fak2":                               
                own['requestAction'] = 'fak_powerslide'    

    def powerslide_sound():
        sact = own.actuators["powerslide_sound"]
        if own['powerslide_on'] == 1:
            sact = own.actuators["powerslide_sound"]
            sact.volume = .2
            new_pitch = (abs(linVelocity.x) / 3)
            if new_pitch < 1.1 and new_pitch > .5: 
                sact.pitch = new_pitch
            elif new_pitch <= .5:
                sact.pitch = .5
            else:
                sact.pitch = 1.1    
            cont.activate(own.actuators["powerslide_sound"])
        else:
            sact.volume = .0
            cont.deactivate(own.actuators["powerslide_sound"])
                                   
    def check_powerslide():
        try:
            own['last_powerslide_on'] = own['powerslide_on']
        except:
            pass 
        psxvel = abs(linVelocity.x)
        if (lUD > .08 or lUD < -.08) and own['manual_v2'] == False and r_ground.triggered == True and psxvel > .1 and own["Pump"] == False:
            if lUD > .08:
                powerslide()
            else:
                powerslide2()    
        else:
            own['powerslide_on'] = 0
            own['powerslide_counter'] = 0
            if own['last_powerslide_on'] == 0:    
                own['powerslide'] = None              

    def killopos():
        pass    
    

                    
    stopAnims() 
    #nextframe()  
    air() 
    stance()
    turn()
    #rotmult()
    airup()
    onramp()
    #speedmult()
    coping()
    resetjumpstance()
    grass()
    grindoutair()
    set_last_grindpos()
    air_pos()
    air_turn_boost()
    record_grindsound()
    check_powerslide()
    powerslide_state()
    powerslide_sound()
    killopos()
    grind()
    #onboard()    




    ##################
    ###realcontrols###
    ##################
    #       q1
    #    q8    q2
    # q7          q3
    #    q6    q4
    #       q5
    ##################
    #lq6
    if lUD > .04 and lLR < -0.04 :
        lq6on = 1
        q6oncdl = countdown
        own["Q6oncdl"] = q6oncdl
    elif q6oncdl > 0:
        lq6on = 0
        q6oncdl = q6oncdl - 1
        own["Q6oncdl"] = q6oncdl
    #lq8
    if lUD < -.04 and lLR < -0.04 :
        lq8on = 1
        q8oncdl = countdown
        own["Q8oncdl"] = q8oncdl
    elif q8oncdl > 0:
        lq8on = 0
        q8oncdl = q8oncdl - 1
        own["Q8oncdl"] = q8oncdl
    #lq2
    if lUD < -.04 and lLR > 0.04 :
        lq2on = 1
        q2oncdl = countdown
        own["Q2oncdl"] = q2oncdl
    elif q2oncdl > 0:
        lq2on = 0
        q2oncdl = q2oncdl - 1
        own["Q2oncdl"] = q2oncdl
    #q4
    if lUD > 0.04 and lLR > 0.04 :
        lq4on = 1
        q4oncdl = countdown
        own["Q4oncdl"] = q4oncdl
    elif q4oncdl > 0:
        lq4on = 0
        q4oncdl = q4oncdl - 1
        own["Q4oncdl"] = q4oncdl  
    #q5
    if lUD > .070 and lq4on == 0 and lq6on == 0:
        lq5on = 1
        q5oncdl = countdown
        own["Q5oncdl"] = q5oncdl
    elif q5oncdl > 0:
        lq5on = 0
        q5oncdl = q5oncdl - 1
        own["Q5oncdl"] = q5oncdl   
    #q1    
    if lUD < -0.070 and lq8on !=1 and lq2on != 1:
        lq1on = 1
        q1oncdl = countdown
        own["Q1oncdl"] = q1oncdl           
    elif q1oncdl > 0:
        lq1on = 0
        q1oncdl = q1oncdl - 1
        own["Q1oncdl"] = q1oncdl   
    #q7
    if lLR < -0.070 and lq8on != 1 and lq6on != 1:
        lq7on = 1
        q7oncdl = countdown
        own["Q7oncdl"] = q7oncdl     
    elif q7oncdl > 0:
        lq7on = 0
        q7oncdl = q7oncdl - 1
        own["Q7oncdl"] = q7oncdl  
    #q3    
    if lLR > 0.070 and lq2on !=1 and lq4on != 1:
        lq3on = 1
        q3oncdl = countdown
        own["Q3oncdl"] = q3oncdl
    elif q3oncdl > 0:
        lq3on = 0
        q3oncdl = q3oncdl - 1
        own["Q3oncdl"] = q3oncdl       

    own['set_revert_timer'] = 0
    ground_since = own["framenum"] - own['lF_air_frame']
    if ground_since > 80 and frames_since_grinding > 40 and rLR > -turnsens and rLR < turnsens and rUD > -turnsens and rUD < turnsens:

        if q3oncdl < q4oncdl < q5oncdl < q6oncdl < q7oncdl:
            if r_ground.triggered == True:
                revert()
                own['set_revert_timer'] = 1
        if q3oncdl > q4oncdl > q5oncdl > q6oncdl > q7oncdl:
            if r_ground.triggered == True:
                revert2()
                own['set_revert_timer'] = 1
        if q7oncdl < q8oncdl < q1oncdl < q2oncdl < q3oncdl:
            if r_ground.triggered == True:
                revert3()
                own['set_revert_timer'] = 1
        if q7oncdl > q8oncdl > q1oncdl > q2oncdl > q3oncdl:
            if r_ground.triggered == True:
                revert4()
                own['set_revert_timer'] = 1           
    ################
    #q6
    if rUD > .04 and rLR < -0.04 :
        q6on = 1
        q6oncd = countdown
        own["Q6oncd"] = q6oncd
        #print("q6on")
    elif q6oncd > 0:
        q6on = 0
        q6oncd = q6oncd - 1
        own["Q6oncd"] = q6oncd
        
    #q8
    if rUD < -.04 and rLR < -0.04 :
        q8on = 1
        q8oncd = countdown
        own["Q8oncd"] = q8oncd
        #print("q8on")
    elif q8oncd > 0:
        q8on = 0
        q8oncd = q8oncd - 1
        own["Q8oncd"] = q8oncd
    #q2
    if rUD < -.04 and rLR > 0.04 :
        q2on = 1
        q2oncd = countdown
        own["Q2oncd"] = q2oncd
        #print("q2on")
    elif q2oncd > 0:
        q2on = 0
        q2oncd = q2oncd - 1
        own["Q2oncd"] = q2oncd
        
    #q4
    if rUD > 0.04 and rLR > 0.04 :
        q4on = 1
        q4oncd = countdown
        own["Q4oncd"] = q4oncd
        #print("q4on")
    elif q4oncd > 0:
        q4on = 0
        q4oncd = q4oncd - 1
        own["Q4oncd"] = q4oncd
    #q5
    if rUD > .070 or dict['kb_space'] == 2:
        if q4on == 0 and q6on == 0:
            #print("q5on")
            q5on = 1
            q5oncd = countdown
            own["Q5oncd"] = q5oncd
        oposin()  
        #print('oposin')
    ground_since = own["framenum"] - own['lF_air_frame']    
    if ((rTrig > 0.02 or dict['kb_lsh'] == 2) and GRAB_ON == False and r_ground.triggered == 1) or (lTrig > 0.02 and GRAB_ON == False and r_ground.triggered == 1) and ground_since > 10:
        pump()
    else:
        own["lastPump"] = False 
        own["Pump"] = False     
    own['jump_stance'] = STANCE     
    if rUD > .02 and grindHit == True:    
        grindpos = own['grindpos']   
        jumpstance = own["jump_stance"]
        if LAST_GRIND == False:    
            if grindpos == "reg_stall":
                grindtype("nose_stall") #change
            elif grindpos == "fak_stall":
                grindtype("nose_stall")
            elif grindpos == "reg_5050":  
                if jumpstance != 3:
                    if jumpstance == 0:
                        if rLR > .03:
                            grindtype("reg_tailgR")
                        elif rLR < -.03:
                            grindtype("reg_tailgL")
                        else:                        
                            grindtype("reg_tailg")
                    if jumpstance == 1:
                        if rLR > .03:
                            grindtype("fak_tailgR")
                        elif rLR < -.03:
                            grindtype("fak_tailgL")
                        else:                        
                            grindtype("fak_tailg")
                else:
                    if STANCE == 0:
                        if rLR > .03:
                            grindtype("reg_tailgR")
                        elif rLR < -.03:
                            grindtype("reg_tailgL")
                        else:        
                            grindtype("reg_tailg")
                    if STANCE == 1:
                        grindtype("fak_tailg")                                 
            elif grindpos == "reg_board":
                if jumpstance != 3:
                    if jumpstance == 0:
                        grindtype("reg_tailslide")
                    if jumpstance == 1:
                        grindtype("fak_tailslide") 
                    STANCE = jumpstance
                    own['stance'] = STANCE       
                else:        
                    if STANCE == 0:
                        grindtype("reg_tailslide")
                    if STANCE == 1:
                        grindtype("fak_tailslide")    
            else:
                if jumpstance == 0:
                    grindtype("reg_tailg")
                if jumpstance == 1:
                    grindtype("fak_tailg")   
                         
    if q5oncd > 0:
        q5on = 0
        q5oncd = q5oncd - 1
        own["Q5oncd"] = q5oncd 
        own["last_Opos"] = False
    #q1    
    if rUD < -0.070:
        if q2on == 0 and q8on == 0:
            #print("q1on")
            q1on = 1
            q1oncd = countdown
            own["Q1oncd"] = q1oncd
        noposin()
    if rUD < -0.020 and grindHit == True:    
        grindpos = own['grindpos']
        jumpstance = own["jump_stance"]
        if LAST_GRIND == False:       
            if grindpos == "reg_5050":
                #print("nose something")
                if jumpstance != 3:  
                    if jumpstance == 0:
                        if rLR > .02:
                            grindtype("reg_nosegR")
                        elif rLR < -.02:
                            grindtype("reg_nosegL")    
                        else:   
                            grindtype("reg_noseg")
                    if jumpstance == 1:
                        if rLR > .02:
                            grindtype("fak_nosegR")
                        elif rLR < -.02:
                            grindtype("fak_nosegL")
                        else:
                            grindtype("fak_noseg")   
                else:
                    if STANCE == 0:
                        if rLR > .02:
                            grindtype("reg_nosegR")
                        elif rLR < -.02:
                            grindtype("reg_nosegL")    
                        else:                    
                            grindtype("reg_noseg")
                    if STANCE == 1:
                        if rLR > .02:
                            grindtype("fak_nosegR")
                        elif rLR < -.02:
                            grindtype("fak_nosegL")  
                        else:    
                            grindtype("fak_noseg")        
            elif grindpos == "reg_board":
                if jumpstance != 3:
                    if jumpstance == 0:
                        grindtype("reg_noseslide")    
                    if jumpstance == 1:
                        grindtype("fak_noseslide") 
                    STANCE = jumpstance    
                    own['stance'] = STANCE    
                else:
                    if STANCE == 0:
                        grindtype("reg_noseslide")
                    if STANCE == 1:
                        grindtype("fak_noseslide")               

    if rUD > -0.020 and rUD <= .020 and LAST_GRIND == False:
        if own['grindpos'] == 'reg_5050':
            grindtype("reg_5050")
        if own['grindpos'] == 'fak_5050':
            grindtype("fak_5050")
            
    if q1oncd > 0:
        q1on = 0
        q1oncd = q1oncd - 1
        own["Q1oncd"] = q1oncd
        own["last_nOpos"] = False      
    #q7
    if rLR < -0.070:
        if q8on == 0 and q6on == 0:
            q7on = 1
            q7oncd = countdown
            own["Q7oncd"] = q7oncd           
    elif q7oncd > 0:
        q7on = 0
        q7oncd = q7oncd - 1
        own["Q7oncd"] = q7oncd
    #q3    
    if rLR > 0.070:
        if q4on == 0 and q2on == 0:
            q3on = 1
            q3oncd = countdown
            own["Q3oncd"] = q3oncd
            #print("q3on")
    elif q3oncd > 0:
        q3on = 0
        q3oncd = q3oncd - 1
        own["Q3oncd"] = q3oncd

###keyboard fliptricks
    if dict['kb_space'] == 3:
        if dict['kb_a'] == 2:
            kickflip()
        elif dict['kb_d'] == 2:
            heelflip()    
        elif dict['kb_w'] == 2:
            fsshuvit()
        elif dict['kb_s'] == 2:
            shuvit()            
        else:
            aollie()    


##########################################
    #trick calls
##########################################

    # hard flip
    # 6 > 5 > 8
    if q6oncd > 0 and q5oncd > 0 and q8oncd > 0 and q6oncd <= q5oncd <= q8oncd:
        print ("Hardflip")
        dict['trick_string'] = 'Hardflip'
        hardflip()
        reset_rtimers() 
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0            

    # inward heelflip
    # 4 > 5 > 2
    if q4oncd > 0 and q5oncd > 0 and q2oncd > 0 and q4oncd <= q5oncd <= q2oncd:
        print ("Inward Heelflip")
        dict['trick_string'] = 'Inward Heelflip'
        inward_heelflip()
        reset_rtimers()     
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0 

    # nollie hard flip
    # 8 > 1 > 6
    if q8oncd > 0 and q1oncd > 0 and q6oncd > 0 and q8oncd <= q1oncd <= q6oncd:
        print ("Nollie Hardflip")
        dict['trick_string'] = 'Nollie Hardflip'
        nollie_hardflip()
        reset_rtimers()
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0 
    
    # nollie inward heelflip
    # 2 > 1 > 4
    if q2oncd > 0 and q1oncd > 0 and q4oncd > 0 and q2oncd <= q1oncd <= q4oncd:
        print ("Nollie Inward Heelflip")
        dict['trick_string'] = 'Nollie Inward Heelflip'
        nollie_inward_heelflip()
        reset_rtimers()    
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0 

    #nollie 360 shuvit
    if q7oncd > 0 and q8oncd > 0 and q1oncd > 0 and q2oncd > 0 and q3oncd > 0 and q7oncd <= q8oncd <= q1oncd <= q2oncd <= q3oncd:
        print ("Nollie 360 shuvit")
        dict['trick_string'] = 'Nollie 360 shuvit'
        nollie_shuvit360()
        reset_rtimers()
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0 

    #nollie fs 360 shuvit
    if q7oncd > 0 and q8oncd > 0 and q1oncd > 0 and q2oncd > 0 and q3oncd > 0 and q3oncd <= q2oncd <= q1oncd <= q8oncd <= q7oncd:
        #print("q4oncd: ", q4oncd, " q5oncd: ", q5oncd, " q6oncd: ", q6oncd)
        print ("Nollie Front Side 360 shuvit")
        dict['trick_string'] = 'Nollie FS 360 shuvit'
        nollie_fsshuvit360()
        reset_rtimers()   
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0 

    # varial heelflip
    # 7 < 6 < 2
    if q7oncd > 0 and q6oncd > 0 and q2oncd > 0 and q7oncd < q6oncd < q2oncd:
        dict['trick_string'] = 'Varial Heelflip'
        varial_heelflip()
        reset_rtimers()
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0

    # varial kickflip 
    # 3 < 4 < 8
    if q3oncd > 0 and q4oncd > 0 and q8oncd > 0 and q3oncd < q4oncd < q8oncd:
        dict['trick_string'] = 'Varial Kickflip'
        varial_kickflip()
        reset_rtimers()
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0 

    # nollie varial kickflip
    # 3 < 2 < 6
    if q3oncd > 0 and q2oncd > 0 and q6oncd > 0 and q3oncd <= q2oncd <= q6oncd:
        dict['trick_string'] = 'Nollie Varial Kickflip'
        print('Nollie Varial Kickflip')
        nollie_varial_kickflip()
        reset_rtimers()   
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0         

    # nollie varial heelflip
    # 7 < 8 < 4
    if q7oncd > 0 and q8oncd > 0 and q4oncd > 0 and q7oncd <= q8oncd <= q4oncd:
        dict['trick_string'] = 'Nollie Varial Heelflip'
        print('Nollie Varial Heelflip')
        nollie_varial_heelflip()
        reset_rtimers()   
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0 

    #360 shuvit
    if q3oncd > 0 and q4oncd > 0 and q5oncd > 0 and q6oncd > 0 and q7oncd > 0 and q7oncd >= q6oncd >= q5oncd >= q4oncd >= q3oncd:
    #    print("q4oncd: ", q4oncd, " q5oncd: ", q5oncd, " q6oncd: ", q6oncd)
        #print ("______-------360 shuvit")
        dict['trick_string'] = '360 shuvit'
        shuvit360()
        reset_rtimers()
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0    

    #360 fs shuvit    
    if q3oncd > 0 and q4oncd > 0 and q5oncd > 0 and q6oncd >= 0 and q7oncd > 0 and q7oncd <= q6oncd <= q5oncd <= q4oncd <= q3oncd:
        dict['trick_string'] = '360 Frontside shuvit'
        fsshuvit360()
        reset_rtimers()    
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0 
        
    #ollie
    if q5oncd > 0 and q1oncd > 0 and q5oncd < q1oncd:
        JUMPSTRENGTH = q1oncd - q5oncd
        #4,7
        if JUMPSTRENGTH <= 4:
           JUMPSTRENGTH = 1.1
        if JUMPSTRENGTH > 4 and JUMPSTRENGTH < 7:
           JUMPSTRENGTH = 1        
        if JUMPSTRENGTH >= 7:
           JUMPSTRENGTH = .9               
        aollie()
        reset_rtimers()
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0         
    #nollie
    if q5oncd > 0 and q1oncd > 0 and q5oncd > q1oncd:
        JUMPSTRENGTH = q5oncd - q1oncd
        #4,7
        if JUMPSTRENGTH <= 4:
           JUMPSTRENGTH = 1.1
        if JUMPSTRENGTH > 4 and JUMPSTRENGTH < 7:
           JUMPSTRENGTH = 1        
        if JUMPSTRENGTH >= 7:
           JUMPSTRENGTH = .9
        nollie()
        reset_rtimers()
        print("nollie")
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0 
    #kickflip
    if q5oncd > 0 and q8oncd > 0 and q5oncd < q8oncd and q3oncd < 1:
        kickflip()
        reset_rtimers()
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0         
    #nollie kickflip
    if q1oncd > 0 and q6oncd > 0 and q1oncd < q6oncd:
        nollie_kickflip()
        reset_rtimers()  
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0 
    #heelflip
    if q5oncd > 0 and q2oncd > 0 and q5oncd < q2oncd:
        heelflip()
        reset_rtimers()
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0         
    #nollie_heelflip
    if q1oncd > 0 and q4oncd > 0 and q1oncd < q4oncd:
        nollie_heelflip()
        reset_rtimers()
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0            

    #shuvit
    if q7oncd > 0 and q5oncd > 0 and q6oncd > 0 and q5oncd <= q6oncd <= q7oncd:# and q3oncd < 1:
        shuvit()
        reset_rtimers()
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0         
    #nollie_shuvit
    if q7oncd > 0 and q1oncd > 0 and q8oncd > 0 and q1oncd <= q8oncd <= q7oncd:# and q3oncd == 0:
        nollie_shuvit()
        print('nollie shuvit')
        reset_rtimers()   
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0         
    #fsshuvit
    if q4oncd > 0 and q5oncd > 0 and q3oncd > 0 and q5oncd <= q4oncd <= q3oncd:# and q7oncd < 1:
        fsshuvit()
        reset_rtimers()
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0         
    #nollie_fsshuvit
    if q3oncd > 0 and q1oncd > 0 and q2oncd > 0 and q1oncd <= q2oncd <= q3oncd:# and q7oncd == 0:
        print ("nollie fsshuvit")
        nollie_fsshuvit()
        reset_rtimers()
        q1oncd = 0
        q2oncd = 0
        q3oncd = 0
        q4oncd = 0
        q5oncd = 0
        q6oncd = 0
        q7oncd = 0
        q8oncd = 0     

    def hippy_jump():
        STANCE = own["stance"]
        if own['hippy'] == 1 and own['last_hippy'] == 0:
            if STANCE == 0:
                own['requestAction'] = 'reg_hippy_in'
            if STANCE == 1:
                own['requestAction'] = 'fak_hippy_in'         
        if own['hippy'] == 1 and own['last_hippy'] == 1:
            if STANCE == 0:
                own['requestAction'] = 'reg_hippy_in'
            if STANCE == 1:
                own['requestAction'] = 'fak_hippy_in'
        if own['hippy'] == 0 and own['last_hippy'] == 1:
            if rLR > turnsens:
                local = True
                rot = [ 0.0, 0.0, 3.14]
                own.applyRotation(rot,local)
                if STANCE == 0:
                    own['requestAction'] = 'reg_hippy_ncw'
                if STANCE == 1:
                    own['requestAction'] = 'fak_hippy_ncw'                
            elif rLR < -turnsens:
                local = True
                rot = [ 0.0, 0.0, -3.14]
                own.applyRotation(rot,local)            
                if STANCE == 0:
                    own['requestAction'] = 'fak_hippy_nccw'  
                if STANCE == 1:
                    own['requestAction'] = 'reg_hippy_nccw'
    ##straight        
            else:
                if STANCE == 0:
                    own['requestAction'] = 'reg_hippy'
                if STANCE == 1:
                    own['requestAction'] = 'fak_hippy'                                       

    #pushing and hippy jumps
    since_a = frame - lastaf
    since_x = frame - lastxf
    cush = 10
    hippy = 0
    own['hippy'] = 0
 
    if xBut == 1 and aBut == 1 and (lTrig < 0.02 and rTrig < 0.02) and r_ground.triggered == True: 
        #F"hippy")
        hippy = 1
        own['hippy'] = 1

    hippy_jump()    
    if ((since_a > cush and aBut == 1 and lasta == 1) or dict['kb_ua'] == 2) and (lTrig < 0.02 and rTrig < 0.02) and own['last_hippy'] == 0:
        if xBut == 0 and hippy == 0 and (lastaBut_ground == True or dict['kb_ua'] == 2):
            push()
    if since_x > cush and xBut == 1 and lastx == 1 and (lTrig < 0.02 and rTrig < 0.02) and own['last_hippy'] == 0:
        if aBut == 0 and hippy == 0 and lastxBut_ground == True:
            push_goof()      
    #cavemans 
    if LAST_GRIND == False and grindHit == False and r_ground.triggered:    
        if (aBut ==0 and own['lastaBut_ground'] == 1) and lTrig > 0.02:
            brfoot()
        if (aBut ==0 and own['lastaBut_ground'] == 1) and rTrig > 0.02:
            frfoot()
        if (xBut ==0 and own['lastxBut_ground'] == 1) and lTrig > 0.02:
            blfoot()
        if (xBut ==0 and own['lastxBut_ground'] == 1) and rTrig > 0.02:
            flfoot()              
        
    #push b button
    if bBut == 1:
        if linVelocity.x > .05 or linVelocity.x < -.05:
            stop()
        elif linVelocity.x < .05 or linVelocity.x > -.05:
            if own["lastStop"] == True:
                own["lastStop"] = False
    elif bBut ==0:
            own["lastStop"] = False
    ##### falls
    if own['fall'] == 1:
        offboard()
        own['getoffboard'] = True
    ####

    #y button
    if (own['lasty'] == 1 and yBut ==0) or dict['kb_q'] == 3:
        offboard()        

    if own["GRAB_ON"] == True:
        playing = skater.isPlayingAction(fliplay)
        if playing == 1:
            frame = skater.getActionFrame(fliplay)
            if frame > 16:
                skater.stopAction(fliplay)
    
    flipping = skater.isPlayingAction(fliplay) 
    
    #reg_ollie_north
    if rTrig < .02 and lTrig <.02 and r_ground.triggered == 0 and flipping == False and aBut == True:
        if STANCE == 0:
            own['requestAction'] = 'reg_ollie_south'
        else:
            own['requestAction'] = 'fak_ollie_north'  
    if rTrig < .02 and lTrig <.02 and r_ground.triggered == 0 and flipping == False and xBut == True:
        if STANCE == 0:
            own['requestAction'] = 'reg_ollie_north'
        else:
            own['requestAction'] = 'fak_ollie_south'                
    
    #frontside grab
    if rTrig > 0.02 and r_ground.triggered == 0 and flipping == False:    
        GRAB_ON = True
        own["GRAB_ON"] = GRAB_ON
        #print(rTrig, GRAB_ON)
        if aBut == False and xBut == False:
            if STANCE == False and rUD >= -.07 and rUD <= .07:
                frontside_grab_on()
            elif STANCE == True and rUD >= -.07 and rUD <= .07:
                fakbackside_grab_on()
            #front_nose    
            if STANCE == True and rUD < -0.070:
                fak_backside_nose_grab_on()
            #front_tail    
            elif STANCE == True and rUD > 0.07:
                fak_backside_tail_grab_on() 
            #    
            if STANCE == False and rUD < -0.070:
                if bBut == True:
                    reg_airwalk()
                else:    
                    frontside_nose_grab_on()
            #front_tail    
            elif STANCE == False and rUD > 0.07:
                frontside_tail_grab_on()     
        elif aBut == True and xBut == False:
            if STANCE == False:
                reg_fsonefoot_grab_on()        
            else:
                fak_onefoot_grab_on()
        elif aBut == False and xBut == True:
            if STANCE == False:
                reg_frigid_grab_on()        
            else:
                fak_judo_grab_on()                                      

    #backside grab
    if lTrig > 0.02 and r_ground.triggered == 0 and flipping == False:    
        GRAB_ON = True
        own["GRAB_ON"] = GRAB_ON
        #print(rTrig)
        if aBut == False and xBut == False:
            if STANCE == False and rUD >= -.07 and rUD <= .07:
                backside_grab_on()
            elif STANCE == True and rUD >= -.07 and rUD <= .07:
                fakfrontside_grab_on()
            #front_nose    
            if STANCE == True and rUD < -0.070:
                fak_frontside_nose_grab_on()
            #front_tail    
            elif STANCE == True and rUD > 0.07:
                fak_frontside_tail_grab_on() 
            #front_nose    
            if STANCE == False and rUD < -0.070:
                if bBut == True:
                    reg_airwalk()
                else:                  
                    backside_nose_grab_on()
            #front_tail    
            elif STANCE == False and rUD > 0.07:
                backside_tail_grab_on() 
                
        elif aBut == True and xBut == False:
            if STANCE == False:
                reg_judo_grab_on()        
            else:
                fak_frigid_grab_on()
        elif aBut == False and xBut == True:
            if STANCE == False:
                reg_onefoot_grab_on()        
            else:
                fak_frigid_grab_on()                    
                                            
            
    #kill grabs        
    if lTrig <= 0.02 and GRAB_ON == True and lTrig >= -.02 and rTrig <= .02 and rTrig >= -.2:
        GRAB_ON = False
        own["GRAB_ON"] = GRAB_ON
        GRAB_PLAYED = False
        own["GRAB_PLAYED"] = GRAB_PLAYED

    #frontside pump #backside pump
    def footplant():    
        framenum = own['framenum']
        last_ground_frame = own['lF_ground_frame']
        lF_air_frame = own['lF_air_frame']
        frames_since_ground = framenum - lF_air_frame
        frames_since_grind = framenum - own['last_grind_frame']
        if grindHit == True and aBut == True and ground_since < 10:
            own.linearVelocity.x = 0
            own.linearVelocity.y = 0                         
            own['footplant_on'] = 1
        if grindHit == False:
            own['footplant_on'] = 0 
        if own['footplant_on'] == True and rUD < turnsens and rUD > -turnsens:
            own.linearVelocity.x = 0
            own.linearVelocity.y = 0
        if own['footplant_on'] == 1 and own['last_footplant'] == True and own['jump_timer'] < 50:
            if skater.isPlayingAction(2925) == False:
                if STANCE == 0:
                    own['requestAction'] = 'reg_fp_rback'              
                if STANCE == 1:
                    own['requestAction'] = 'fak_fp_rback'
               
    def invert():    
        if grindHit == True and own['grindpos'] == 'reg_board' and gsf < 10:   
            if lBump == 1:   
                own['invert_on'] = 1
                own.linearVelocity.x = 0
                own.linearVelocity.y = 0
        if own["coping"] == 1 and own['invert_on'] == 1:
            if own['invert_on'] == 1 and own['last_invert'] == False:
                cont.activate(own.actuators['invertOn_sound'])
                if STANCE == False:
                    own['invert_type'] = "reg_back_invert_in"
                if STANCE == True:
                    own['invert_type'] = "fak_fr_invert"                         
        if own['invert_on'] == 0 and own['last_invert'] == True:
            own['last_invert_frame'] = frame
            cont.activate(own.actuators['invertOff_Sound'])
     
        if own['invert_on'] == 1 and own['invert_type'] != None:
            if own['invert_type'] == "reg_back_invert_in":
                own['requestAction'] = 'reg_back_invert'
      
            if own['invert_type'] == "fak_fr_invert":
                own['requestAction'] = 'fak_fr_invert'
        lif = own['last_invert_frame'] 
        if frame - lif > 3 and own['invert_on'] == 0:
            own['invert_type'] = None
            
    invert() 
    footplant()
        
    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]] 
                                      
            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
     
    #start button   
    if stBut == True:
        own.actuators["sroll"].volume = .0001
        cont.deactivate(own.actuators["sroll"])
        own.actuators["sroll"].stopSound()
    if (stBut == False and dict['last_stBut'] == True) or dict['kb_en'] == 1:
        if own['pause_on'] == True:
            own['pause_on'] = False   
        else:
            own['pause_on'] = True           
         
    def ylimit():
        lgf = own['last_grind_frame']
        frame = own['framenum']
        frames_since_grinding = frame - lgf
        #ylimit = .84
        ylimit = dict['ylimit']
        #print(ground_since, 'ground_since')
        if ground_since < 20 and ground_since > 1 and grindHit == 0 and own['jump_timer'] < 40:
            ylimit = ylimit + ((ground_since - 15) * -.005)
            
            yvel = own.linearVelocity.y
            yvel = yvel *.03
            if STANCE == 0:
                yvel *= -1
            try:    
                #dist = r_ground.hitObject.worldPosition - own.worldPosition
                #print('ground dist', dist)
                if own.linearVelocity.y > .01 or own.linearVelocity.y < -.01:
                    own.applyRotation([0,0,yvel], True)
                
                if ylimit > .99999:
                    ylimit = .9999
            except:
                pass       
        else:    
            if r_ground.triggered and touched == False and grindHit == 0 and frames_since_grinding > 20:    
            #     linVelocity4 = own.getLinearVelocity(True)
            #     newy = linVelocity4.y * ylimit   
            #     force = [linVelocity4.x, newy, linVelocity4.z]
            #     own.setLinearVelocity(force, True) 
                yvel = own.linearVelocity.y
                yvel = yvel *.03
                if STANCE == 0:
                    yvel *= -1
                try:    
                    if own.linearVelocity.y > .01 or own.linearVelocity.y < -.01:
                        own.applyRotation([0,0,yvel], True)
                    
                except:
                    pass 

        #print(ylimit, 'ylimit')       

    def getoffboard():
        lasty = own['lasty']
        getoffboard = own['getoffboard']
        if getoffboard == 1 and own['fall'] == False:    
            own['getoffboard'] = 0 
        if (yBut == False and lasty == True) or dict['kb_q'] == 3:
            own['getoffboard'] = 1        

    def switchcam():
        pass
    #    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 rtsBut == False and own['lastrts'] == True:
            if dict['last_bkBut'] == 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:
                #act = followcam.actuators[
                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"])
                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 dict['last_bkBut'] == 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"])
                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:
        own["lF_air_frame"] = own["framenum"]
    if r_ground.triggered == True:
        own["lF_ground_frame"] = own["framenum"]   

    if own['LAST_GRIND'] == True:
        own['last_grind_frame'] = own['framenum']
    if own['LAST_GRIND'] == False and r_ground.triggered and own['jump_timer'] == 0:
        if own['jump_stance'] != 3:
            own['jump_stance'] = 3  

    def control_calib():
        #controller calibration test
        scenes = bge.logic.getSceneList()

        controller_calib = [scene for scene in scenes if scene.name=="controller_calib"][0]
        cq1 = controller_calib.objects['q1']
        cq2 = controller_calib.objects['q2']
        cq3 = controller_calib.objects['q3']
        cq4 = controller_calib.objects['q4']
        cq5 = controller_calib.objects['q5']
        cq6 = controller_calib.objects['q6']
        cq7 = controller_calib.objects['q7']
        cq8 = controller_calib.objects['q8']
        if lq1on == 1:
            cq1["q1"] = 1
        else:
            cq1["q1"] = 0    
        if lq2on == 1:
            cq2["q2"] = 1
        else:
            cq2["q2"] = 0  
        if lq3on == 1:
            cq3["q3"] = 1
        else:
            cq3["q3"] = 0    
        if lq4on == 1:
            cq4["q4"] = 1
        else:
            cq4["q4"] = 0
        if lq5on == 1:
            cq5["q5"] = 1
        else:
            cq5["q5"] = 0    
        if lq6on == 1:
            cq6["q6"] = 1
        else:
            cq6["q6"] = 0
        if lq7on == 1:
            cq7["q7"] = 1
        else:
            cq7["q7"] = 0    
        if lq8on == 1:
            cq8["q8"] = 1
        else:
            cq8["q8"] = 0  
    def grind_turn():
        jumping = None
        gotcd = 25
        force = [0,0,0]
        grindHit = own['grindTouch']   
        sincegrinding = own['framenum']  - own['grindstartFrame']
        STANCE = own['stance']
        if rUD > turnsens or rLR > turnsens or rUD < -turnsens or rLR < -turnsens:
           jumping = True
        if grindHit == False:
            cont.deactivate(own.actuators['grindoutRight'])
            cont.deactivate(own.actuators['grindoutLeft'])  
        if (LAST_GRIND == True and jumping == None and sincegrinding > 20 and ground_since > 20) or own['invert_on'] == True and LAST_GRIND == 1:

        #own['grindTouch']      

            outloc = 0.022
            bsoutloc = .07
            bsoutvel = .1
            outrot = .06#2 #0.012
            outrot2 = .24
            outact = own.actuators["grindoutRight"]
            STANCE = own['grind_stance'] 
            if 'fak' in own['l_actionState']:
                STANCE = 1
            if 'reg' in own['l_actionState']:
                STANCE = 0          
            if own['grindpos'] == 'reg_5050':
                if lq3on == 1 or lq2on or dict['kb_ra'] == 2:
                    if own['gt_cd2'] == 0:
                        own['gt_cd2'] = 60

                    if STANCE == True:
                        if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'fak right'                    
                    if STANCE == False:
                        if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'reg right'                    
                    own["grindoutturn"] = gotcd    
                if lq7on == 1 or lq8on or dict['kb_la'] == 2:
                    if own['gt_cd2'] == 0:
                        own['gt_cd2'] = 60                
                    if STANCE == True:
                        if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'fak left'                    
                    if STANCE == False:
                        if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'reg left'                    
                    own["grindoutturn"] = gotcd 
                if lq4on == 1:
                    if own['gt_cd2'] == 0:
                        own['gt_cd2'] = 60                
                    if STANCE == True:
                        if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'fak fak right'
                    if STANCE == False:
                        if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'reg fak right'
                    own["grindoutturn"] = gotcd
                if lq6on == 1:
                    if own['gt_cd2'] == 0:
                        own['gt_cd2'] = 60                
                    if STANCE == True:
                        if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'fak fak left'
                    if STANCE == False:
                        if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'reg fak left'                      
                    own["grindoutturn"] = gotcd                
            #use stance for 5050 and grindstance for boards                        
            if own['grindpos'] == 'reg_board':
                outvel = own.getLinearVelocity(1)
                outact.dLoc = [0, 0, 0]
                outact.dRot = [0, 0, 0]
                if lq5on == 1 or dict['kb_da'] == 2:
                    if own['gt_cd2'] == 0:
                        own['gt_cd2'] = 60                 
                    if STANCE == True:
                        if own['footplant_on'] == True:
                            own.setLinearVelocity([(outvel.x + -bsoutvel), outvel.y, outvel.z], 1)
                            cont.activate(own.actuators["grindoutRight"])                   
                        if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'bs fak back'                     
                    if STANCE == False:
                        if own['footplant_on'] == True:
                            own.setLinearVelocity([(outvel.x + bsoutvel), outvel.y, outvel.z], 1)
                            cont.activate(own.actuators["grindoutRight"]) 
                        if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'bs reg back'
                    own["grindoutturn"] = gotcd 
                    own['invert_on'] = 0  
                if lq1on == 1 or dict['kb_ua'] == 2:
                    if own['gt_cd2'] == 0:
                        own['gt_cd2'] = 60                 
                    if STANCE == True:
                        if own['footplant_on'] == True:                   
                            own.setLinearVelocity([(outvel.x + bsoutvel), outvel.y, outvel.z], 1)
                            cont.activate(own.actuators["grindoutRight"])
                        if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'bs fak forward'                                            
                    if STANCE == False:
                        if own['footplant_on'] == True:                    
                            own.setLinearVelocity([(outvel.x + -bsoutvel), outvel.y, outvel.z], 1)
                            cont.activate(own.actuators["grindoutRight"])
                        if own['grind_out_type'] == None:
                             own['grind_out_type'] = 'bs reg forward'                                            
                    own["grindoutturn"] = gotcd
                    own['invert_on'] = 0  
            if lq1on or lq2on or lq3on or lq4on or lq5on or lq6on or lq7on or lq8on:
                gt_cd = own['gt_cd']
                if gt_cd == 0:
                    gt_cd = 30
                    own['gt_cd'] = gt_cd        
        
            if own['grindoutturn'] == 0:    
                cont.deactivate(own.actuators["grindoutRight"])
                own["grindoutturn"] = 0  
            gt_cd = own['gt_cd']
            if gt_cd > 0:
                own['gt_cd'] = gt_cd - 1         
            else:
                own['gt_cd'] = 0 
    #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
        reg_move = .05
        reg_rot = 0.02#2
        reg_rot2 = .26
        reg_move2 = .13
        bsforce = 50
        bs_dloc = .04
        outvel = own.linearVelocity
        if own["coping"] == 1:
            reg_rot = reg_rot *3
        if own['gt_cd2'] > 50 and own['jump_timer'] < 20:
            if own['grind_out_type'] == 'reg right':
                own.applyMovement([0,reg_move,0], True)
                own.applyRotation([0,0,-reg_rot],True)
            if own['grind_out_type'] == 'fak right':
                own.applyMovement([0,-reg_move,0], True)
                own.applyRotation([0,0,-reg_rot],True)
            if own['grind_out_type'] == 'reg left':
                own.applyMovement([0,-reg_move,0], True)
                own.applyRotation([0,0,reg_rot],True)           
            if own['grind_out_type'] == 'fak left':
                own.applyMovement([0,reg_move,0], True)
                own.applyRotation([0,0,reg_rot],True)
            if own['grind_out_type'] == 'reg fak right':
                if own['gt_cd2'] > 55:
                    own.applyMovement([0,reg_move2,0], True)
                own.applyRotation([0,0,reg_rot2],True)            
            if own['grind_out_type'] == 'fak fak right':
                if own['gt_cd2'] > 55:
                    own.applyMovement([0,-reg_move2,0], True)
                own.applyRotation([0,0,reg_rot2],True)            
            if own['grind_out_type'] == 'reg fak left':
                if own['gt_cd2'] > 55:
                    own.applyMovement([0,-reg_move2,0], True)
                own.applyRotation([0,0,-reg_rot2],True)                                
            if own['grind_out_type'] == 'fak fak left':
                if own['gt_cd2'] > 55:
                    own.applyMovement([0,reg_move2,0], True)
                own.applyRotation([0,0,-reg_rot2],True)            
            if own['grind_out_type'] == 'reg right' or own['grind_out_type'] == 'reg left' or own['grind_out_type'] == 'fak right' or own['grind_out_type'] == 'fak left':   
                own.setLinearVelocity([outvel.x * 1.01, outvel.y, outvel.z], True)
            if own['grind_out_type'] == 'reg fak right' or own['grind_out_type'] == 'reg fak left' or own['grind_out_type'] == 'fak fak right' or own['grind_out_type'] == 'fak fak left':
                if own['gt_cd2'] == 51:
                    if STANCE == False:
                        own.applyForce([-200, 0, 0], True)
                        own['stance'] = True
                        STANCE = True
                    if STANCE == True:
                        own.applyForce([200, 0, 0], True)
                        own['stance'] = False
                        STANCE = False
            if own['grind_out_type'] == 'bs reg back' or own['grind_out_type'] == 'bs fak forward':
                if own['gt_cd2'] > 50:
                    if STANCE == True:
                        own.applyForce([bsforce, 0, 0], True)
                    if STANCE == False:
                        own.applyForce([bsforce, 0, 0], True)
                    own.applyMovement([bs_dloc,0,0], True)    
            if own['grind_out_type'] == 'bs fak back' or own['grind_out_type'] == 'bs reg forward':
                if own['gt_cd2'] > 50:
                    if STANCE == True:
                        own.applyForce([-bsforce, 0, 0], True)
                    if STANCE == False:
                        own.applyForce([-bsforce, 0, 0], True)
                    own.applyMovement([-bs_dloc,0,0], True)                 
                                                                              
        if own['gt_cd2'] > 0:
            own['gt_cd2'] -= 1
        if own['gt_cd2'] == 0:    
            own['grind_out_type'] = None 

    if own["grindoutturn"] > 0:
        own["grindoutturn"] = own["grindoutturn"] - 1
        
                    
    def air_height():
        height = own["air_height"]
        if lf_ground == True and r_ground.triggered == False:
            height = 0    
        
    #wallride
    def wallride():
        wallride_off = own['wallride_off']
        distance = own.getDistanceTo(gray.hitPosition)
        upforce = 25
        sideforce = 15
        try:
            obj = gray.hitObject
            objpos = obj.worldPosition
            ownpos = own.worldPosition
            distance = ownpos.z - objpos.z
        except:
            pass    
        if wallrideL.triggered and wallride_off == 0 and r_ground.triggered == False:
            own['jump_timer'] = 0
            if r_ground.triggered == False:
                own["wallride"] = "L"
                cont.activate(wallrideconstL)
                force = [0,sideforce,upforce]
                own.applyForce(force,1)            
                #align
                if STANCE == 0:
                    own['requestAction'] = 'reg_wall_r'
                else:
                    own['requestAction'] = 'fak_wall_l'

        else:
            if own["wallride"] != "R":
                own["wallride"] = None
            cont.deactivate(wallrideconstL) 
      
        if wallrideR.triggered and wallride_off == 0:
            own['jump_timer'] = 0
            if r_ground.triggered == False:
                own["wallride"] = "R"
                cont.activate(wallrideconstR)
                force = [0,-sideforce,upforce]
                own.applyForce(force,1)
                if STANCE == 0: 
                    own['requestAction'] = 'reg_wall_l'
                else:
                    own['requestAction'] = 'fak_wall_r'             
        else:
            if own["wallride"] != "L":
                own["wallride"] = None
            cont.deactivate(wallrideconstR)   

    def wallride_sound():
        sact = own.actuators["wallSound"]
        if own["wallride"] != None and (own['actionState'] == 'reg_wall_r' or own['actionState'] == 'reg_wall_l' or own['actionState'] == 'fak_wall_r' or own['actionState'] == 'fak_wall_l'):
            sact.volume = .2
            cont.activate(own.actuators["wallSound"])
        else:
            sact.volume = .001
            sact.stopSound()
    if own['revert_timer'] > 0:
        own['revert_timer'] = own['revert_timer'] - 1 
        
    def shutoff_timers():
        if (LAST_GRIND == False and grindHit == True) or (jump_timer > 10 and own['wallride'] == None):
            own["Q1oncd"] = 0
            own["Q2oncd"] = 0
            own["Q3oncd"] = 0
            own["Q4oncd"] = 0
            own["Q5oncd"] = 0
            own["Q6oncd"] = 0
            own["Q7oncd"] = 0
            own["Q8oncd"] = 0 

    def grindout_cleanup():             
        lgf = own['last_grind_frame']

    def trans_jump():
        if own['jump_from_trans'] == 1:
            ground_ray = cont.sensors['ground_look']                        
            jump_obj = own['trans_jump_obj']
            jump_obj = scene.objects[str(own['trans_jump_obj'])]
            worldVect = [1, 0, 0]
            vect = jump_obj.getAxisVect(worldVect)      
            go = jump_obj.worldOrientation
            grinder_axis = [0,1,0]
            player_pos = own.worldPosition
            jump_obj = jump_obj.worldPosition
            try: 
                delta = player_pos - jump_obj
            except:
                pass 
            delta = delta.cross(vect) 
            deltamove = delta[1] * .25
            move = [deltamove, 0, 0]
            if abs(deltamove) < 1 and delta[1] < 1:
                own.applyMovement(move, True)               

    def air_mover():
        if r_ground.triggered == False and jump_timer > 53 and frames_since_grinding > 50:
            if lUD > 0.075:
                if STANCE == 0:
                    force2 = [120, 0, 10]
                if STANCE == 1:
                    force2 = [-120, 0, 10]            
                own.applyForce(force2, True)
                own['no_grind_pull'] = 1
        if r_ground.triggered == False and jump_timer > 53 and frames_since_grinding > 50:
            if lUD < -0.075:
                own['no_grind_pull'] = 1                
        if r_ground.triggered == False and jump_timer > 10 and lUD > 0.075 and frames_since_grinding > 50:
            if STANCE == 0:
                force2 = [7, 0, 10]
            if STANCE == 1:
                force2 = [-7, 0, 10]            
            own.applyForce(force2, True)
            own.applyForce([0,0,5], False)
            own['air_mover'] = True
            own['no_grind_pull'] = 1
        else:
            own['air_mover'] = False 
            
    def dropinRotate():
        if own['dropinTimer'] > 30 and own['dropinTimer'] < 40:
            rot = [ 0.01, 0.0, 0]
            vel = [linVelocity.x - .25, linVelocity.y, linVelocity.z - .01]
            if STANCE == 1:
                rot = [-0.01, 0.0, 0]
                vel = [linVelocity.x + .25, linVelocity.y, linVelocity.z - .01]
            local = True
            own.applyRotation(rot,local)
            own.setLinearVelocity(vel, local)            
        if own['dropinTimer'] == 50:
            if STANCE == 1:
                force = (linVelocity.x +1, linVelocity.y, linVelocity.z )
            else:
                force = (linVelocity.x -1, linVelocity.y, linVelocity.z )                    
            own.setLinearVelocity(force, True)               

    framenum = own['framenum']
    last_ground_frame = own['lF_ground_frame']
    lF_air_frame = own['lF_air_frame']
    frames_since_ground = framenum - lF_air_frame               
    if framenum - lF_air_frame > 30:
        own['no_grind_pull'] = 0

    def wallhit():
        linvelx = linVelocity.x
        lastx = own["linvelx"]
        wallsens = cont.sensors['wall']
        if frames_since_ground > 20 and (abs(lastx) - abs(linvelx)) > .5 and wallsens.positive:
            velx = linVelocity.x * -1.5
            if velx > 0 and velx < 1:
                velx = 1
            if velx < 0 and velx > -1:
                velx = -1    
            force = (velx, linVelocity.y, linVelocity.z )                    
            own.setLinearVelocity(force, True)        
    
    def land_boost():
        linvelx = linVelocity.x
        lastx = own["linvelx"]
        if frames_since_ground < 10 and (abs(lastx) - abs(linvelx)) > .5:
            #print('land boost')
            force = (lastx, linVelocity.y, linVelocity.z )                    
            own.setLinearVelocity(force, True)                 
    
    jump_Timer()
    check_landing()
    nextframe()
    wheelroll()
    rollsound()
    reset_pos()
    ylimit()
    getoffboard()
    #switchcam()
    move_flycam()
    move_followcam()
    grind_turn()
    air_height()
    wallride()
    wallride_sound()
    shutoff_timers()
    grindout_cleanup()
    air_mover()
    dropinRotate()    
    onboard()   
    #wallhit() 
    linvelx = own.getLinearVelocity(True)
    #land_boost()
    own["linvelx"] = linvelx.x
    LAST_STANCE = STANCE
    LAST_STANCE = own["stance"]
    own["last_stance"] = STANCE
    own["lastGrab"] = GRAB_ON
    own['ground'] = r_ground.triggered
    own['last_ground'] = r_ground.triggered
    own["LAST_GRIND"] = grindHit
    own["rotz"] = rot.z
    own['walk'] = 0
    own['lasty'] = yBut
    own['lastlts'] = ltsBut
    own['lastrts'] = rtsBut
    own["lF_ground2"] = own["lF_ground"]
    own['last_invert'] = invert_on
    own['grab_type'] = grab_type
    own['last_last_manual'] = own['last_manual']
    own['last_manual'] = own['manual']
    own['last_reg_manual'] = own['reg_manual']     
    own['last_fak_manual'] = own['fak_manual']
    own['last_fak_nmanual'] = own['fak_nmanual'] 
    own['last_reg_nmanual'] = own['reg_nmanual']
    if own['manual'] == 1:
        own['last_manual_frame'] = frame

    own['last_hippy'] = own['hippy']
    if aBut == 1 and own["lasta"] == 0:
        own["lastaf"] = frame
    if xBut == 1 and own["lastx"] == 0:
        own["lastxf"] = frame
    own["lasta"] = aBut
    own["lastx"] = xBut
    own['lastaBut_ground'] = aBut_ground
    own['lastxBut_ground'] = xBut_ground
    own["last_sel"] = own["sel"]
    own["sel"] = bkBut  

    if r_ground.triggered and own["jump_timer"] < 20:
        #if own['rotz'] > .65:
        #if own['rotz'] > .15: 
        if 1 == 1:    
            force2 = [0.0, 0, dict['antibounce']]
            #own.applyForce(force2, True)

            gdist = ((own.worldPosition.z - r_ground.hitPosition[2]))  
            #print(gdist)
            if gdist < .2875 and gdist > .1:
                #move = 2.875 - gdist
                move = (.2875 - gdist)*.33
                #move = (own.worldPosition.z + gdist)
                if move > 0:
                    own.worldPosition.z = own.worldPosition.z + move
                else:
                    own.worldPosition.z = own.worldPosition.z - move    
                own.linearVelocity.z = 0
        else:
            gdist = ((own.worldPosition.z - r_ground.hitPosition[2]))  
            #print(gdist)
            if gdist < .2875 and gdist > .1:
                #move = 2.875 - gdist
                #move = (.2875 - gdist)*.33
                move = (.2875 - gdist)*.4
                #move = (own.worldPosition.z + gdist)
                if move > 0:
                    own.worldPosition.z = own.worldPosition.z + move
                else:
                    own.worldPosition.z = own.worldPosition.z - move    
                own.linearVelocity.z = 0            
                
    

    Axis = 2 
    Distance = -10
    # X axis is zero
    # Y is 1
    # Z is 2
    End = own.worldPosition + (own.worldOrientation.col[Axis]*Distance)
    Start = own.worldPosition
    localRay = own.rayCast(End,Start,0,'ground',1,0,0)
    #print(localRay)
    if localRay[0]:
        localHitDist = (own.worldPosition - localRay[1]).length
        #print(localHitDist)
        #print(localRay[2])
        if localHitDist < .287:
            own.localPosition[2] += (.287 - localHitDist)
            if localRay[2] != [0,0,-1] and grindHit == 0:
                own.alignAxisToVect(localRay[2], 2, .75)
                #print('moving local')

    # if own['LAST_GRIND'] == False and touched:
    #     print('touching but not grinding')
    #     if STANCE == 0:
    #         own.applyMovement([-.05, 0, .01], True)
    #     else:
    #         own.applyMovement([.05, 0, .01], True)    
    # #rend = bge.render
    #rend.drawLine(Start, End, [1,0,0,1])
    #print(own['rotz'])


    if own.linearVelocity.x > 10:
        own.linearVelocity.x = 10
    if (grindDar == False and r_ground.triggered and own['grindTouch'] == False) or own['jump_timer'] > 40:
        own['grindType'] = ''
    
    dict['walk'] = 0  

    #print(own["LAST_GRIND"])