grabs

controller2.py

         trigger = r_ground.triggered
         STANCE = own["stance"]
         wallride = own["wallride"]
+        dict['trick_string'] = 'Ollie'
         if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
             own["wallride_off"] = 1
             own['requestAction'] = 'reg_ollie'
 
     def kickflip():
         print("kickflip")
-        dict['trick_string'] = 'Kickflip'
+        
         STANCE = own["stance"]
         print(flip_start_lay)
         if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
             own["wallride_off"] = 1
             own['requestAction'] = 'reg_kickflip'       
             jump()
+            dict['trick_string'] = 'Kickflip'
         elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
             own["wallride_off"] = 1
-            own['requestAction'] = 'fak_kickflip'       
+            own['requestAction'] = 'fak_heelflip'       
             jump()
             if own["wallride"] !=1: jump()
+            dict['trick_string'] = 'Heelflip'
         if r_ground.triggered == 0 and STANCE == False:
             own["wallride_off"] = 1
             own['requestAction'] = 'reg_kickflip'
             if own["wallride"] != None: 
                 jump()  
+            dict['trick_string'] = 'Kickflip'
         elif r_ground.triggered == 0 and STANCE == True:
             own["wallride_off"] = 1
-            own['requestAction'] = 'fak_kickflip'
+            own['requestAction'] = 'fak_heelflip'
             if own["wallride"] != None: 
                 jump()
+            dict['trick_string'] = 'Heelflip'    
 
     def inward_heelflip():
         print("inward heelflip")
         
     def heelflip():
         print("heelflip")
-        dict['trick_string'] = 'Heelflip'
+        
         STANCE = own["stance"]
         if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
             own["wallride_off"] = 1
             own['requestAction'] = 'reg_heelflip'
             jump()
+            dict['trick_string'] = 'Heelflip'
         elif (r_ground.triggered == 1 and STANCE == True) or ((grindHit == True or wallride != None) and STANCE == True):
             own["wallride_off"] = 1
-            own['requestAction'] = 'fak_heelflip'
+            own['requestAction'] = 'fak_kickflip'
             jump()
+            dict['trick_string'] = 'Kickflip'
         if r_ground.triggered == 0 and STANCE == False:
             own["wallride_off"] = 1
         elif r_ground.triggered == 0 and STANCE == True:
 
     def shuvit():
         print("shuvit")
-        dict['trick_string'] = 'shuvit'
+        dict['trick_string'] = 'Shuvit'
         STANCE = own["stance"]
         if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
             own["wallride_off"] = 1
 
     def shuvit360():
         print("360shuvit")
-        dict['trick_string'] = '360 shuvit'
+        dict['trick_string'] = '360 Shuvit'
         STANCE = own["stance"]
         if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
             own["wallride_off"] = 1
 
     def fsshuvit360():
         print("360shuvit")
-        dict['trick_string'] = '360 shuvit'
+        dict['trick_string'] = 'FS 360 Shuvit'
         STANCE = own["stance"]
         if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
             own["wallride_off"] = 1
 
     def nollie_shuvit():
         print("shuvit")
-        dict['trick_string'] = 'Nollie shuvit'
+        dict['trick_string'] = 'Nollie Shuvit'
         STANCE = own["stance"]
         if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
             own["wallride_off"] = 1
                 jump()        
 
     def fsshuvit():
-        dict['trick_string'] = 'Frontside shuvit'
+        dict['trick_string'] = 'FS Shuvit'
         if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
             own["wallride_off"] = 1
             own['requestAction'] = 'reg_fsshuvit'
                 jump()
             
     def nollie_fsshuvit():
-        dict['trick_string'] = 'Nollie Frontside shuvit'
+        dict['trick_string'] = 'Nollie FS Shuvit'
         if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
             own["wallride_off"] = 1
             own['requestAction'] = 'reg_nollie_fsshuvit'
      
     #nollie_shuvit360()
     def nollie_shuvit360():
