release/walk.py

#os = 'Windows'
#from sys import platform
#if platform != "win32":
 #os = 'Linux'
def onWindows():
 return os == 'Windows'
import bge
import GameLogic
import ctypes
#import bpy
import random
import math

#build global dict (move this to separate script that runs once)
scene = bge.logic.getCurrentScene()
objList = scene.objects

#reduction = 400000
#axisTh = 0.03 

############
##vibration#
############
## Define necessary structures
#class XINPUT_VIBRATION(ctypes.Structure):
#    _fields_ = [("wLeftMotorSpeed", ctypes.c_ushort), ("wRightMotorSpeed", ctypes.c_ushort)]
#xinput = ctypes.windll.xinput1_3 # Load Xinput.dll
## Set up function argument types and return type
#XInputSetState = xinput.XInputSetState
#XInputSetState.argtypes = [ctypes.c_uint, ctypes.POINTER(XINPUT_VIBRATION)]
#XInputSetState.restype = ctypes.c_uint
## Now we're ready to call it. Set left motor to 100%, right motor to 50%
## for controller 0
##vibration = XINPUT_VIBRATION(65535, 32768)
##XInputSetState(0, ctypes.byref(vibration))
## You can also create a helper function like this:
#def set_vibration(controller, left_motor, right_motor):
#    vibration = XINPUT_VIBRATION(int(left_motor * 65535), int(right_motor * 65535))
#    XInputSetState(controller, ctypes.byref(vibration))  
## ... and use it like so
##set_vibration(0, 0.2, 0.2)
################
##end vibration#
################


cont = GameLogic.getCurrentController() 
obj = bge.logic.getCurrentScene().objects
char = bge.constraints.getCharacter
own = cont.owner
stance = own['stance']
STANCE = own['stance']
r_ground = cont.sensors["r_Ground"]
#Sensor logic bricks connected to the python Controller  
#aXis = cont.sensors["sControla.001"]
#bUtt = cont.sensors["sControlb.001"]
linvel = own.getLinearVelocity(True)
lasta = own['lasta']
lastx = own['lastx']
last_sit = own['sit']
dict = bge.logic.globalDict

try:
    own['walk_timer'] = own['walk_timer'] +1
except:
    own['walk_timer'] = 1

truckon = 30
deckon = 30

#onW = onWindows()

# windows stuff
#lar_lts = 0
#uad_lts = 1
#lt = 4 if onW else 2
#lar_rts = 2 if onW else 3
#uad_rts = 3 if onW else 4
#rt = 5

#a_but = 0 if onW else 0
#b_but = 1 if onW else 1
#x_but = 2 if onW else 2
#y_but = 3 if onW else 3
#l_bump = 9 if onW else 4
#r_bump = 10 if onW else 5
#bk_but = 4 if onW else 6
#st_but = 6 if onW else 7
#xb_but = 5 if onW else 8
#lts_pr = 7 if onW else 9
#rts_pr = 8 if onW else 10
#l_dp = 13 if onW else 11
#r_dp = 14 if onW else 12
#u_dp = 11 if onW else 13
#d_dp = 12 if onW else 14

lLR = dict['lLR']
lUD = dict['lUD']
rLR = dict['rLR']
rUD = dict['rUD']
lTrig = dict['lTrig']
rTrig = dict['rTrig']
aBut = dict['aBut']
bBut = dict['bBut']
xBut = dict['xBut']
yBut = dict['yBut']
lBump = dict['lBump']
rBump = dict['rBump']
bkBut = dict['bkBut']
stBut = dict['stBut']
xbBut = dict['xbBut']
ltsBut = dict['ltsBut']
rtsBut = dict['rtsBut']
ldPad = dict['ldPad']
rdPad = dict['rdPad']
udPad = dict['udPad']
ddPad = dict['ddPad']

#user
sens = .04
fliplay = 30
dropinCol = own.sensors['dropinCol']

#no input
#def cutOff():
#    
# if (abs(lLR) < axisTh 
#     and abs(lUD) < axisTh 
#     and abs(rLR) < axisTh 
#     and abs(rUD) < axisTh
#     and aBut == False):
#         
#  return True
skater = scene.objects["Char4"]
deck = scene.objects["deck"]
trucks = scene.objects["trucks"]

throw_deck_empty = scene.objects["throw_deck_empty"]
wheel1 = scene.objects["rollen.000"]
wheel2 = scene.objects["rollen.001"]
wheel3 = scene.objects["rollen.002"]
wheel4 = scene.objects["rollen.003"]
camobj = scene.objects["Camera.003"]
camera = cont.actuators["Camera"]
replayCam = cont.actuators["replayCam"]
timer = own['dropinTimer']
cam = scene.objects["Camera.003"]
freecam = scene.objects["freecam"]
followcam = scene.objects["followcam"]

noidle = 0

playing_deck = deck.isPlayingAction(deckon)
playing_trucks = trucks.isPlayingAction(truckon)
if playing_deck == 1 or playing_trucks == 1:
    noidle = 1

if own["stance"] == None:
    own["stance"] = True
STANCE = own["stance"]
def killact(layer):
    if skater.isPlayingAction(layer):
        skater.stopAction(layer)
    if deck.isPlayingAction(layer):    
        deck.stopAction(layer)
    if trucks.isPlayingAction(layer):    
        trucks.stopAction(layer)
def killall():
    for x in range(5000):
        skater.stopAction(x)
        deck.stopAction(x)
        trucks.stopAction(x)
def trucksisplaying():
    for x in range(5000):
        if deck.isPlayingAction(x):
            print("deck is playing:", x)
#trucksisplaying() 

