shuvit/scripts/walk.py

#shuvit.org
#walk.py

import bge
import GameLogic
import ctypes
import random
import math

def main(cont):
    
    scene = bge.logic.getCurrentScene()
    objList = scene.objects
    cont = GameLogic.getCurrentController() 
    obj = bge.logic.getCurrentScene().objects
    char = bge.constraints.getCharacter
    own = cont.owner
    stance = own['stance']
    STANCE = own['stance']
    r_ground = cont.sensors["r_Ground"]
    linvel = own.getLinearVelocity(True)
    lasta = own['lasta']
    lastx = own['lastx']
    last_sit = own['sit']
    dict = bge.logic.globalDict

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

    truckon = 450
    deckon = 460

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

    #user
    sens = .04
    fliplay = 30
    dropinCol = own.sensors['dropinCol']
    cube = scene.objects['control_cube.002']
    skater = scene.objects["Char4"]
    deck = scene.objects["b_deck"]
    trucks = scene.objects["b_trucks"]
    camobj2 = scene.objects['camobj']
    throw_deck_empty = scene.objects["throw_deck_empty"]
    wheel1 = scene.objects["wheel1"]
    wheel2 = scene.objects["wheel2"]
    wheel3 = scene.objects["wheel3"]
    wheel4 = scene.objects["wheel4"]
    camobj = scene.objects["Camera.003"]
    camera = cont.actuators["Camera"]
    replayCam = cont.actuators["replayCam"]
    timer = own['dropinTimer']
    cam = scene.objects["Camera.003"]
    freecam = scene.objects["freecam"]
    followcam = scene.objects["followcam"]

    control_bottom = scene.objects['control_bottom']
    cb = control_bottom.sensors['grindCol_bottom']
    cb_td = control_bottom.sensors['td_bottom']

    noidle = 0

    #if skater.isPlayingAction(460):  
    #    noidle = 1  


    try:
        walk_inc = own['walk_inc'] 
    except:
        own['walk_inc'] = .01
        walk_inc = own['walk_inc']  
        own['walk_jump_timer'] = 0   
    if own['stair_counter'] != 0:
        walk_inc = own['walk_inc']  *10

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

    def printplaying():
        splaying_layers = "S: "
        playing_layers = "D: "
        tplaying_layers = "T: "
        for x in range(9900):
            if skater.isPlayingAction(x):
            #if trucks.isPlayingAction(x):
            #if skater.isPlayingAction(x):                        
                splaying_layers += str(x)
                splaying_layers += " "        
            if deck.isPlayingAction(x):
            #if trucks.isPlayingAction(x):
            #if skater.isPlayingAction(x):                        
                playing_layers += str(x)
                playing_layers += " "
            if trucks.isPlayingAction(x):
            #if trucks.isPlayingAction(x):
            #if skater.isPlayingAction(x):                        
                tplaying_layers += str(x)
                tplaying_layers += " "            
        print(splaying_layers, playing_layers, tplaying_layers) 
    #printplaying() 
    ##
    if r_ground.positive and xBut == False and lastx == False:
        killact(10)
        #killact(11)
        killact(12)
        killact(13)              
    ######################################    

    #idle      
    if stance == 0 and skater.isPlayingAction(fliplay) == False and yBut == False and r_ground.triggered and xBut == False and noidle == 0 and own['walk_idling'] == 0 and own['sit'] == 0 and own['dropinTimer'] == 0 and own['lasty']  == False:
        own['requestAction'] = 'reg_idle'
        if own['throw_deck'] == True:
            own['requestAction'] = 'reg_idle_nb'

    if stance == 1 and skater.isPlayingAction(fliplay) == False and yBut == False and r_ground.triggered and xBut == False and noidle == 0 and own['walk_idling'] == 0 and own['sit'] == 0 and own['dropinTimer'] == 0 and own['lasty']  == False:
        own['requestAction'] = 'fak_idle'
        if own['throw_deck'] == True:
            own['requestAction'] = 'fak_idle_nb'

    if lUD < -sens:
        lup = 1
    else:
        lup = 0
    if lUD > sens:
        ldown = 1
    else:
        ldown = 0 
    if lLR < -sens:
        lLeft = 1
    else:
        lLeft = 0
    if lLR > sens:
        lRight = 1
    else:
        lRight = 0        



    #turning
    turning = False
    if r_ground.positive:
        num = .5
        tilt = .015
        if STANCE == 1:
            num *= -1
            tilt *= -1
        if lRight == 1 or dict['kb_ra'] == 2:
            #cont.activate(own.actuators['right'])
            own.linearVelocity.y = num
            if own['stair_counter'] > 0:
                if STANCE == 0:
                    own.applyRotation([0,0,.05], True)
                else:
                    own.applyRotation([0,0,-.05], True)                
            else:
                own.applyRotation([-tilt, 0, 0], True)
            turning = True
        else:
            #cont.deactivate(own.actuators['right']) 
            pass  
            
        if lLeft == 1 or dict['kb_la'] == 2:
            #cont.activate(own.actuators['left']) 
            own.linearVelocity.y = -num
            if own['stair_counter'] > 0:
                if STANCE == 0:
                    own.applyRotation([0,0,.05], True)
                else:
                    own.applyRotation([0,0,-.05], True)                                
            else:        
                own.applyRotation([tilt, 0, 0], True)        
            turning = True
        else:
            #cont.deactivate(own.actuators['left'])        
            pass

    #in air        
    #if (lup == 1 or dict['kb_ua'] != 0) and r_ground.positive == False:
    if r_ground.positive == False:
        airrot = .05
        if lLeft == 1 or dict['kb_la'] == 2:
            if stance == 0:
                own.applyRotation([0,0,airrot], True)
            if stance == 1:    
                own.applyRotation([0,0,airrot], True)
        if lRight == 1 or dict['kb_ra'] == 2:
            if stance == 0:
                own.applyRotation([0,0,-airrot], True)
            if stance == 1:    
                own.applyRotation([0,0,-airrot], True)  
                
        if lup == 1 or dict['kb_ua'] == 2:
            if own.linearVelocity.x < 10 and own .linearVelocity.x > - 10:
                if stance == 0:
                    own.linearVelocity.x -= .04
                if stance == 1:
                    own.linearVelocity.x += .04                             
        own['lF_air_frame'] = own['framenum']  
        own.actuators["walkondirt"].stopSound()

        
    #walking

    #new walking
    vel = own.getLinearVelocity(True)
    if own['walk_timer'] < 50:
        velx = vel.x * .95             
        own.setLinearVelocity([velx, 0, vel.z], True)
        #print('y is zero')
    else:
        pass
        #own.setLinearVelocity([0, 0, vel.z], True)
        
    wf = 1
    if own['last_walk_frame'] - own['last_roll_frame'] > 55:
        wf = 0   
       
    if ((lup == 1 and aBut == 0) or (dict['kb_ua'] == 2 and dict['kb_lsh'] == 0)) and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0 and wf == 0 and dict['kb_space'] == 0:
        own['walking'] = "regular"
        walking = "regular"
        
    elif ((lup == 1 and aBut == 1) or (dict['kb_lsh'] == 2 and dict['kb_ua'] == 2)) and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0 and wf == 0 and dict['kb_space'] != 2:
        own['walking'] = "fast"
        walking = "fast"
    else:
        own['walking'] = None
        walking = None
       
    if walking == "regular":  
        if stance == 1:
            if linvel.x < own['walk_targ_speed']:
                own.linearVelocity.x = linvel.x + walk_inc
            else:
                own.linearVelocity.x = own['walk_targ_speed']    
        else:
            if linvel.x > -own['walk_targ_speed']:
                own.linearVelocity.x = linvel.x - walk_inc       
            else:
                own.linearVelocity.x = -own['walk_targ_speed']                
    if walking == "fast":   
        if stance == 1:
            if linvel.x < own['walk_fast_targ_speed']:
                own.linearVelocity.x = linvel.x + walk_inc
            else:
                own.linearVelocity.x = own['walk_fast_targ_speed']  
        else:
            if linvel.x > -own['walk_fast_targ_speed']:
                own.linearVelocity.x = linvel.x - walk_inc      
            else:
                own.linearVelocity.x = -own['walk_fast_targ_speed'] 

    if walking == None and r_ground.positive and own['walk_jump_timer'] == 0:      
        if own['walk_timer'] < 50 and turning == False:
            velx = vel.x * .95             
            own.setLinearVelocity([velx, 0, vel.z], True)
        elif own['walk_timer'] > 50:
            if own.linearVelocity.x > .1 or own.linearVelocity.x < -.1:
                own.linearVelocity.x *= .01
            else:
                own.linearVelocity.x = 0
            if turning == False:    
                if own.linearVelocity.y > .01 or own.linearVelocity.y < -.01:
                    own.linearVelocity.y *= .01
                else:
                    own.linearVelocity.y = 0                
            #own.setLinearVelocity([0, 0, vel.z], True) 
        
    #old walking
    if ((lup == 1 and aBut == 0) or (dict['kb_ua'] == 2 and dict['kb_lsh'] == 0)  and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0) or (turning == True and aBut == 0):
        own.actuators["walkondirt"].volume = .2
        own.actuators["walkondirt"].pitch = 1
        cont.activate(own.actuators["walkondirt"])          
        if stance == 0 and skater.isPlayingAction(fliplay) == False:             
            #without deck
            if own['throw_deck'] == True:
                own['requestAction'] = 'reg_walk_nb'
            else:
                own['requestAction'] = 'reg_walk'
                   
        if stance == 1 and skater.isPlayingAction(fliplay) == False:        
            #without deck
            if own['throw_deck'] == True:
                own['requestAction'] = 'fak_walk_nb'
            else:
                own['requestAction'] = 'fak_walk'
           
    elif (((lup == 1 and aBut == 1) or (dict['kb_lsh'] == 2 and dict['kb_ua'] == 2)) and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0) or (turning == True and aBut == 1):
        own.actuators["walkondirt"].volume = .2
        own.actuators["walkondirt"].pitch = 1.3
        cont.activate(own.actuators["walkondirt"])
        #print('fastwalk')
        if stance == 0 and skater.isPlayingAction(fliplay) == False:        
            if own['throw_deck'] == True:
                own['requestAction'] = 'reg_walkFast_nb'
            else:
                own['requestAction'] = 'reg_walkFast'
             
        if stance == 1 and skater.isPlayingAction(fliplay) == False:        
            if own['throw_deck'] == True:
                own['requestAction'] = 'fak_walkFast_nb'          
            else:
                own['requestAction'] = 'fak_walkFast'             
    else:
        vel = own.getLinearVelocity(True)
        cont.deactivate(own.actuators["walkondirt"])       

           
    #---------------
    if rLR > .05:
        cont.activate(camobj.actuators['camRight'])
    else:
        cont.deactivate(camobj.actuators['camRight'])    
    if rLR < -.05:
        cont.activate(camobj.actuators['camLeft'])
    else:
        cont.deactivate(camobj.actuators['camLeft'])     
    if rUD > .05:
        cont.activate(camobj.actuators['camDown'])
    else:
        cont.deactivate(camobj.actuators['camDown'])     
    if rUD < -.05:
        cont.activate(camobj.actuators['camUp'])
    else:
        cont.deactivate(camobj.actuators['camUp'])     
                    
    #----------------
    #camera.height = .01 #.9
    #camera.min = 1.75
    #camera.max = 2.25
    lasty = own['lasty']     

    def onboard():
        if own['walk'] == 0:
            #print("start walking")
            own['walk_idling'] = 0
            if own['framenum'] > 100 and own['fall'] == False:
                cont.activate(own.actuators['pop'])
            own['getoffboard'] = False
            own["walk_idle_frame"] = own["framenum"]
            own['grindcement_vol'] = 0
            own['grindcement_pitch'] = 0
            own['grindrail_vol'] = 0
            own['grindrail_pitch'] = 0 
            own['sroll_vol'] = 0
            own['sroll_pitch'] = 0   
            
            #camobj.worldPosition.z += 4              
            try:
                vel = own['offboard_vel']
                vel = [velx, vel.y, vel.z]           
            except: 
                pass
             
            if STANCE == 0:
                own['requestAction'] = 'reg_offboard'             
                
            if STANCE == 1:
                own['requestAction'] = 'fak_offboard'                          
    def jump():
        #limit fall speed
        if linvel.z < -10:
            own.linearVelocity.z = -10
        if xBut == True or dict['kb_space'] == 1: 
            if own['lastx'] == 0:
                #killact(3)
                #killact(4)
                #killact(5)
                #killact(6)
                #killact(7)      
                if STANCE == 0:  
                    own['requestAction'] ='reg_jump'  
                    #print('jump') 
                if STANCE == 1:
                    own['requestAction'] ='fak_jump'             
                    #print('jump')
                JUMPHEIGHT = 1100
                force = [ 0.0, 0.0, JUMPHEIGHT]
                # use local axis
                local = False
                # apply force -- limit jump speed
                if linvel.z < 10:
                    #own.applyForce(force, local)
                    own.linearVelocity.z += 5
                    own.linearVelocity.x = linvel.x
                    own.linearVelocity.y = linvel.y
                    own['walk_jump_timer'] = 6
            own['lastx'] = 1
        else:
            own['lastx'] = 0  
            
    def getonboard(dict, cont):
        grindDar = cont.sensors['grindDar2']
        getonboard = own['getonboard']
        fliplay2 = 50#8560
        if ((yBut == True and dict['last_yBut'] == False) or dict['kb_q'] == 2):# and (cont.sensors["vehicleNear"].positive == False and own['throw_deck'] == False):
            fliplay3 = fliplay2 + 1
            dar = 0 
            if grindDar.hitObjectList != None:
                for x in grindDar.hitObjectList:
                    to_grinder = (x.worldPosition - own.worldPosition).length
                    #if 'coping' in x and to_grinder < .36:
                    if 'coping' in x:    
                        dar = 1
            if dropinCol.positive == True or dar == 1: 
                nearestObject = None
                grindEmpty = scene.objects['grindEmpty']
                grindDar = grindEmpty.sensors['grindDar2']
                minDist = None             
                if grindDar.positive:
                    detectedObjects = grindDar.hitObjectList
                    dist = 0
                    for obj in detectedObjects:
                        dist = own.getDistanceTo(obj)
                        if (minDist is None or dist < minDist):
                            nearestObject = obj
                            minDist = dist
                # if nearestObject != None:
                #     #print(nearestObject)
                #     obj = nearestObject
                #     player_e = own.worldOrientation.to_euler()
                #     player_pos = own.worldPosition
                #     player_rotz = math.degrees(player_e[2])                
                #     grinder_e = obj.worldOrientation.to_euler()
                #     grinder_rotz = math.degrees(grinder_e[2])            
                #     rot = player_rotz - grinder_rotz  
                #     grinder_pos = obj.worldPosition 
                #     worldVect = [1, 0, 0]
                #     vect = obj.getAxisVect(worldVect)      
                #     go = obj.worldOrientation
                #     grinder_axis = [1,0,0] 
                #     try: 
                #         delta = player_pos - grinder_pos
                        
                #         delta = delta.cross(vect)
                #         if delta[2] >= 0:
                #             grindside = "right"
                #         else:
                #             grindside = "left"                    
                #         deltamove = delta[2] * .1#.25
                #         if STANCE == 0:
                #             move = [-deltamove, 0, 0]
                #         else:
                #             move = [deltamove, 0, 0]                            
                #         own.applyMovement(move, True)                    
                #     except:
                #         pass 
                print('dropin')
                if STANCE == 0: 
                    own['requestAction'] ='reg_dropin_pos' 
                    own['dropinTimer'] = 60                                     
                        
                if STANCE == 1: 
                    own['requestAction'] ='fak_dropin_pos'  
                    own['dropinTimer'] = 60                                 
                                         
        if getonboard == 1:
            fliplay3 = 6000 
            onboard_speed = .1                                      
            own['getonboard'] = 0 
            own['walk_idling'] = 0
        if (yBut == False and lasty == True) or (yBut == True or dict['kb_q'] == 2) and dropinCol.positive:
            deckact = deck.actuators["Visibility"]
            trucksact = trucks.actuators["Visibility"]
            wheel1act = wheel1.actuators["Visibility"]
            wheel2act = wheel2.actuators["Visibility"]
            wheel3act = wheel3.actuators["Visibility"]
            wheel4act = wheel4.actuators["Visibility"]        
            deckact.visibility = True
            trucksact.visibility = True
            wheel1act.visibility = True
            wheel2act.visibility = True
            wheel3act.visibility = True
            wheel4act.visibility = True  
            cont.activate(deck.actuators['Visibility'])
            cont.activate(trucks.actuators['Visibility'])
            cont.activate(wheel1.actuators['Visibility'])
            cont.activate(wheel2.actuators['Visibility'])
            cont.activate(wheel3.actuators['Visibility'])
            cont.activate(wheel4.actuators['Visibility']) 
            own['throw_deck'] = False 
            throw_deck_empty = scene.objects["throw_deck_empty"]
            throw_deck_empty['kill_deck'] = 1 
        if ((yBut == False and lasty == True) or dict['kb_q'] == 3):# and cont.sensors["vehicleNear"].positive == False:               
            own['getonboard'] = 1 
            own['walk_idling'] = 0      

    def nextframe():
        framenumber = own["framenum"]
        framenumber = framenumber + 1
        if framenumber == 900000:
            framenumber = 0
        own["framenum"] = framenumber
        own['last_walk_frame'] = framenumber
                
    def checkidle():
        idle = cont.sensors["idle"]
        idle_frame = own["walk_idle_frame"]
        if idle.positive:
            own["walk_idle_frame"] = 0
            cont.deactivate(camobj.actuators['idle_camRight'])  
            #camera.height = .5
            camera.height = dict['cam_idle_height']
        else: 
            if idle_frame == 0:
                own["walk_idle_frame"] = own["framenum"] 
            diff = own["framenum"] - idle_frame
            
            if (diff > 700 and idle_frame != 0 and dropinCol.positive == False and own['walk'] != 0) or own['sit'] == 1:
                cont.activate(camobj.actuators['idle_camRight'])  
                #camera.height = .9   
                #camera.min = 2
                #camera.max = 2.50
                own['walk_idling'] = 1
            else:
                own['walk_idling'] = 0    
                
    def idle_anim():
        if own['walk_idling'] == 1 and own['sit'] == 0:
            walk_idle_frame = own['walk_idle_frame']
            mod_num = (own["framenum"] - walk_idle_frame) % 240
            idle_lay = 300
            if mod_num == 0:
                if own['idle_skipper'] > 0:
                   own['idle_skipper'] -= 1 
                ran_num = random.randint(1, 8)
                if own['last_idle_num'] == ran_num:
                    ran_num = 1
                if own['idle_skipper'] == 0:
                    own['last_idle_num'] = ran_num
                    if ran_num == 1 or ran_num > 7:    
                        killact(3)
                        if STANCE == 0 and own['throw_deck'] == 0:
                            own['requestAction'] = 'reg_idle1'
                        elif STANCE == 0 and own['throw_deck'] == 1:
                            own['requestAction'] = 'reg_idle1'
                        elif STANCE == 1 and own['throw_deck'] == 0:
                            own['requestAction'] = 'fak_idle1'
                        elif STANCE == 1 and own['throw_deck'] == 1:
                            own['requestAction'] = 'fak_idle1'
                                                                               
                    elif ran_num == 2:    
                        killact(3)
                        if STANCE == 0 and own['throw_deck'] == 0:
                            own['requestAction'] = 'reg_idle2'
                        elif STANCE == 0 and own['throw_deck'] == 1:
                            own['requestAction'] = 'reg_idle2_nb'
                        elif STANCE == 1 and own['throw_deck'] == 0:
                            own['requestAction'] = 'fak_idle1'
                        elif STANCE == 1 and own['throw_deck'] == 1:
                            own['requestAction'] = 'fak_idle1'
                    elif ran_num == 3:    
                        killact(3)
                        if STANCE == 0 and own['throw_deck'] == 0:
                            own['requestAction'] = 'reg_idle3'
                        elif STANCE == 0 and own['throw_deck'] == 1:
                            own['requestAction'] = 'reg_idle3'
                        elif STANCE == 1 and own['throw_deck'] == 0:
                            own['requestAction'] = 'fak_idle1'
                        elif STANCE == 1 and own['throw_deck'] == 1:
                            own['requestAction'] = 'fak_idle1'
                        own['idle_skipper'] = 2 
                    elif ran_num == 4:    
                        killact(3)
                        if STANCE == 0 and own['throw_deck'] == 0:
                            own['requestAction'] = 'reg_idle4'
                        elif STANCE == 0 and own['throw_deck'] == 1:
                            own['requestAction'] = 'reg_idle4'
                        elif STANCE == 1 and own['throw_deck'] == 0:
                            own['requestAction'] = 'fak_idle4'
                        elif STANCE == 1 and own['throw_deck'] == 1:
                            own['requestAction'] = 'fak_idle4' 
                    elif ran_num == 5:    
                        killact(3)
                        if STANCE == 0 and own['throw_deck'] == 0:
                            own['requestAction'] = 'reg_idle5'
                        elif STANCE == 0 and own['throw_deck'] == 1:
                            own['requestAction'] = 'reg_idle5'
                        elif STANCE == 1 and own['throw_deck'] == 0:
                            own['requestAction'] = 'fak_idle5'
                        elif STANCE == 1 and own['throw_deck'] == 1:
                            own['requestAction'] = 'fak_idle5'
                    elif ran_num == 6:    
                        killact(3)
                        if STANCE == 0 and own['throw_deck'] == 0:
                            own['requestAction'] = 'reg_idle6'
                        elif STANCE == 0 and own['throw_deck'] == 1:
                            own['requestAction'] = 'reg_idle6'
                        elif STANCE == 1 and own['throw_deck'] == 0:
                            own['requestAction'] = 'fak_idle6'
                        elif STANCE == 1 and own['throw_deck'] == 1:
                            own['requestAction'] = 'fak_idle6'
                    elif ran_num == 7:    
                        killact(3)
                        if STANCE == 0 and own['throw_deck'] == 0:
                            own['requestAction'] = 'reg_idle7'
                        elif STANCE == 0 and own['throw_deck'] == 1:
                            own['requestAction'] = 'reg_idle7'
                        elif STANCE == 1 and own['throw_deck'] == 0:
                            own['requestAction'] = 'fak_idle6'
                        elif STANCE == 1 and own['throw_deck'] == 1:
                            own['requestAction'] = 'fak_idle6'

    def reset_pos():
        #reset
        if ddPad == 1:   
            spawn_pos = own['spawn_pos']
            spawn_rot = own['spawn_rot']
            spawn_cam_pos = own['spawn_cam_pos']
            spawn_cam_rot = own['spawn_cam_rot']            
            try:
                own.worldPosition = (spawn_pos[0], spawn_pos[1], (spawn_pos[2] + .1))
                own.worldOrientation = [[spawn_rot[0][0],spawn_rot[0][1],spawn_rot[0][2]], [spawn_rot[1][0],spawn_rot[1][1],spawn_rot[1][2]], [0.0, 0.0, 1.0]]
                cam.worldPosition = (spawn_cam_pos[0], spawn_cam_pos[1], (spawn_cam_pos[2]))
                cam.worldOrientation = [[spawn_cam_rot[0][0],spawn_cam_rot[0][1],spawn_cam_rot[0][2]], [spawn_cam_rot[1][0],spawn_cam_rot[1][1],spawn_cam_rot[1][2]], [0.0, 0.0, 1.0]]            
            except:    
                own.worldPosition = (5, 2, .1)
                own.worldOrientation = [[1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] 
            own['stance'] = own['spawn_stance']                          
            if own["spawn_stance"] == 1:
                own.setLinearVelocity([.1,0,0], 1)
            else: 
                own.setLinearVelocity([-.1,0,0], 1)         
                
        if udPad == 1:        
            own['spawn_pos'] = [own.worldPosition[0], own.worldPosition[1], own.worldPosition[2]] 
            own['spawn_rot'] = [[own.worldOrientation[0][0],own.worldOrientation[0][1],own.worldOrientation[0][2]], [own.worldOrientation[1][0],own.worldOrientation[1][1],own.worldOrientation[1][2]], own.worldOrientation[2][2]]
            own['spawn_cam_pos'] = [cam.worldPosition[0], cam.worldPosition[1], cam.worldPosition[2]] 
            own['spawn_cam_rot'] = [[cam.worldOrientation[0][0],cam.worldOrientation[0][1],cam.worldOrientation[0][2]], [cam.worldOrientation[1][0],cam.worldOrientation[1][1],cam.worldOrientation[1][2]], cam.worldOrientation[2][2]]            
            stance = own["stance"]
            own["spawn_stance"] = stance   
    def falldeck():
        throw_deck_empty = scene.objects["throw_deck_empty"]
        throw_deck_empty.worldPosition.y += .5
        throw_deck_empty.worldPosition.x += .5
        deckact = deck.actuators["Visibility"]
        trucksact = trucks.actuators["Visibility"]
        wheel1act = wheel1.actuators["Visibility"]
        wheel2act = wheel2.actuators["Visibility"]
        wheel3act = wheel3.actuators["Visibility"]
        wheel4act = wheel4.actuators["Visibility"]
        print('doing falldeck')        
        if own['throw_deck'] == False:
            own['throw_deck'] = True
            deckact.visibility = False
            trucksact.visibility = False
            wheel1act.visibility = False
            wheel2act.visibility = False
            wheel3act.visibility = False
            wheel4act.visibility = False
            act = throw_deck_empty.actuators['throw_dec_act']
            if STANCE == True:
                act.linearVelocity = [0.0, 1.0, 1.0]
            if STANCE == False:
                act.linearVelocity = [0.0, 1.0, -1.0]  
            cont.activate(act)
            print('running falldeck()')
        else:
            own['throw_deck'] = False    
            deckact.visibility = True
            trucksact.visibility = True
            wheel1act.visibility = True
            wheel2act.visibility = True
            wheel3act.visibility = True
            wheel4act.visibility = True
            throw_deck_empty['kill_deck'] = 1    
        cont.activate(deck.actuators['Visibility'])
        cont.activate(trucks.actuators['Visibility'])
        cont.activate(wheel1.actuators['Visibility'])
        cont.activate(wheel2.actuators['Visibility'])
        cont.activate(wheel3.actuators['Visibility'])
        cont.activate(wheel4.actuators['Visibility']) 

    def throwdeck(strength, ud):
        throw_deck_empty = scene.objects["throw_deck_empty"]
        deckact = deck.actuators["Visibility"]
        trucksact = trucks.actuators["Visibility"]
        wheel1act = wheel1.actuators["Visibility"]
        wheel2act = wheel2.actuators["Visibility"]
        wheel3act = wheel3.actuators["Visibility"]
        wheel4act = wheel4.actuators["Visibility"]
                
        if own['throw_deck'] == False:
            own['throw_deck'] = True
            deckact.visibility = False
            trucksact.visibility = False
            wheel1act.visibility = False
            wheel2act.visibility = False
            wheel3act.visibility = False
            wheel4act.visibility = False
            act = throw_deck_empty.actuators['throw_dec_act']
            hard = strength * .08
            if hard > 9:
                hard = 9
            if hard < 1:
                hard = 1    
            ud = ud * 4
            own['bbut_timer'] = 0
            if STANCE == True:
                own['requestAction'] = 'fak_throw'
                act.linearVelocity = [0.0, ud, hard]
            if STANCE == False:
                own['requestAction'] = 'fak_throw'
                act.linearVelocity = [0.0, ud, -hard]  
            cont.activate(act)
        else:
            own['throw_deck'] = False    
            deckact.visibility = True
            trucksact.visibility = True
            wheel1act.visibility = True
            wheel2act.visibility = True
            wheel3act.visibility = True
            wheel4act.visibility = True
            throw_deck_empty['kill_deck'] = 1     
        cont.activate(deck.actuators['Visibility'])
        cont.activate(trucks.actuators['Visibility'])
        cont.activate(wheel1.actuators['Visibility'])
        cont.activate(wheel2.actuators['Visibility'])
        cont.activate(wheel3.actuators['Visibility'])
        cont.activate(wheel4.actuators['Visibility'])            
    def throwdeck_trigger():
        lastb = own['lastb']
        throw_deck_empty = scene.objects["throw_deck_empty"]
        if bBut == True:
            own['bbut_timer'] += 1
            ud = (rUD * 10) +1
        if bBut == False:
            throw_deck_empty['kill_deck'] = 0
        if bBut == False and own['lastb'] == True:        
            strength = own['bbut_timer']
            ud = (rUD * 10) +1
            throwdeck(strength, ud)   
            
    def focus_deck():
        since_air = own['framenum'] - own['lF_air_frame']
        if cb_td.positive and since_air < 10:
            object = 'focus_deckA'
            object2 = 'focus_deckB'            
            other = throw_deck_empty
            throw_deck = scene.objects["throw_deck"]
            throw_deck.endObject()
            scene.addObject(object, other, 0)          
            scene.addObject(object2, other, 0)
                    
        if own['throw_deck'] == True:
            if dict['ldPad'] == False and dict['last_ldPad'] == True: 
                object = 'focus_deckA'
                object2 = 'focus_deckB'            
                other = throw_deck_empty
                scene.addObject(object, other, 0)          
                scene.addObject(object2, other, 0)          
                  
    def fall():
        if own['fall'] == True:
            falldeck()        
            if STANCE == 1:
                own['requestAction'] = 'fak_air-walk_air'            
                #own.setLinearVelocity([3,2,0], True)
            else:
                own['requestAction'] = 'reg_air-walk_air'
                #own.setLinearVelocity([-3,-2,0], True)    
            own['fall'] = False
            own.worldPosition.z += .3
            print('falling from walk.py')

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

        if aBut == True and lasta == False:
            try:
                if 'sit' in r_ground.hitObject:
                    #print("sit")
                    own['sit'] = 1
                    killact(3)
                    if STANCE == 0:
                        own['requestAction'] = 'reg_sit'
                    elif STANCE == 1:
                        own['requestAction'] = 'fak_sit'                                        
            except:
                pass    
        if own['sit'] == 1:
            try:
                killact(3)
                sit_vect = r_ground.hitObject.getAxisVect( [0, 1, 0])
                if STANCE == 0:
                    own.alignAxisToVect(-sit_vect, 0, .2)
                    own['requestAction'] = 'reg_sit'                               
                    
                elif STANCE == 1:
                    own['requestAction'] = 'fak_sit'
                    own.alignAxisToVect(sit_vect, 0, .2)                    
            except:
                pass    
                          
    def switchcam():
        if ltsBut == False and own['lastlts'] == True and rtsBut == False:
            if own['camera'] == 1:
                own['camera'] = 0
            else:
                own['camera'] = 1
        if rtsBut == False and own['lastrts'] == True and ltsBut == False:
            if own['camera'] == 2:
                own['camera'] = 0
            else:
                own['camera'] = 2 
    #followcam 
    def move_followcam():
        if own['camera'] == 2:
            if own['lastbkBut'] == True and bkBut == False:
                #print("activate move followcam") 
                if own['move_followcam'] == False:
                    own['move_followcam'] = True
                else:
                    own['move_followcam'] = False                       
            if own['move_followcam'] == True:
                camspeed1 = .015
                camspeed2 = .055
                camrot1 = .005
                camrot2 = .02
                #up
                if lUD < -0.080:
                    followcam.actuators["up"].dLoc = [ 0, 0, -camspeed2]
                    cont.activate(followcam.actuators["up"])
                    #print("fastup")
                else:
                    cont.deactivate(followcam.actuators["up"])    
    #            #down    
                if lUD > .080:
                    followcam.actuators["down"].dLoc = [ 0, 0, camspeed2]
                    cont.activate(followcam.actuators["down"])
                else:
                    cont.deactivate(followcam.actuators["down"])                    
    #            #left
                #if lLR < -0.080:
                if lLR > 0.080:    
                    followcam.actuators["left"].dLoc = [-camspeed2, 0, 0]                
                    cont.activate(followcam.actuators["left"])
                else:
                    cont.deactivate(followcam.actuators["left"])                    
    #            #right
                #if lLR > 0.080: 
                if lLR < -0.080:         
                    followcam.actuators["right"].dLoc = [camspeed2, 0, 0]                
                    cont.activate(followcam.actuators["right"])
                else:
                    cont.deactivate(followcam.actuators["right"])  
                #up
                if rUD < -0.080:
                    followcam.actuators["rotup"].dLoc = [0, 0, camrot2]
                    cont.activate(followcam.actuators["rotup"])
                else:
                    cont.deactivate(followcam.actuators["rotup"])    
    #            #down    
                if rUD > .080:
                    followcam.actuators["rotdown"].dLoc = [0, 0, -camrot2]                
                    cont.activate(followcam.actuators["rotdown"])
                else:
                    cont.deactivate(followcam.actuators["rotdown"])                    
    #            #left
                if rLR < -0.080:
                    followcam.actuators["rotleft"].dRot = [0, 0, camrot2]                
                    cont.activate(followcam.actuators["rotleft"])
                else:
                    cont.deactivate(followcam.actuators["rotleft"])                    
    #            #right
                if rLR > 0.080:         
                    followcam.actuators["rotright"].dRot = [0, 0, -camrot2]
                    cont.activate(followcam.actuators["rotright"])
                else:
                    cont.deactivate(followcam.actuators["rotright"]) 

    #*********************************************                
                    
                if lUD > -0.080 and lUD < -0.030:
                    followcam.actuators["up"].dLoc = [ 0, 0, -camspeed1]
                    cont.activate(followcam.actuators["up"])
                else:
                    cont.deactivate(followcam.actuators["up"])    
    #            #down    
                if lUD < .080 and lUD > .03:
                    followcam.actuators["down"].dLoc = [ 0, 0, camspeed1]                
                    cont.activate(followcam.actuators["down"])
                else:
                    cont.deactivate(followcam.actuators["down"])                    
    #            #left
                if lLR > -0.080 and lLR < -0.030:
                    followcam.actuators["left"].dLoc = [-camspeed1, 0, 0]                
                    cont.activate(followcam.actuators["left"])
                else:
                    cont.deactivate(followcam.actuators["left"])                    
    #            #right
                if lLR < .080 and lLR > .03:       
                    followcam.actuators["right"].dLoc = [camspeed1, 0, 0]
                    cont.activate(followcam.actuators["right"])
                else:
                    cont.deactivate(followcam.actuators["right"])  
                #up
                if rUD > -0.080 and rUD < -0.030:
                    followcam.actuators["rotup"].dRot = [camrot1, 0, 0]                
                    cont.activate(followcam.actuators["rotup"])
                else:
                    cont.deactivate(followcam.actuators["rotup"])    
    #            #down    
                if rUD < .080 and rUD > .03:
                    followcam.actuators["rotdown"].dRot = [-camrot1, 0, 0]                
                    cont.activate(followcam.actuators["rotdown"])
                else:
                    cont.deactivate(followcam.actuators["rotdown"])                    
    #            #left
                if rLR > -0.080 and rLR < -0.030:
                    followcam.actuators["rotleft"].dRot = [0, 0, camrot1]
                    cont.activate(followcam.actuators["rotleft"])
                else:
                    cont.deactivate(followcam.actuators["rotleft"])                    
    #            #right
                if rLR < .080 and rLR > .03:         
                    followcam.actuators["rotright"].dRot = [0, 0, -camrot1]
                    cont.activate(followcam.actuators["rotright"])
                else:
                    cont.deactivate(followcam.actuators["rotright"])                       
    def move_flycam():
        if own['camera'] == 1:
            if own['lastbkBut'] == True and bkBut == False: 
                if own['move_freecam'] == False:
                    own['move_freecam'] = True
                else:
                    own['move_freecam'] = False                       
            if own['move_freecam'] == True:
                camspeed1 = .015
                camspeed2 = .055
                camrot1 = .005
                camrot2 = .02
                #up
                if lUD < -0.080:
                    freecam.actuators["up"].dLoc = [ 0, 0, -camspeed2]
                    cont.activate(freecam.actuators["up"])
                else:
                    cont.deactivate(freecam.actuators["up"])    
    #            #down    
                if lUD > .080:
                    freecam.actuators["down"].dLoc = [ 0, 0, camspeed2]
                    cont.activate(freecam.actuators["down"])
                else:
                    cont.deactivate(freecam.actuators["down"])                    
    #            #left
                if lLR < -0.080:
                    freecam.actuators["left"].dLoc = [-camspeed2, 0, 0]                
                    cont.activate(freecam.actuators["left"])
                else:
                    cont.deactivate(freecam.actuators["left"])                    
    #            #right
                if lLR > 0.080:         
                    freecam.actuators["right"].dLoc = [camspeed2, 0, 0]                
                    cont.activate(freecam.actuators["right"])
                else:
                    cont.deactivate(freecam.actuators["right"])  
                #up
                if rUD < -0.080:
                    freecam.actuators["rotup"].dRot = [camrot2, 0, 0]
                    cont.activate(freecam.actuators["rotup"])
                else:
                    cont.deactivate(freecam.actuators["rotup"])    
    #            #down    
                if rUD > .080:
                    freecam.actuators["rotdown"].dRot = [-camrot2, 0, 0]                
                    cont.activate(freecam.actuators["rotdown"])
                else:
                    cont.deactivate(freecam.actuators["rotdown"])                    
    #            #left
                if rLR < -0.080:
                    freecam.actuators["rotleft"].dRot = [0, 0, camrot2]                
                    cont.activate(freecam.actuators["rotleft"])
                else:
                    cont.deactivate(freecam.actuators["rotleft"])                    
    #            #right
                if rLR > 0.080:         
                    freecam.actuators["rotright"].dRot = [0, 0, -camrot2]
                    cont.activate(freecam.actuators["rotright"])
                else:
                    cont.deactivate(freecam.actuators["rotright"]) 

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

    #walking on stairs
    if r_ground.triggered:
        try:
            if 'stair' in r_ground.hitObject:
                own['stair_counter'] = 20
                
        except:
            pass        
        if own['stair_counter'] > 0:
            own.linearVelocity.z += .1
            own['stair_counter'] -= 1     

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



    if own['stair_counter'] > 5 and r_ground.triggered == False:
        own.applyForce([0,0,-200], True)                          
       
    if deck.visible:
        own['deckvis'] = 1
    else:
        own['deckvis'] = 0       

    if own['requestAction'] == 'empty' or own['requestAction'] == None:
        if STANCE == 0:
            own['requestAction'] = 'reg_idle1'
        if STANCE == 1:
            own['requestAction'] = 'fak_idle1'        
        
    def onground():
        if r_ground.positive:
            own['lF_ground_frame'] = own['framenum']
            if 'grind' in r_ground.hitObject:
                if own['framenum'] - own['last_fall_frame'] < 90:
                    #own.applyForce([0,100,0], True)
                    pass
                    #print('moving away from rail')
                    
            yvel = own.linearVelocity.y
            yvel = yvel *.1
            if own.linearVelocity.y > .01 or own.linearVelocity.y < -.01 and own['stair_counter'] == 0:
                if STANCE == 0:
                    own.applyRotation([0,0,-yvel], True) 
                else:
                    own.applyRotation([0,0,yvel], True) 
            else:
                own.linearVelocity.y = 0                           

        else:
            #print('in air')            
            if  own['framenum'] - own['lF_ground_frame'] > 10:
                if STANCE == 0:            
                    own['requestAction'] = 'reg_walk_air'
                else:
                    own['requestAction'] = 'fak_walk_air' 
        #if control bottom is touching ground object, turn ground on            
        if cb.positive:
            if own['framenum'] - own['last_fall_frame'] < 90:
                own['lF_ground_frame'] = own['framenum']
                
                

    def get_in_car():
        vehicleNear = cont.sensors["vehicleNear"]
        #print('vh', vehicleNear.positive)
        scene = bge.logic.getCurrentScene()
        cam = scene.active_camera
        #dict = bge.logic.globalDict 
        if vehicleNear.positive and 'car' in vehicleNear.hitObject:
            obj = vehicleNear.hitObject
            if yBut == True:
                obj['driving'] = True
                own['driving'] = True
                cube.suspendDynamics(True)
                cube.worldPosition = obj.worldPosition
                cube.worldOrientation = obj.worldOrientation
                rot = [ 0.0, 0.0, 1.570796327]
                cube.applyRotation(rot,False)            
                compound = False

                # child is solid
                ghost = True

                # set parent
                cube.setParent( obj, compound, ghost)            
                
                

                #cam.target = obj
                #cam.state = 2
                cont.actuators['Camera'].object = obj
                cont.actuators['Camera'].height = 3
                cont.actuators['Camera'].min = 6
                cont.actuators['Camera'].max = 10
                own.state = 2
            #print('near car')
            
        if dict['last_driving'] == True:
            cont.actuators['Camera'].object = scene.objects['camCube']    
            cont.activate(cont.actuators['walk'])               
        if own['driving'] == False:  
            #cont.actuators['Camera'].object = scene.objects['camCube'] 
            #cont.activate(cont.actuators['walk']) 
            dict['last_driving'] = False
            
    def get_on_bike(dict, own):
        #bikeCol = cont.sensors['bikeCol']
        vehicleNear = cont.sensors["vehicleNear"]
        #print('vh', vehicleNear.positive)
        scene = bge.logic.getCurrentScene()
        #cam = scene.active_camera
        #dict = bge.logic.globalDict 
        try:
            if vehicleNear.positive and 'bike' in vehicleNear.hitObject:          
                if yBut == True and dict['last_yBut'] == False and own['throw_deck'] == True:
                    vehicleNear.hitObject.endObject()
                    dict['bike'] = True 
                    cont.activate(own.actuators['bike_state']) 

                    object = "player_bike"
                    # instantly add bullet
                    newbike = scene.addObject(object, own, 0)
                    #bike.localScale = 4.6            
                    newbike.setParent(cube, False, False)
                    #rot = [ 0.0, 0.0, 1.570796327]
                    #bike.applyRotation(rot,False) 
        except:
            pass            
                                                  
    if dict['driving_reset'] == True:
        scene.resume()
        cube.suspendDynamics(False)
        cont.actuators['Camera'].object = camobj2
        cont.activate(own.actuators['walk'])
        #dict['driving_reset'] = False
        #print('reseting driving')   
    if own['walk_jump_timer'] != 0:
        own['walk_jump_timer'] = own['walk_jump_timer'] - 1    
    wts = own['walk_targ_speed'] +1                 
    if own['requestAction'] == 'reg_walkFast' and own.linearVelocity.x > (wts * -1):
        own['requestAction'] = 'reg_walk' 
    if own['requestAction'] == 'fak_walkFast' and own.linearVelocity.x < wts:
        own['requestAction'] = 'fak_walk' 
    if own['requestAction'] == 'reg_walkFast_nb' and own.linearVelocity.x > (wts * -1):
        own['requestAction'] = 'reg_walk_nb' 
    if own['requestAction'] == 'fak_walkFast_nb' and own.linearVelocity.x < wts:
        own['requestAction'] = 'fak_walk_nb'   


    if r_ground.triggered:
        #force2 = [0.0, 0, dict['antibounce']]
        #own.applyForce(force2, True)

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

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

    nextframe()
    checkidle()
    getonboard(dict, cont)
    reset_pos()
    switchcam()
    move_flycam()
    move_followcam()
    fall()
    idle_anim()
    sit()
    onground()
    focus_deck()
    get_in_car()
    get_on_bike(dict, own)

    #printplaying() 

    own.alignAxisToVect([0.0,0.0,1.0], 2, .03)
    own.actuators["sroll"].stopSound() 
    wheel1 = scene.objects["wheel1"]
    wheel2 = scene.objects["wheel2"]
    wheel3 = scene.objects["wheel3"]
    wheel4 = scene.objects["wheel4"]
    wheel1.stopAction(2)
    wheel2.stopAction(2)
    wheel3.stopAction(2)
    wheel4.stopAction(2)
    own['lasty'] = yBut
    own['lastb'] = bBut  
    own['lasta'] = aBut
    own['lastx'] = xBut   
    own['lastlts'] = ltsBut
    own['lastrts'] = rtsBut        
    own['lastbkBut'] = bkBut
    own['dropinCol'] = dropinCol
    own['walk'] = 1
    dict['walk'] = 1