-        dict['trick_string'] = 'Nollie Frontside shuvit 360'
+        dict['trick_string'] = 'Nollie FS Shuvit 360'
         if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
             own["wallride_off"] = 1
             own['requestAction'] = 'reg_nollie_shuvit360'
 
     #nollie_fsshuvit360()
     def nollie_fsshuvit360():
-        dict['trick_string'] = 'Nollie Frontside shuvit 360'
+        dict['trick_string'] = 'Nollie FS Shuvit 360'
         if (r_ground.triggered == 1 and STANCE == False) or ((grindHit == True or wallride != None) and STANCE == False):
             own["wallride_off"] = 1
             own['requestAction'] = 'reg_nollie_fsshuvit_360'
             own["wallride_off"] = 1
             if own["wallride"] != None: 
                 jump()             
-        
+#-------
+    def reg_frigid_grab_on():
+        GRAB_PLAYED = own["GRAB_PLAYED"]
+        GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'Frigid'
+        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
+            own['requestAction'] = 'reg_frigid'
+            grablay2 = grablay + 1
+            GRAB_PLAYED = True
+            own["GRAB_PLAYED)"] = GRAB_PLAYED
+    def reg_fsonefoot_grab_on():
+        GRAB_PLAYED = own["GRAB_PLAYED"]
+        GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'FS One Foot'
+        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
+            own['requestAction'] = 'reg_fsonefoot'
+            grablay2 = grablay + 1
+            GRAB_PLAYED = True
+            own["GRAB_PLAYED)"] = GRAB_PLAYED
+    def reg_onefoot_grab_on():
+        GRAB_PLAYED = own["GRAB_PLAYED"]
+        GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'One Foot'
+        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
+            own['requestAction'] = 'reg_onefoot'
+            grablay2 = grablay + 1
+            GRAB_PLAYED = True
+            own["GRAB_PLAYED)"] = GRAB_PLAYED
+
+    def fak_frigid_grab_on():
+        GRAB_PLAYED = own["GRAB_PLAYED"]
+        GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'Frigid'
+        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
+            own['requestAction'] = 'fak_frigid'
+            grablay2 = grablay + 1
+            GRAB_PLAYED = True
+            own["GRAB_PLAYED)"] = GRAB_PLAYED
+    def fak_fsonefoot_grab_on():
+        GRAB_PLAYED = own["GRAB_PLAYED"]
+        GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'FS One Foot'
+        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
+            own['requestAction'] = 'fak_fsonefoot'
+            grablay2 = grablay + 1
+            GRAB_PLAYED = True
+            own["GRAB_PLAYED)"] = GRAB_PLAYED
+    def fak_onefoot_grab_on():
+        GRAB_PLAYED = own["GRAB_PLAYED"]
+        GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'One Foot'
+        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
+            own['requestAction'] = 'fak_onefoot'
+            grablay2 = grablay + 1
+            GRAB_PLAYED = True
+            own["GRAB_PLAYED)"] = GRAB_PLAYED
+
+#----        
     def reg_judo_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
-        dict['trick_string'] = 'Judo Grab'
+        dict['trick_string'] = 'Judo'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
             own['requestAction'] = 'reg_judo'
             grablay2 = grablay + 1
     def fak_judo_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
-        dict['trick_string'] = 'Fak Judo Grab'
+        dict['trick_string'] = 'Judo'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
             own['requestAction'] = 'fak_judo'
             grablay2 = grablay + 1
     def frontside_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
-        dict['trick_string'] = 'Mute Grab'
+        dict['trick_string'] = 'Mute'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
             own['requestAction'] = 'frontside_grab'
             #skater.playAction("reg_fg", 10,30, layer=400, priority=5, play_mode=1, speed=.5)
     def backside_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'Backside'
         if GRAB_ON == True and r_ground.triggered == 0 and aBut == True:
             own['requestAction'] = 'reg_fp_rback'          
         elif GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:
     def fakfrontside_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'Mute'
         if GRAB_ON == True and r_ground.triggered == 0 and aBut == True:
             own['requestAction'] = 'fak_fp_rback'         
         
     def fakbackside_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'Backside'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
             own['requestAction'] = 'fak_backside_grab' 
             GRAB_PLAYED = True
     def frontside_nose_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'FS Nose'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:
             own['requestAction'] = 'frontside_nose_grab' 
             GRAB_PLAYED = True
     def frontside_tail_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'FS Tail'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0: 
             own['requestAction'] = 'frontside_tail_grab' 
             GRAB_PLAYED = True
     def backside_nose_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