def printplaying():
    splaying_layers = "S: "
    playing_layers = "D: "
    tplaying_layers = "T: "
    for x in range(9900):
        if skater.isPlayingAction(x):
        #if trucks.isPlayingAction(x):
        #if skater.isPlayingAction(x):                        
            splaying_layers += str(x)
            splaying_layers += " "        
        if deck.isPlayingAction(x):
        #if trucks.isPlayingAction(x):
        #if skater.isPlayingAction(x):                        
            playing_layers += str(x)
            playing_layers += " "
        if trucks.isPlayingAction(x):
        #if trucks.isPlayingAction(x):
        #if skater.isPlayingAction(x):                        
            tplaying_layers += str(x)
            tplaying_layers += " "            
    print(splaying_layers, playing_layers, tplaying_layers) 
#printplaying() 
##
if r_ground.positive and xBut == False and lastx == False:
    killact(10)
    #killact(11)
    killact(12)
    killact(13)              
######################################  
#walk out
#print(own['walk_timer'])
#if own['walk_timer'] < 5:
#    
#    if stance == 0 and skater.isPlayingAction(fliplay) == False:
#        
#        if own['throw_deck'] == True:
#            print("walk out1")
#            skater.playAction("reg_nwalk_nb.001", 15,35, layer=29, play_mode=0, speed=.5)
#        else:
#            print("walk out2")
#            skater.playAction("walk.000", 15,35, layer=29, play_mode=0, speed=.5)
#        deck.playAction("a_reg_walk", 0,35, layer=17, play_mode=0)
#        trucks.playAction("a_reg_walk", 0,35, layer=17, play_mode=0)    
    

#idle      
if stance == 0 and skater.isPlayingAction(fliplay) == False and yBut == False and r_ground.triggered and xBut == False and noidle == 0 and own['walk_idling'] == 0 and own['sit'] == 0 and own['dropinTimer'] == 0 and own['lasty']  == False:
    own['requestAction'] = 'reg_idle'
    if own['throw_deck'] == True:
        own['requestAction'] = 'reg_idle_nb'
        #skater.playAction("reg_idle1", 1,120, layer=3, play_mode=1, speed=.5)
    #else:
        #skater.playAction("reg_idle1", 1,120, layer=3, play_mode=1, speed=.5)
        #deck.playAction("a_reg_idle1", 1,120, layer=3, play_mode=1, speed=.5)
        #trucks.playAction("a_reg_idle1", 1,120, layer=3, play_mode=1, speed=.5) 
if stance == 1 and skater.isPlayingAction(fliplay) == False and yBut == False and r_ground.triggered and xBut == False and noidle == 0 and own['walk_idling'] == 0 and own['sit'] == 0 and own['dropinTimer'] == 0 and own['lasty']  == False:
    own['requestAction'] = 'fak_idle'
    if own['throw_deck'] == True:
        own['requestAction'] = 'fak_idle_nb'
        #skater.playAction("fak_idle1", 1,120, layer=3, play_mode=1, speed=.5)
    #else:
        #skater.playAction("fak_idle1", 1,120, layer=3, play_mode=1, speed=.5)
        #deck.playAction("a_fak_idle1", 1,120, layer=3, play_mode=1, speed=.5)
        #trucks.playAction("a_fak_idle1", 1,120, layer=3, play_mode=1, speed=.5) 

if lUD < -sens:
    lup = 1
else:
    lup = 0
if lUD > sens:
    ldown = 1
else:
    ldown = 0    
    
#walking

#new walking
#if (lup == 1 and aBut == 0 and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0):
vel = own.getLinearVelocity(True)
if own['walk_timer'] < 50:
    velx = vel.x * .95             
    own.setLinearVelocity([velx, 0, vel.z], True)
else:
    own.setLinearVelocity([0, 0, vel.z], True)
    #print("set 0 vel")
    
wf = 1
if own['last_walk_frame'] - own['last_roll_frame'] > 55:
    wf = 0
   
if (lup == 1 and aBut == 0 and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0) and wf == 0:    
    own['walking'] = "regular"
    walking = "regular"
elif lup == 1 and aBut == 1 and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0 and wf == 0:
    own['walking'] = "fast"
    walking = "fast"
else:
    own['walking'] = None
    walking = None
#print(own['walk_timer'])    
if walking == "regular":
    cont.deactivate(own.actuators['forward2']) 
    cont.deactivate(own.actuators['backward2'])    
    if stance == 0:
        cont.activate(own.actuators['forward'])
    else:
        cont.activate(own.actuators['backward'])
if walking == "fast":
    cont.deactivate(own.actuators['forward']) 
    cont.deactivate(own.actuators['backward'])    
    if stance == 0:
        cont.activate(own.actuators['forward2'])
    else:
        cont.activate(own.actuators['backward2'])            
        

if walking == None:
    cont.deactivate(own.actuators['forward2']) 
    cont.deactivate(own.actuators['backward2'])
    cont.deactivate(own.actuators['forward']) 
    cont.deactivate(own.actuators['backward'])        
    if own['walk_timer'] < 50:
        velx = vel.x * .95             
        own.setLinearVelocity([velx, 0, vel.z], True)
    else:
        own.setLinearVelocity([0, 0, vel.z], True)
        #print("set 0 vel")    
                
    
#old walking
if (lup == 1 and aBut == 0 and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0):
    own.actuators["walkondirt"].volume = .2
    own.actuators["walkondirt"].pitch = 1
    cont.activate(own.actuators["walkondirt"])
    if lasta == 1:
        #cont.deactivate(own.actuators['forward2']) 
        #cont.deactivate(own.actuators['backward2'])
        killact(6)
        killact(7)
        killact(8)
        killact(9)
        killact(17)
        killact(18)                
    if stance == 0 and skater.isPlayingAction(fliplay) == False:             
        #cont.activate(own.actuators['forward'])
        #cont.activate(skater.actuators['aWalk'])
        #cont.activate(deck.actuators['a_reg_walk'])
        #cont.activate(deck.actuators['a_reg_walk'])
        #without deck
        if own['throw_deck'] == True:
            own['requestAction'] = 'reg_walk_nb'
            #skater.playAction("reg_nwalk_nb.001", 0,35, layer=24, play_mode=1, speed=.5)
        else:
            own['requestAction'] = 'reg_walk'