-        #airwalk
-        if GRAB_ON == True and r_ground.triggered == 0 and (aBut == True):    
-            print("airwalk")
-            skater.playAction("reg_airwalk", 10,30, layer=405, priority=5, blendin=5, play_mode=1, speed=.5)
-            deck.playAction("a_reg_airwalk", 10,30, layer=405, priority=5, blendin=5, play_mode=1, speed=.5)
-            trucks.playAction("a_reg_airwalk", 10,30, layer=405, priority=5, blendin=5, play_mode=1, speed=.5)
-        
-        #norm
-        elif GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:   
+        dict['trick_string'] = 'BS Nose'
+        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:   
             own['requestAction'] = 'backside_nose_grab' 
             GRAB_PLAYED = True
             own["GRAB_PLAYED)"] = GRAB_PLAYED 
     def backside_tail_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'BS Tail'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0: 
             own['requestAction'] = 'backside_tail_grab' 
             GRAB_PLAYED = True
             own["GRAB_PLAYED)"] = GRAB_PLAYED
+            
+    def reg_airwalk():
+        GRAB_PLAYED = own["GRAB_PLAYED"]
+        GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'Airwalk'
+        if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0: 
+            own['requestAction'] = 'reg_airwalk' 
+            GRAB_PLAYED = True
+            own["GRAB_PLAYED)"] = GRAB_PLAYED            
+            
     #switch    
     def fak_frontside_nose_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'FS Nose'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:  
             own['requestAction'] = 'fak_frontside_nose_grab' 
             GRAB_PLAYED = True
     def fak_frontside_tail_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'FS Tail'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:           
             own['requestAction'] = 'fak_frontside_tail_grab' 
             GRAB_PLAYED = True
     def fak_backside_nose_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'BS Nose'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:           
             own['requestAction'] = 'fak_backside_nose_grab' 
             GRAB_PLAYED = True
     def fak_backside_tail_grab_on():
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
+        dict['trick_string'] = 'BS Tail'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:           
             own['requestAction'] = 'fak_backside_tail_grab' 
             GRAB_PLAYED = True
                 else:
                     if STANCE == 0:
                         own['requestAction'] = 'reg_5050'
+                        dict['trick_string'] = '5050'
                     if STANCE == 1:
                         own['requestAction'] = 'fak_5050'
+                        dict['trick_string'] = '5050'
                 
             elif STANCE == False:
                 if own['grindType'] == "reg_bsboard":
         own['revert_timer'] = 20 
         cont.activate(own.actuators["revertSound"]) 
         own['revert_sound'] = 1 
+        dict['trick_string'] = 'Revert'
 
     def revert2():
         own["Q3oncdl"] = 0
         own['revert_timer'] = 20 
         cont.activate(own.actuators["revertSound"])   
         own['revert_sound'] = 1 
+        dict['trick_string'] = 'Revert'
 
     def revert3():
         own["Q7oncdl"] = 0
         own['revert_timer'] = 20 
         cont.activate(own.actuators["revertSound"]) 
         own['revert_sound'] = 1  
+        dict['trick_string'] = 'Revert'
 
     def revert4():
         own["Q7oncdl"] = 0
         own['revert_timer'] = 20 
         cont.activate(own.actuators["revertSound"]) 
         own['revert_sound'] = 1      
+        dict['trick_string'] = 'Revert'
 
     def powerslide():
         own['powerslide_counter'] = own['powerslide_counter'] + 1
         GRAB_ON = True
         own["GRAB_ON"] = GRAB_ON
         #print(rTrig, GRAB_ON)