#            skater.playAction("reg_nwalk", 0,35, layer=24, play_mode=1, speed=.5)
#        deck.playAction("a_reg_nwalk", 0,35, layer=16, play_mode=1, speed=.5)
#        trucks.playAction("a_reg_nwalk", 0,35, layer=16, play_mode=1, speed=.5)
        killact(25) 
        killact(305)
        killact(306)                
    if stance == 1 and skater.isPlayingAction(fliplay) == False:        
        #cont.activate(own.actuators['backward'])
        #cont.activate(skater.actuators['aWalk_fak'])
        #cont.activate(deck.actuators['a_fak_walk'])
        #cont.activate(trucks.actuators['a_fak_walk'])
        #without deck
        if own['throw_deck'] == True:
            own['requestAction'] = 'fak_walk_nb'
            #skater.playAction("fak_nwalk_nb.001", 0,35, layer=25, play_mode=1, speed=.5)
        else:
            own['requestAction'] = 'fak_walk'
#            skater.playAction("fak_nwalk", 0,35, layer=25, play_mode=1, speed=.5)    
#        deck.playAction("a_fak_nwalk", 0,35, layer=15, play_mode=1, speed=.5)
#        trucks.playAction("a_fak_nwalk", 0,35, layer=15, play_mode=1, speed=.5)        
elif lup == 1 and aBut == 1 and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0:
    own.actuators["walkondirt"].volume = .2
    own.actuators["walkondirt"].pitch = 1.3
    cont.activate(own.actuators["walkondirt"])
    if stance == 0 and skater.isPlayingAction(fliplay) == False:        
        #cont.activate(own.actuators['forward2'])
        #cont.activate(skater.actuators['aWalk'])
        if own['throw_deck'] == True:
            own['requestAction'] = 'reg_walkFast_nb'
            skater.playAction("reg_nwalk_nb.001", 0,35, layer=25, play_mode=1, speed=1)
        else:
            own['requestAction'] = 'reg_walkFast'
#            skater.playAction("reg_nwalk", 0,35, layer=25, play_mode=1, speed=1)         
#        
#        deck.playAction("a_reg_nwalk", 0,35, layer=305, play_mode=1, speed=1)
#        trucks.playAction("a_reg_nwalk", 0,35, layer=306, play_mode=1, speed=1)
    else:
        killact(25) 
        killact(305)
        killact(306)           
    if stance == 1 and skater.isPlayingAction(fliplay) == False:        
        #cont.activate(own.actuators['backward2'])
        #cont.activate(skater.actuators['aWalk_fak'])
        if own['throw_deck'] == True:
            own['requestAction'] = 'fak_walkFast_nb'
            skater.playAction("fak_nwalk_nb.001", 0,35, layer=24, play_mode=1, speed=1)           
        else:
            own['requestAction'] = 'fak_walkFast'
#            skater.playAction("fak_nwalk", 0,35, layer=24, play_mode=1, speed=1)                       
#        deck.playAction("a_fak_nwalk", 0,35, layer=15, play_mode=1, speed=1)
#        trucks.playAction("a_fak_nwalk", 0,35, layer=15, play_mode=1, speed=1)             
else:
    vel = own.getLinearVelocity(True)
    cont.deactivate(own.actuators["walkondirt"])
    if stance == 0:
        #cont.deactivate(own.actuators['forward'])
        #cont.deactivate(own.actuators['forward2'])
        cont.deactivate(skater.actuators['aWalk'])
        cont.deactivate(deck.actuators['a_reg_walk'])
        cont.deactivate(trucks.actuators['a_reg_walk'])        
        killact(4)
        killact(5)
        killact(6)
        killact(7)
        killact(15)
        killact(16)
        killact(17)
        killact(18)
        killact(24)
        killact(25) 
        killact(305)
        killact(306)         
#        if own['walk_timer'] < 50:
#            velx = vel.x * .95             
#            #own.setLinearVelocity([velx, 0, vel.z], True)
#            
#        else:
#            if r_ground.triggered:
#                own.setLinearVelocity([0, 0, vel.z], True)
#            #velz = vel.z
#            #print(velz)
#            #own.localLinearVelocity[0, 0, velz]
    if stance == 1:
        #cont.deactivate(own.actuators['backward'])
        #cont.deactivate(own.actuators['backward2'])
        cont.deactivate(skater.actuators['aWalk_fak'])
        cont.deactivate(deck.actuators['a_fak_walk'])
        cont.deactivate(trucks.actuators['a_fak_walk'])        
        killact(4)
        killact(5)
        killact(6)
        killact(7)
        killact(15)
        killact(16)
        killact(17)
        killact(18)
        killact(24)
        killact(25) 
        killact(305)
        killact(306)             
#        if own['walk_timer'] < 50:
#            velx = vel.x * .95             
#            #own.setLinearVelocity([velx, 0, vel.z], True)
#        else:
#            own.setLinearVelocity([0, 0, vel.z], True)
#in air        
if lup == 1 and r_ground.positive == False:
    
    if stance == 0:
        cont.deactivate(own.actuators['forward'])
        cont.deactivate(own.actuators['forward2'])
        cont.deactivate(skater.actuators['aWalk'])
        killact(4)
        killact(5)
        killact(6)
        killact(7)        
        velx = linvel.x - 1
        own.setLinearVelocity([-1.5, linvel.y, linvel.z], 1)
        #cont.activate(own.actuators['forward2'])
    if stance == 1:    
        cont.deactivate(own.actuators['backward'])
        cont.deactivate(own.actuators['backward2'])
        cont.deactivate(skater.actuators['aWalk_fak'])
        killact(4)
        killact(5)
        killact(6)
        killact(7)        
        velx = linvel.x + 1
        own.setLinearVelocity([1.5, linvel.y, linvel.z], 1) 
        #cont.activate(own.actuators['backward2'])       
#---------------
if rLR > .05:
    cont.activate(camobj.actuators['camRight'])
else:
    cont.deactivate(camobj.actuators['camRight'])    
if rLR < -.05:
    cont.activate(camobj.actuators['camLeft'])
else:
    cont.deactivate(camobj.actuators['camLeft'])     
if rUD > .05:
    cont.activate(camobj.actuators['camDown'])
else:
    cont.deactivate(camobj.actuators['camDown'])     
if rUD < -.05:
    cont.activate(camobj.actuators['camUp'])
else:
    cont.deactivate(camobj.actuators['camUp'])     
                
#----------------
camera.height = .9 #-.4
camera.min = 1.5
camera.max = 2
#camera.object = "Char4:Mhair01"
#camera.damping = 0
#camera.axis = 4 
lasty = own['lasty']     
#if yBut == False and lasty == True:

#    if own['walk'] == 1: 
#        killact(fliplay) 
        #killall() 
    #camera.damping = 0     
    #camera.axis = 4            
#print(stance)


def onboard():
#    pass
    if own['walk'] == 0:
        print("start walking")
        if own['framenum'] > 100 and own['fall'] == False:
            #pass
            cont.activate(own.actuators['pop'])
        own['getoffboard'] = False
        #set_vibration(0, 0.0, 0.0)
        fliplay = 301
        fliplay2 = 302 
        fliplay3 = 303
        try:
            vel = own['offboard_vel']
            #velx = vel.x *2
            vel = [velx, vel.y, vel.z]
            #vel = vel * 4
            #vel = [-100, 0, 0]
            #print(vel)
            #own.localLinearVelocity = vel
            #JUMPHEIGHT = 1100
            #force = [600, 0.0, 10]
            # use local axis
            #local = True
            # apply force
            #own.applyForce(force, local)            
        except: 
            pass
         
        if STANCE == 0:
            #killact(3)
            #killact(4)
            killall()
            skater.stopAction(fliplay)
            deck.stopAction(deckon)
            trucks.stopAction(truckon)
            own['requestAction'] = 'reg_offboard'             

#            skater.playAction("reg_noffboard", 0,26, layer=fliplay, priority=0, play_mode=0, speed=.5)
#            deck.playAction("a_reg_noffboard", 0,26, layer=deckon, priority=0, play_mode=0, speed=.5)
#            trucks.playAction("a_reg_noffboard", 0,26, layer=truckon, priority=0, play_mode=0, speed=.5)            
        if STANCE == 1:
            killact(3)
            killact(4)
            killall()
            skater.stopAction(fliplay)
            deck.stopAction(deckon)
            trucks.stopAction(truckon)
            own['requestAction'] = 'fak_offboard'             
#            skater.playAction("nfak_offboard", 1,30, layer=fliplay, priority=0, play_mode=0, speed=1.5)
#            deck.playAction("a_fak_offboard", 1,30, layer=deckon, priority=0, play_mode=0, speed=1.5)
#            trucks.playAction("a_fak_offboard", 1,30, layer=truckon, priority=0, play_mode=0, speed=1.5)             
def jump():
    if xBut == True:
        if own['lastx'] == 0:
            killact(3)
            killact(4)
            killact(5)
            killact(6)
            killact(7) 
            #why does this layer have to be so high?      
            if STANCE == 0:  
                own['requestAction'] ='reg_jump'   
#                skater.playAction("reg_jump", 1,35, layer=400, priority=0, play_mode=0, speed=.5)
#                deck.playAction("a_reg_jump2", 1,35, layer=400, priority=0, play_mode=0, speed=.5)
#                trucks.playAction("a_reg_jump2", 1,35, layer=400, priority=0, play_mode=0, speed=.5)
            if STANCE == 1:
                own['requestAction'] ='fak_jump'
                #skater.playAction("fak_jump", 1,35, layer=400, priority=0, play_mode=0, speed=.5)    
            #deck.playAction("a_reg_jump", 1,30, layer=11, play_mode=0, speed=.5)
            #trucks.playAction("a_reg_jump", 1,30, layer=12, priority=0, play_mode=0, speed=1)             
            JUMPHEIGHT = 1100
            force = [ 0.0, 0.0, JUMPHEIGHT]
            # use local axis
            local = False
            # apply force
            own.applyForce(force, local)
        own['lastx'] = 1
    else:
        own['lastx'] = 0
def dropin():
    if dropinCol.positive == True:
        #print("DROPIN") 
        pass       
        