-
-        if STANCE == False and rUD >= -.07 and rUD <= .07:
-            frontside_grab_on()
-        elif STANCE == True and rUD >= -.07 and rUD <= .07:
-            fakbackside_grab_on()
-        #front_nose    
-        if STANCE == True and rUD < -0.070:
-            fak_backside_nose_grab_on()
-        #front_tail    
-        elif STANCE == True and rUD > 0.07:
-            fak_backside_tail_grab_on() 
-        #    
-        if STANCE == False and rUD < -0.070:
-            frontside_nose_grab_on()
-        #front_tail    
-        elif STANCE == False and rUD > 0.07:
-            frontside_tail_grab_on()                
+        if aBut == False and xBut == False:
+            if STANCE == False and rUD >= -.07 and rUD <= .07:
+                frontside_grab_on()
+            elif STANCE == True and rUD >= -.07 and rUD <= .07:
+                fakbackside_grab_on()
+            #front_nose    
+            if STANCE == True and rUD < -0.070:
+                fak_backside_nose_grab_on()
+            #front_tail    
+            elif STANCE == True and rUD > 0.07:
+                fak_backside_tail_grab_on() 
+            #    
+            if STANCE == False and rUD < -0.070:
+                if bBut == True:
+                    reg_airwalk()
+                else:    
+                    frontside_nose_grab_on()
+            #front_tail    
+            elif STANCE == False and rUD > 0.07:
+                frontside_tail_grab_on()     
+        elif aBut == True and xBut == False:
+            if STANCE == False:
+                reg_fsonefoot_grab_on()        
+            else:
+                fak_onefoot_grab_on()
+        elif aBut == False and xBut == True:
+            if STANCE == False:
+                reg_frigid_grab_on()        
+            else:
+                fak_judo_grab_on()                  
+                
+                
+                           
 
     #backside grab
     if lTrig > 0.02 and r_ground.triggered == 0 and flipping == False:    
                 fak_frontside_tail_grab_on() 
             #front_nose    
             if STANCE == False and rUD < -0.070:
-                backside_nose_grab_on()
+                if bBut == True:
+                    reg_airwalk()
+                else:                  
+                    backside_nose_grab_on()
             #front_tail    
             elif STANCE == False and rUD > 0.07:
-                backside_tail_grab_on()  
-        else:
+                backside_tail_grab_on() 
+                
+        elif aBut == True and xBut == False:
             if STANCE == False:
-                reg_judo_grab_on()
-            elif STANCE == True:
-                fak_judo_grab_on()            
+                reg_judo_grab_on()        
+            else:
+                fak_frigid_grab_on()
+        elif aBut == False and xBut == True:
+            if STANCE == False:
+                reg_onefoot_grab_on()        
+            else:
+                fak_frigid_grab_on()                    
+                 
+#        else:
+#            if STANCE == False:
+#                reg_judo_grab_on()
+#            elif STANCE == True:
+#                fak_judo_grab_on()            
                                             
             
     #kill grabs        
         lgf = own['last_grind_frame']
         frame = own['framenum']
         frames_since_grinding = frame - lgf
-        ylimit = .8
-        if ground_since < 15:
+        ylimit = .84
+        #print(ground_since, 'ground_since')
+        if ground_since < 20 and ground_since > 1 and grindHit == 0:
             ylimit = ylimit + ((ground_since - 15) * -.005)
-            if ylimit > .99999:
-                ylimit = .9999
-               
+            
+            yvel = own.linearVelocity.y
+            yvel = yvel *.03
+            if STANCE == 0:
+                yvel *= -1
+            try:    
+                dist = r_ground.hitObject.worldPosition - own.worldPosition
+                #print('ground dist', dist)
+                if own.linearVelocity.y > .01 or own.linearVelocity.y < -.01:
+                    own.applyRotation([0,0,yvel], True)
+                
+                if ylimit > .99999:
+                    ylimit = .9999
+            except:
+                pass       
         else:    
             if r_ground.triggered and touched == False and grindHit == 0 and frames_since_grinding > 20:    
                 linVelocity4 = own.getLinearVelocity(True)
                 newy = linVelocity4.y * ylimit   
                 force = [linVelocity4.x, newy, linVelocity4.z]
                 own.setLinearVelocity(force, True) 