def getonboard():
    getonboard = own['getonboard']
    fliplay2 = 50#8560
    if yBut == True:
        #camera.height = -.4
        #camera.min = 1.5
        #camera.max = 2 #2
        #camera.damping = .99
        #camera.axis = 0
        
        #cont.deactivate(cam.actuators['replayCam'])
        #cont.deactivate(cam.actuators['Camera'])
        #camera.height = 10 #-.5
        #print("high cam")
        #camera.min = .75
        #camera.max = 1.25
        #cont.activate(cam.actuators['Camera']) 
        
        deckact = deck.actuators["Visibility"]
        trucksact = trucks.actuators["Visibility"]
        wheel1act = wheel1.actuators["Visibility"]
        wheel2act = wheel2.actuators["Visibility"]
        wheel3act = wheel3.actuators["Visibility"]
        wheel4act = wheel4.actuators["Visibility"]        
        deckact.visibility = True
        trucksact.visibility = True
        wheel1act.visibility = True
        wheel2act.visibility = True
        wheel3act.visibility = True
        wheel4act.visibility = True  
        cont.activate(deck.actuators['Visibility'])
        cont.activate(trucks.actuators['Visibility'])
        cont.activate(wheel1.actuators['Visibility'])
        cont.activate(wheel2.actuators['Visibility'])
        cont.activate(wheel3.actuators['Visibility'])
        cont.activate(wheel4.actuators['Visibility']) 
        own['throw_deck'] = False 
        throw_deck_empty = scene.objects["throw_deck_empty"]
        throw_deck_empty['kill_deck'] = 1 
        fliplay3 = fliplay2 + 1 
        if dropinCol.positive == True: 
                       
            nearestObject = None
            grindEmpty = scene.objects['grindEmpty']
            grindDar = grindEmpty.sensors['grindDar2']
            minDist = None             
            if grindDar.positive:
                detectedObjects = grindDar.hitObjectList
                dist = 0
                for obj in detectedObjects:
                    dist = own.getDistanceTo(obj)
                    if (minDist is None or dist < minDist):
                        nearestObject = obj
                        minDist = dist
            if nearestObject != None:
                print(nearestObject)
                obj = nearestObject
                player_e = own.worldOrientation.to_euler()
                player_pos = own.worldPosition
                player_rotz = math.degrees(player_e[2])                
                grinder_e = obj.worldOrientation.to_euler()
                grinder_rotz = math.degrees(grinder_e[2])            
                rot = player_rotz - grinder_rotz  
                
                
                grinder_pos = obj.worldPosition 
                worldVect = [1, 0, 0]
                vect = obj.getAxisVect(worldVect)      
                go = obj.worldOrientation
                grinder_axis = [1,0,0] 
                try: 
                    delta = player_pos - grinder_pos
                    
                    delta = delta.cross(vect)
                    if delta[2] >= 0:
                        grindside = "right"
                    else:
                        grindside = "left"                    
                    deltamove = delta[2] * .1#.25
                    if STANCE == 0:
                        move = [-deltamove, 0, 0]
                    else:
                        move = [deltamove, 0, 0]                            
                    #print("1deltamove", deltamove)
                    own.applyMovement(move, True)                    
                except:
                    #print("delta broke: ", player_pos, grinder_pos)
                    pass 

            if STANCE == 0: 
                own['requestAction'] ='reg_dropin_pos' 
                own['dropinTimer'] = 60                                     
                    
            if STANCE == 1: 
                    
                own['requestAction'] ='fak_dropin_pos'  
                own['dropinTimer'] = 60                                 
                                     
    if getonboard == 1:
        fliplay3 = 6000 
        onboard_speed = .1                                      
        own['getonboard'] = 0 
    if yBut == False and lasty == True:
        own['getonboard'] = 1       

def nextframe():
    framenumber = own["framenum"]
    framenumber = framenumber + 1
    if framenumber == 900000:
        framenumber = 0
    own["framenum"] = framenumber
    own['last_walk_frame'] = framenumber
            
def checkidle():
    idle = cont.sensors["idle"]
    #print(idle.positive)
    idle_frame = own["walk_idle_frame"]
    if idle.positive:
        own["walk_idle_frame"] = 0
        cont.deactivate(camobj.actuators['idle_camRight'])  
        camera.height = .5
    else: 
        if idle_frame == 0:
            own["walk_idle_frame"] = own["framenum"] 
        diff = own["framenum"] - idle_frame
        
        if (diff > 700 and idle_frame != 0 and dropinCol.positive == False and own['walk'] != 0) or own['sit'] == 1:
            #print("you are idle", diff)  
            cont.activate(camobj.actuators['idle_camRight'])  
            camera.height = .9   
            camera.min = 2
            camera.max = 2.50
            own['walk_idling'] = 1
        else:
            own['walk_idling'] = 0    
            
def idle_anim():
    if own['walk_idling'] == 1 and own['sit'] == 0:
        walk_idle_frame = own['walk_idle_frame']
        #print("walk_idling")
        mod_num = (own["framenum"] - walk_idle_frame) % 240
        #print(walk_idle_frame, mod_num)
        #killact(3)
        idle_lay = 300
        if mod_num == 0:
            if own['idle_skipper'] > 0:
               own['idle_skipper'] -= 1 
            ran_num = random.randint(1, 8)
            #print(ran_num, "modding")
            if own['last_idle_num'] == ran_num:
                ran_num = 1
            if own['idle_skipper'] == 0:
                own['last_idle_num'] = ran_num
                if ran_num == 1 or ran_num > 7:    
                    killact(3)
                    if STANCE == 0 and own['throw_deck'] == 0:
                        skater.playAction("reg_idle1", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_reg_idle1", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_reg_idle1", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 0 and own['throw_deck'] == 1:
                        skater.playAction("reg_idle1", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 1 and own['throw_deck'] == 0:
                        skater.playAction("fak_idle1", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_fak_idle1", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_fak_idle1", 1,120, layer=idle_lay, play_mode=0, speed=.5) 
                    elif STANCE == 1 and own['throw_deck'] == 1:
                        skater.playAction("fak_idle1", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                                                                           
                elif ran_num == 2:    
                    killact(3)
                    if STANCE == 0 and own['throw_deck'] == 0:
                        skater.playAction("reg_idle2_", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_reg_idle2", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_reg_idle2", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 0 and own['throw_deck'] == 1:
                        skater.playAction("reg_idle2_nb", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 1 and own['throw_deck'] == 0:
                        skater.playAction("fak_idle1", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_fak_idle1", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_fak_idle1", 1,120, layer=idle_lay, play_mode=0, speed=.5) 
                    elif STANCE == 1 and own['throw_deck'] == 1:
                        skater.playAction("fak_idle1", 1,120, layer=idle_lay, play_mode=0, speed=.5)  
                elif ran_num == 3:    
                    killact(3)
                    if STANCE == 0 and own['throw_deck'] == 0:
                        skater.playAction("reg_idle3", 1,240, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_reg_idle3", 1,240, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_reg_idle3", 1,240, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 0 and own['throw_deck'] == 1:
                        skater.playAction("reg_idle3", 1,240, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 1 and own['throw_deck'] == 0:
                        skater.playAction("fak_idle1", 1,240, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_fak_idle1", 1,240, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_fak_idle1", 1,240, layer=idle_lay, play_mode=0, speed=.5) 
                    elif STANCE == 1 and own['throw_deck'] == 1:
                        skater.playAction("fak_idle1", 1,240, layer=idle_lay, play_mode=0, speed=.5)
                    own['idle_skipper'] = 2 
                elif ran_num == 4:    
                    killact(3)
                    if STANCE == 0 and own['throw_deck'] == 0:
                        skater.playAction("reg_idle4", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_reg_idle4", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_reg_idle4", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 0 and own['throw_deck'] == 1:
                        skater.playAction("reg_idle4", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 1 and own['throw_deck'] == 0:
                        skater.playAction("fak_idle4", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_fak_idle4", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_fak_idle4", 1,120, layer=idle_lay, play_mode=0, speed=.5) 
                    elif STANCE == 1 and own['throw_deck'] == 1:
                        skater.playAction("fak_idle4", 1,120, layer=idle_lay, play_mode=0, speed=.5) 
                elif ran_num == 5:    
                    killact(3)
                    if STANCE == 0 and own['throw_deck'] == 0:
                        skater.playAction("reg_idle5", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_reg_idle5", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_reg_idle5", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 0 and own['throw_deck'] == 1:
                        skater.playAction("reg_idle5", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 1 and own['throw_deck'] == 0:
                        skater.playAction("fak_idle5", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_fak_idle5", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_fak_idle5", 1,120, layer=idle_lay, play_mode=0, speed=.5) 
                    elif STANCE == 1 and own['throw_deck'] == 1:
                        skater.playAction("fak_idle5", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                elif ran_num == 6:    
                    killact(3)
                    if STANCE == 0 and own['throw_deck'] == 0:
                        skater.playAction("reg_idle6", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_reg_idle6", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_reg_idle6", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 0 and own['throw_deck'] == 1:
                        skater.playAction("reg_idle6", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 1 and own['throw_deck'] == 0:
                        skater.playAction("fak_idle6", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_fak_idle6", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_fak_idle6", 1,120, layer=idle_lay, play_mode=0, speed=.5) 
                    elif STANCE == 1 and own['throw_deck'] == 1:
                        skater.playAction("fak_idle6", 1,120, layer=idle_lay, play_mode=0, speed=.5) 
                elif ran_num == 7:    
                    killact(3)
                    if STANCE == 0 and own['throw_deck'] == 0:
                        skater.playAction("reg_idle7", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_reg_idle7", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_reg_idle7", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 0 and own['throw_deck'] == 1:
                        skater.playAction("reg_idle7", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                    elif STANCE == 1 and own['throw_deck'] == 0:
                        skater.playAction("fak_idle6", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        deck.playAction("a_fak_idle6", 1,120, layer=idle_lay, play_mode=0, speed=.5)
                        trucks.playAction("a_fak_idle6", 1,120, layer=idle_lay, play_mode=0, speed=.5) 
                    elif STANCE == 1 and own['throw_deck'] == 1:
                        skater.playAction("fak_idle6", 1,120, layer=idle_lay, play_mode=0, speed=.5)                                                                                                                                 

def reset_pos():
    #reset
    if ddPad == 1:
        
        spawn_pos = own['spawn_pos']
        spawn_rot = own['spawn_rot']
        #spawnz = spawn_pos[2] + .1
        try:
            own.worldPosition = (spawn_pos[0], spawn_pos[1], spawnz)
            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]]
        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)
            #cam.worldPosition = (spawn_pos[0], spawn_pos[1], (spawn_pos[2] + .25))
            #lx = cam.localPosition[1] 
            #lx = lx - 4
            #cam.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.localPosition[1] = lx
         
        else: 
            own.setLinearVelocity([-.1,0,0], 1)         
            #cam.worldPosition = (spawn_pos[0], spawn_pos[1], (spawn_pos[2] + .25))
            #lx = cam.localPosition[1]
            #lx = lx - 4
            #cam.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.localPosition[1] = lx
    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]]
        stance = own["stance"]
        own["spawn_stance"] = stance    
def falldeck():
    #print("falldeck")
    throw_deck_empty = scene.objects["throw_deck_empty"]
    deckact = deck.actuators["Visibility"]
    trucksact = trucks.actuators["Visibility"]
    wheel1act = wheel1.actuators["Visibility"]
    wheel2act = wheel2.actuators["Visibility"]
    wheel3act = wheel3.actuators["Visibility"]
    wheel4act = wheel4.actuators["Visibility"]
            
    if own['throw_deck'] == False:
        own['throw_deck'] = True
        deckact.visibility = False
        trucksact.visibility = False
        wheel1act.visibility = False
        wheel2act.visibility = False
        wheel3act.visibility = False
        wheel4act.visibility = False
        act = throw_deck_empty.actuators['throw_dec_act']
        if STANCE == True:
            #skater.playAction("fak_throw", 10,30, layer=29, priority=0, play_mode=0, speed=.5)
            act.linearVelocity = [0.0, 1.0, 1.0]
        if STANCE == False:
            #skater.playAction("reg_throw", 10,30, layer=29, priority=0, play_mode=0, speed=.5)  
            act.linearVelocity = [0.0, 1.0, -1.0]  
        cont.activate(act)
    else:
        own['throw_deck'] = False    
        deckact.visibility = True
        trucksact.visibility = True
        wheel1act.visibility = True
        wheel2act.visibility = True
        wheel3act.visibility = True
        wheel4act.visibility = True
        throw_deck_empty['kill_deck'] = 1 
        #print("trying to kill deck")     
    cont.activate(deck.actuators['Visibility'])
    cont.activate(trucks.actuators['Visibility'])
    cont.activate(wheel1.actuators['Visibility'])
    cont.activate(wheel2.actuators['Visibility'])
    cont.activate(wheel3.actuators['Visibility'])
    cont.activate(wheel4.actuators['Visibility']) 

def throwdeck():
    throw_deck_empty = scene.objects["throw_deck_empty"]
    deckact = deck.actuators["Visibility"]
    trucksact = trucks.actuators["Visibility"]
    wheel1act = wheel1.actuators["Visibility"]
    wheel2act = wheel2.actuators["Visibility"]
    wheel3act = wheel3.actuators["Visibility"]
    wheel4act = wheel4.actuators["Visibility"]
            
    if own['throw_deck'] == False:
        own['throw_deck'] = True
        deckact.visibility = False
        trucksact.visibility = False
        wheel1act.visibility = False
        wheel2act.visibility = False
        wheel3act.visibility = False
        wheel4act.visibility = False
        act = throw_deck_empty.actuators['throw_dec_act']
        if STANCE == True:
            skater.playAction("fak_throw", 10,30, layer=29, priority=0, play_mode=0, speed=.5)
            act.linearVelocity = [0.0, 5.0, 5.0]
        if STANCE == False:
            skater.playAction("reg_throw", 10,30, layer=29, priority=0, play_mode=0, speed=.5)  
            act.linearVelocity = [0.0, 5.0, -5.0]  
        cont.activate(act)
    else:
        own['throw_deck'] = False    
        deckact.visibility = True
        trucksact.visibility = True
        wheel1act.visibility = True
        wheel2act.visibility = True
        wheel3act.visibility = True
        wheel4act.visibility = True
        throw_deck_empty['kill_deck'] = 1 
        #print("trying to kill deck")     
    cont.activate(deck.actuators['Visibility'])
    cont.activate(trucks.actuators['Visibility'])
    cont.activate(wheel1.actuators['Visibility'])
    cont.activate(wheel2.actuators['Visibility'])
    cont.activate(wheel3.actuators['Visibility'])
    cont.activate(wheel4.actuators['Visibility'])    
        
def throwdeck_trigger():
    lastb = own['lastb']
    throw_deck_empty = scene.objects["throw_deck_empty"]
    if bBut == False:
        throw_deck_empty['kill_deck'] = 0
    if bBut == False and own['lastb'] == True:        
        #print("throw deck")
        throwdeck()        
              
def fall():
    if own['fall'] == True:
        falldeck()
        if STANCE == 1:
            own.setLinearVelocity([3,2,0], True)
        else:
            own.setLinearVelocity([-3,-2,0], True)    
        own['fall'] = False

def sit():
    #turn off sit
    if lup == 1 or ldown == 1 or lUD > sens or lUD < -sens:
        if own['sit'] == 1:
            killact(300)
            killact(299)
        own['sit'] = 0

    if aBut == False and lasta == True:
        #print(lasta)
        try:
            #print(r_ground.hitObject)
            if 'sit' in r_ground.hitObject:
                print("sit")
                own['sit'] = 1
                #killall()
                killact(3)
                if STANCE == 0:
                    skater.playAction("reg_sit", 1,65, layer=300, play_mode=0, speed=1)
                    deck.playAction("a_reg_sit", 1,65, layer=300, play_mode=0, speed=1)
                    trucks.playAction("a_reg_sit", 1,65, layer=300, play_mode=0, speed=1)
                elif STANCE == 1:
                    skater.playAction("fak_sit", 1,65, layer=300, play_mode=0, speed=1)
                    deck.playAction("a_fak_sit", 1,65, layer=300, play_mode=0, speed=1)
                    trucks.playAction("a_fak_sit", 1,65, layer=300, play_mode=0, speed=1)                                         
    #if own['sit'] == 1 and last_sit == 0:
                 
                     
                
        except:
            #print("sit broke")
            pass    
    if own['sit'] == 1:
        try:
            killact(3)
            sit_vect = r_ground.hitObject.getAxisVect( [0, 1, 0])
            if STANCE == 0:
                own.alignAxisToVect(-sit_vect, 0, .2)
                skater.playAction("reg_sit", 65,65, layer=299, play_mode=1, speed=1)
                deck.playAction("a_reg_sit", 65,65, layer=299, play_mode=1, speed=1)
                trucks.playAction("a_reg_sit", 65,65, layer=299, play_mode=1, speed=1)                                 
                
            elif STANCE == 1:
                own.alignAxisToVect(sit_vect, 0, .2) 
                skater.playAction("fak_sit", 65,65, layer=299, play_mode=1, speed=1)
                deck.playAction("a_fak_sit", 65,65, layer=299, play_mode=1, speed=1)
                trucks.playAction("a_fak_sit", 65,65, layer=299, play_mode=1, speed=1)                    
        except:
            pass    

                      
def switchcam():
    if ltsBut == False and own['lastlts'] == True and rtsBut == False:
        if own['camera'] == 1:
            own['camera'] = 0
        else:
            own['camera'] = 1
    if rtsBut == False and own['lastrts'] == True and ltsBut == False:
        if own['camera'] == 2:
            own['camera'] = 0
        else:
            own['camera'] = 2 
#followcam 
def move_followcam():
    if own['camera'] == 2:
        #if rtsBut == False and own['lastrts'] == True:
        if own['lastbkBut'] == True and bkBut == False:
            print("activate move followcam") 
            if own['move_followcam'] == False:
                own['move_followcam'] = True
            else:
                own['move_followcam'] = False                       
        if own['move_followcam'] == True:
            #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"])
                print("fastup")
            else:
                cont.deactivate(followcam.actuators["up"])    
#            #down    
            if lUD > .080:
                followcam.actuators["down"].dLoc = [ 0, 0, camspeed2]
                cont.activate(followcam.actuators["down"])
            else:
                cont.deactivate(followcam.actuators["down"])                    
#            #left
            if lLR < -0.080:
                followcam.actuators["left"].dLoc = [-camspeed2, 0, 0]                
                cont.activate(followcam.actuators["left"])
            else:
                cont.deactivate(followcam.actuators["left"])                    
#            #right
            if lLR > 0.080:         
                followcam.actuators["right"].dLoc = [camspeed2, 0, 0]                
                cont.activate(followcam.actuators["right"])
            else:
                cont.deactivate(followcam.actuators["right"])  
            #up
            if rUD < -0.080:
                followcam.actuators["rotup"].dLoc = [0, 0, camrot2]
                cont.activate(followcam.actuators["rotup"])
                #print("uppppppppppppppppppppppppppp")
            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"])
                #print(lUD)
            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 rtsBut == False and own['lastrts'] == True:
        if own['lastbkBut'] == True and bkBut == False: 
            if own['move_freecam'] == False:
                own['move_freecam'] = True
            else:
                own['move_freecam'] = False                       
        if own['move_freecam'] == True:
            #act = freecam.actuators[
            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"])
                #print("fastup")
            else:
                cont.deactivate(freecam.actuators["up"])    
#            #down    
            if lUD > .080:
                freecam.actuators["down"].dLoc = [ 0, 0, camspeed2]
                cont.activate(freecam.actuators["down"])
            else:
                cont.deactivate(freecam.actuators["down"])                    
#            #left
            if lLR < -0.080:
                freecam.actuators["left"].dLoc = [-camspeed2, 0, 0]                
                cont.activate(freecam.actuators["left"])
            else:
                cont.deactivate(freecam.actuators["left"])                    
#            #right
            if lLR > 0.080:         
                freecam.actuators["right"].dLoc = [camspeed2, 0, 0]                
                cont.activate(freecam.actuators["right"])
            else:
                cont.deactivate(freecam.actuators["right"])  
            #up
            if rUD < -0.080:
                freecam.actuators["rotup"].dRot = [camrot2, 0, 0]
                cont.activate(freecam.actuators["rotup"])
            else:
                cont.deactivate(freecam.actuators["rotup"])    
#            #down    
            if rUD > .080:
                freecam.actuators["rotdown"].dRot = [-camrot2, 0, 0]                
                cont.activate(freecam.actuators["rotdown"])
            else:
                cont.deactivate(freecam.actuators["rotdown"])                    
#            #left
            if rLR < -0.080:
                freecam.actuators["rotleft"].dRot = [0, 0, camrot2]                
                cont.activate(freecam.actuators["rotleft"])
            else:
                cont.deactivate(freecam.actuators["rotleft"])                    
#            #right
            if rLR > 0.080:         
                freecam.actuators["rotright"].dRot = [0, 0, -camrot2]
                cont.activate(freecam.actuators["rotright"])
            else:
                cont.deactivate(freecam.actuators["rotright"]) 

#*********************************************                
                
            if lUD > -0.080 and lUD < -0.030:
                freecam.actuators["up"].dLoc = [ 0, 0, -camspeed1]
                cont.activate(freecam.actuators["up"])
                #print(lUD)
            else:
                cont.deactivate(freecam.actuators["up"])    
#            #down    
            if lUD < .080 and lUD > .03:
                freecam.actuators["down"].dLoc = [ 0, 0, camspeed1]                
                cont.activate(freecam.actuators["down"])
            else:
                cont.deactivate(freecam.actuators["down"])                    
#            #left
            if lLR > -0.080 and lLR < -0.030:
                freecam.actuators["left"].dLoc = [-camspeed1, 0, 0]                
                cont.activate(freecam.actuators["left"])
            else:
                cont.deactivate(freecam.actuators["left"])                    
#            #right
            if lLR < .080 and lLR > .03:       
                freecam.actuators["right"].dLoc = [camspeed1, 0, 0]
                cont.activate(freecam.actuators["right"])
            else:
                cont.deactivate(freecam.actuators["right"])  
            #up
            if rUD > -0.080 and rUD < -0.030:
                freecam.actuators["rotup"].dRot = [camrot1, 0, 0]                
                cont.activate(freecam.actuators["rotup"])
            else:
                cont.deactivate(freecam.actuators["rotup"])    
#            #down    
            if rUD < .080 and rUD > .03:
                freecam.actuators["rotdown"].dRot = [-camrot1, 0, 0]                
                cont.activate(freecam.actuators["rotdown"])
            else:
                cont.deactivate(freecam.actuators["rotdown"])                    
#            #left
            if rLR > -0.080 and rLR < -0.030:
                freecam.actuators["rotleft"].dRot = [0, 0, camrot1]
                cont.activate(freecam.actuators["rotleft"])
            else:
                cont.deactivate(freecam.actuators["rotleft"])                    
#            #right
            if rLR < .080 and rLR > .03:         
                freecam.actuators["rotright"].dRot = [0, 0, -camrot1]
                cont.activate(freecam.actuators["rotright"])
            else:
                cont.deactivate(freecam.actuators["rotright"])                     
if r_ground.triggered == False:
    cont.deactivate(own.actuators["walk_align"])
else:
    cont.activate(own.actuators["walk_align"])                    

if r_ground.triggered:
    #print("on stair")
    try:
        if 'stair' in r_ground.hitObject:
            own['stair_counter'] = 20
            force = [ 0.0, 0.0, -100]
            # use local axis
            local = True
            # apply force
            #own.applyForce(force, local)        
    except:
        pass        
    if own['stair_counter'] > 0:
       own['stair_counter'] -= 1     

if yBut == True:
    own['walk_idling'] = 0
    own["walk_idle_frame"] = 0

                    
onboard() 
jump()
dropin()
throwdeck_trigger()

nextframe()
checkidle()
getonboard()
reset_pos()
switchcam()
move_flycam()
move_followcam()
fall()
idle_anim()
sit()
#cont.activate(cam.actuators['Camera'])
#printplaying() 

own.alignAxisToVect([0.0,0.0,1.0], 2, .03)
own.actuators["sroll"].stopSound() 
wheel1 = scene.objects["rollen.000"]
wheel2 = scene.objects["rollen.001"]
wheel3 = scene.objects["rollen.002"]
wheel4 = scene.objects["rollen.003"]
wheel1.stopAction(2)
wheel2.stopAction(2)
wheel3.stopAction(2)
wheel4.stopAction(2)


own['lasty'] = yBut
own['lastb'] = bBut  
own['lasta'] = aBut
own['lastx'] = xBut   
own['lastlts'] = ltsBut
own['lastrts'] = rtsBut        
own['lastbkBut'] = bkBut
own['dropinCol'] = dropinCol
own['walk'] = 1