-        print(ylimit, 'ylimit')       
+        #print(ylimit, 'ylimit')       
 
     def getoffboard():
         lasty = own['lasty']

grindV2.py

                 delta = delta.cross(vect)
                 if delta[2] >= 0:
                     grindside = "right"
+
                 else:
                     grindside = "left"
+                edge = 0
+                if 'edge' in obj:
+                    edge = 1    
+                #print('grind on', grindside, edge)
                 if (delta[2] > .00001 or delta[2] < -.00001) and (delta[2] < .8 or delta[2] < -.8):
                     rotation = own.worldOrientation[2] - obj.worldOrientation[2]
                     player_e = own.worldOrientation.to_euler()
         if dist < grind_dist and dropin == 0 and manual == 0 and no_grind == 0 and own['grindoutturn'] == 0 and own['manual'] == 0 and own['gt_cd2'] < 40 and invert_on == False and own['air_mover'] == False and no_grind_pull == 0 and own['last_invert'] == False and own['grindjumpturn'] == 0 and grind_jump == 0 and own['airup'] == 0:
             #print('grind')      
             hitObject, hitPoint, hitNormal = own.rayCast(nearestObject.worldPosition, own.worldPosition, .0, 'grind')
-            if grindold == 0:
+            if grindold == 0:     
                 if grindTouch.triggered:
                     nearpos = nearestObject.worldPosition
                     if hitNormal != None:
-                        stre = .05
+                        stre = .45
                         own.alignAxisToVect(hitNormal, 2, stre) 
                         #print("align")                   
                     own.worldPosition = [nearpos.x, nearpos.y, nearpos.z + .2975]
                     if grindTouch.triggered:
                         nearpos = nearestObject.worldPosition
                         if hitNormal != None:
-                            stre = .05
+                            stre = .15
                             own.alignAxisToVect(hitNormal, 2, stre) 
                             #print("align")                   
-                        own.worldPosition = [nearpos.x, nearpos.y, nearpos.z + .2975]
+                        #own.worldPosition = [nearpos.x, nearpos.y, nearpos.z + .2975]
                         print('new moving world')                    
 
     else:

scene_init.py

     own['driving'] = False
     dict['last_driving'] = False
     own['last_roty'] = 0.0
+    
+    own['walk_targ_speed'] = 2
+    own['walk_fast_targ_speed'] = 5
+    own['walk_speed'] = 0
+    own['walk_inc'] = .05
+    own['walk_jump_timer'] = 0
        
 main()

walk.py

 
 #if skater.isPlayingAction(460):  
 #    noidle = 1  
+walk_inc = own['walk_inc'] 
+if own['stair_counter'] != 0:
+    walk_inc = own['walk_inc']  *10
 
 if own["stance"] == None:
     own["stance"] = True
     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)            
+    own['lF_air_frame'] = own['framenum']  
+
+
     
 #walking
 
 if own['walk_timer'] < 50:
     velx = vel.x * .95             
     own.setLinearVelocity([velx, 0, vel.z], True)
+    #print('y is zero')
 else:
-    own.setLinearVelocity([0, 0, vel.z], True)
+    pass
+    #own.setLinearVelocity([0, 0, vel.z], True)
     
 wf = 1
 if own['last_walk_frame'] - own['last_roll_frame'] > 55:
     walking = None
    
 if walking == "regular":
-    cont.deactivate(own.actuators['forward2']) 
-    cont.deactivate(own.actuators['backward2'])    
-    if stance == 0:
-        cont.activate(own.actuators['forward'])
+    #if linvel.x < own['walk_targ_speed']:
+    #cont.deactivate(own.actuators['forward2']) 
+    #cont.deactivate(own.actuators['backward2'])    
+    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']    
+        #cont.activate(own.actuators['forward'])
     else:
-        cont.activate(own.actuators['backward'])
+        if linvel.x > -own['walk_targ_speed']:
+            own.linearVelocity.x = linvel.x - walk_inc       
+        else:
+            own.linearVelocity.x = -own['walk_targ_speed']                
+        #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'])
+    #cont.deactivate(own.actuators['forward']) 
+    #cont.deactivate(own.actuators['backward'])    
+    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:
-        cont.activate(own.actuators['backward2'])                 
+        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:
-    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:
+if walking == None and r_ground.positive and own['walk_jump_timer'] == 0:
+    #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 and turning == False:
         velx = vel.x * .95             
         own.setLinearVelocity([velx, 0, vel.z], True)
+        #print('minusvel', velx)
     else:
-        own.setLinearVelocity([0, 0, vel.z], True) 
+        #pass
+        print('minusvel')
+        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:
+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"])
         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:
+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'
     vel = own.getLinearVelocity(True)
     cont.deactivate(own.actuators["walkondirt"])       
 
-#turning
-if lRight == 1 or dict['kb_ra'] == 2:
-    cont.activate(own.actuators['right'])
-else:
-    cont.deactivate(own.actuators['right'])    
-    
-if lLeft == 1 or dict['kb_la'] == 2:
-    cont.activate(own.actuators['left'])    
-else:
-    cont.deactivate(own.actuators['left'])        
-
-#in air        
-if (lup == 1 or dict['kb_ua'] != 0) and r_ground.positive == False:
-    if stance == 0:
-        cont.deactivate(own.actuators['forward'])
-        cont.deactivate(own.actuators['forward2'])
-        killact(4)
-        killact(5)
-        killact(6)
-        killact(7)        
-        velx = linvel.x - 1
-        own.setLinearVelocity([-1.5, linvel.y, linvel.z], 1)
-    if stance == 1:    
-        cont.deactivate(own.actuators['backward'])
-        cont.deactivate(own.actuators['backward2'])
-        killact(4)
-        killact(5)
-        killact(6)
-        killact(7)        
-        velx = linvel.x + 1
-        own.setLinearVelocity([1.5, linvel.y, linvel.z], 1)  
-    own['lF_air_frame'] = own['framenum']         
+       
 #---------------
 if rLR > .05:
     cont.activate(camobj.actuators['camRight'])
         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)      
+            #killact(3)
+            #killact(4)
+            #killact(5)
+            #killact(6)
+            #killact(7)      
             if STANCE == 0:  
                 own['requestAction'] ='reg_jump'  
                 print('jump') 
             local = False
             # apply force -- limit jump speed
             if linvel.z < 10:
-                own.applyForce(force, local)
+                #own.applyForce(force, local)
+                own.linearVelocity.z += 5
+                own.linearVelocity.x = linvel.x
+                own.linearVelocity.y = linvel.y
+                own['walk_jump_timer'] = 20
         own['lastx'] = 1
     else:
         own['lastx'] = 0
     try:
         if 'stair' in r_ground.hitObject:
             own['stair_counter'] = 20
+            
     except:
         pass        
     if own['stair_counter'] > 0:
-       own['stair_counter'] -= 1     
+        own.linearVelocity.z += .1
+        own['stair_counter'] -= 1     
 
 if yBut == True:
     own['walk_idling'] = 0
             if own['framenum'] - own['last_fall_frame'] < 90:
                 own.applyForce([0,100,0], True)
                 #print('moving away from rail')
+                
+        yvel = own.linearVelocity.y
+        yvel = yvel *.1
+        if own.linearVelocity.y > .01 or own.linearVelocity.y < -.01 and own['stair_counter'] == 0:
+            if STANCE == 0:
+                own.applyRotation([0,0,-yvel], True) 
+            else:
+                own.applyRotation([0,0,yvel], True) 
+        else:
+            own.linearVelocity.y = 0                           
 
     else:
         #print('in air')            
     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"]
     cont.actuators['Camera'].object = camobj2
     cont.activate(own.actuators['walk'])
     #dict['driving_reset'] = False
-    #print('reseting driving')                
+    #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'                         
 onboard() 
 jump()
 dropin()