controller cleanup2

co_ActionState.py

         queueAction = own['queueAction']
         actionTimer = own['actionTimer']
     except:
-        #print("init")
         own['actionState'] = 'reg_walk'
         own['l_actionState'] = 'empty'        
         own['requestAction'] = 'reg_walk'    
         actionState = 'empty'
         l_actionState = 'empty'
         l_requestAction = 'empty'
-    #print("ra1: ", requestAction) \
     if requestAction == 'empty':
         print("*******empty request****")
         
     isplaying = skater.isPlayingAction(flip_layer)
     transPlaying = skater.isPlayingAction(trans_layer)
-    #if isplaying  == False:    
-        #own['actionTimer'] = 0
         
     if own['clear_request'] == 1:
         requestAction = 'empty'
     if own['actionTimer'] != 0 and transPlaying == False and isplaying == False:
         own['actionTimer'] = 0
         actionTimer = 0
-        #print('reset actionTimer')
-        #pass 
         
     if own['actionTimer'] != 0 and (own['actionState'] == 'reg_land' or own['actionState'] == 'fak_land') and own['requestAction'] not in reg_fliplist and own['requestAction'] not in fak_fliplist:
-#        requestAction = own['l_actionState'] 
         requestAction = 'empty'
         own['requestAction'] = 'empty'              
 #================
         requestAction = 'reg-fak_roll'
         own['requestAction'] = 'reg-fak_roll'
     
-    
-    
     if requestAction == 'reg_5050' and (l_actionState == 'fak_5050' or l_actionState == 'fak_air' or l_actionState in fak_fliplist) or (l_actionState == 'fak-reg_5050' and actionTimer > 1):
         print("fak-reg_5050")
         requestAction = 'fak-reg_5050'
     if (requestAction == 'reg_land' or requestAction == 'fak_land') and own['grindHit'] == True:
         if l_requestAction == 'reg_land' or l_requestAction == 'fak_land':
             pass
-            #print("landing action incorrect")
-        else: 
-            #print("using old requestAction")   
+        else:    
             requestAction = l_requestAction
             own['requestAction'] = requestAction
             own['l_actionState'] = requestAction
             actionState = requestAction
             own['actionTimer'] = 0
-            actionTimer = 0 
-    #if (own['l_requestAction'] == 'reg_air_nose' or own['l_requestAction'] == 'reg_air_tail' or own['l_requestAction'] == 'fak_air_nose' or own['l_requestAction'] == 'fak_air_tail') and ((requestAction == 'reg_land' or requestAction == 'fak_land') or (own['requestAction'] == 'reg_roll' or own['requestAction'] == 'fak_roll')):            
+            actionTimer = 0            
     if (own['l_requestAction'] == 'reg_air_nose' or own['l_requestAction'] == 'reg_air_tail' or own['l_requestAction'] == 'fak_air_nose' or own['l_requestAction'] == 'fak_air_tail') and (requestAction == 'reg_land' or requestAction == 'fak_land') and own['manual_v2_timer'] > 2:
         requestAction = own['l_requestAction']
         print("changing land")
     if l_actionState == 'fak_air_nose' and requestAction == 'fak_roll':
         requestAction = 'fak_air_nose'                
         
-        
     #dirt invert fix
     if 'invert' in requestAction:
         actionTimer = 0
             own['actionTimer'] = 0    
     #revert override
     if requestAction == 'revert1' or requestAction == 'revert2' or requestAction == 'revert3' or requestAction == 'revert4':
-        #print("@@@revert override")
         actionState = requestAction
         own['actionState'] = requestAction 
         if l_requestAction != 'revert1' and l_requestAction != 'revert2' and l_requestAction != 'revert3' and l_requestAction != 'revert4':   
             trucks.stopAction(trans_layer)
             deck.stopAction(trans_layer)                 
             
-    #check last actionState to see if an out action is needed
-    
+    #check last actionState to see if an out action is needed    
     if requestAction not in jump_overrideList:
         if l_actionState == 'reg_turnRight' and requestAction != 'reg_turnRight':
             requestAction = 'reg_turnRight_out'
             requestAction = 'fak_nopos_out'
             actionState = 'fak_nopos_out' 
             
-#        if l_actionState == 'reg_pump_out_hold' and requestAction != 'reg_pump' and requestAction not in pump_out_overList:
-#            requestAction = 'reg_pump_out'
-#            actionState = 'reg_pump_out' 
-            
-            
         if l_actionState == 'reg_pump' and requestAction != 'reg_pump' and requestAction not in pump_out_overList:
             requestAction = 'reg_pump_out'
             actionState = 'reg_pump_out' 
             
-            
-                        
-#        if l_actionState == 'fak_pump_out_hold' and requestAction != 'fak_pump' and requestAction not in pump_out_overList:
-#            requestAction = 'fak_pump_out'
-#            actionState = 'fak_pump_out'
-            
         if l_actionState == 'fak_pump' and requestAction != 'fak_pump' and requestAction not in pump_out_overList:
             requestAction = 'fak_pump_out'
             actionState = 'fak_pump_out'            
             
-            
         if l_actionState == 'reg_powerslide' and requestAction != 'reg_powerslide':
             requestAction = 'reg_powerslide_out'
             actionState = 'reg_powerslide_out' 
             actionState = 'fak_5050-roll' 
             print('************************')                                                                                                                  
     else:
-        print("action over ridden")
-        #own['actionState'] = requestAction                     
+        print("action over ridden")               
     def updateAction(requestAction, actionState):
         try:
             flip_start_frame = own['flip_start_lay']
         except:
             flip_start_frame = 1  
             flipspeed = .6  
-        #flipspeed = own['flipspeed'] 
 ###############################        
         #one shot actions
 ###############################
                 deck.playAction("a_fak_dropin", 60,80, layer=trans_layer, play_mode=0, speed=.75)
                 trucks.playAction("a_fak_dropin", 60,80, layer=trans_layer, play_mode=0, speed=.75)    
 
-
-
             if requestAction == 'reg_turnRight_out':
                 actionState = 'reg_turnRight_out'
                 own['actionTimer'] = 19
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
                     cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2   
                                   
                 if trans_playing and cur_frame > .5:                
                     skater.playAction("nreg_right", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_reg_right", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     trucks.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
-                    #own['actionTimer'] = cur_frame
                     own['actionTimer'] = (10 - cur_frame) *2
                 else:                      
                     skater.playAction("nreg_right", 10,1, layer=trans_layer, play_mode=0, speed=.5)
                 own['actionTimer'] = 19
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)        
                 if trans_playing and cur_frame > .5:                
                     skater.playAction("nreg_left", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_reg_left", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     trucks.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
-                    #own['actionTimer'] = cur_frame
                     own['actionTimer'] = (10 - cur_frame) *2
                 else:                      
                     skater.playAction("nreg_left", 10,1, layer=trans_layer, play_mode=0, speed=.5)
                 own['actionTimer'] = 19
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)          
                 if trans_playing and cur_frame > .5:                
                     skater.playAction("nfak_right", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_fak_right", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     trucks.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
-                    #own['actionTimer'] = cur_frame
                     own['actionTimer'] = (10 - cur_frame) *2
                 else:                      
                     skater.playAction("nfak_right", 10,1, layer=trans_layer, play_mode=0, speed=.5)
                 own['actionTimer'] = 19
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                   
                 if trans_playing and cur_frame > .5:                
                     skater.playAction("nfak_left", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_fak_left", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     trucks.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
-                    #own['actionTimer'] = cur_frame
                     own['actionTimer'] = (10 - cur_frame) *2
                 else:                      
                     skater.playAction("nfak_left", 10,1, layer=trans_layer, play_mode=0, speed=.5)
                 own['actionTimer'] = 19
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    print('opos_out: ', cur_frame)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                
                 if trans_playing and cur_frame > .5:                
                     skater.playAction("noposin", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_reg", 1,40, layer=trans_layer, play_mode=1, speed=.5)
                 own['actionTimer'] = 19
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                 
                 if trans_playing and cur_frame > .5:                
                     skater.playAction("fak_oposin", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_reg", 1,40, layer=trans_layer, play_mode=1, speed=.5)
                 own['actionTimer'] = 19
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                   
                 if trans_playing and cur_frame > .5:                
                     skater.playAction("nnoposin", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_reg", 1,40, layer=trans_layer, play_mode=1, speed=.5)
                 own['actionTimer'] = 19
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                  
                 if trans_playing and cur_frame > .5:                
                     skater.playAction("fak_noposin", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_reg", 1,40, layer=trans_layer, play_mode=1, speed=.5)
                 own['actionTimer'] = 39
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)              
                 if trans_playing and cur_frame > .5:                
                     skater.playAction("nreg_pump_in", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=1, speed=.5)
                 else:                      
                     skater.playAction("nreg_pump_in", 20,1, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_reg", 1,20, layer=trans_layer, play_mode=1, speed=.5)
-                    trucks.playAction("a_reg", 1,20, layer=trans_layer, play_mode=1, speed=.5)
-                    
-#            if requestAction == 'reg_pump_out_hold':
-#                actionState = 'reg_pump_out_hold'
-#                own['actionTimer'] = 19
-#                skater.playAction("nreg_pump_in", 10,10, layer=trans_layer, play_mode=0, speed=.5)
-#                deck.playAction("a_reg", 10,10, layer=trans_layer, play_mode=1, speed=.5)
-#                trucks.playAction("a_reg", 10,10, layer=trans_layer, play_mode=1, speed=.5)                    
+                    trucks.playAction("a_reg", 1,20, layer=trans_layer, play_mode=1, speed=.5)                   
                     
             if requestAction == 'fak_pump_out':
                 actionState = 'fak_pump_out'
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
                     cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                
                 if trans_playing and cur_frame > .5:                
                     skater.playAction("nfak_pump_in", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=1, speed=.5)
                     skater.playAction("nfak_pump_in", 20,1, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_reg", 20,1, layer=trans_layer, play_mode=1, speed=.5)
                     trucks.playAction("a_reg", 20,1, layer=trans_layer, play_mode=1, speed=.5)
-#            if requestAction == 'fak_pump_out_hold':
-#                actionState = 'fak_pump_out_hold'
-#                own['actionTimer'] = 19
-#                skater.playAction("nfak_pump_in", 10,10, layer=trans_layer, play_mode=0, speed=.5)
-#                deck.playAction("a_reg", 10,10, layer=trans_layer, play_mode=1, speed=.5)
-#                trucks.playAction("a_reg", 10,10, layer=trans_layer, play_mode=1, speed=.5)                          
 
             if requestAction == 'reg_stop_out':
                 actionState = 'reg_stop_out'
                 own['actionTimer'] = 30
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)              
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("reg_stopin", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                 own['actionTimer'] = 30
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                   
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("fak_stopin", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_reg", 15,1, layer=trans_layer, play_mode=0, speed=.5)
                     trucks.playAction("a_reg", 15,1, layer=trans_layer, play_mode=0, speed=.5)                           
                     
-
-
             if requestAction == 'reg_tailslide_out':
                 actionState = 'reg_tailslide_out'
                 own['actionTimer'] = 19
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("fak_noses", cur_frame,40, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_fak_noses", cur_frame,40, layer=trans_layer, play_mode=0, speed=.5)
                 own['actionTimer'] = 19
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                  
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("reg_noses", cur_frame,40, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_reg_noses", cur_frame,40, layer=trans_layer, play_mode=0, speed=.5)
                 own['actionTimer'] = 19
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                   
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("fak_tails", cur_frame,40, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_fak_tails", cur_frame,40, layer=trans_layer, play_mode=0, speed=.5)
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
                     cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("reg_tails", cur_frame,40, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_reg_tails", cur_frame,40, layer=trans_layer, play_mode=0, speed=.5)
                 own['actionTimer'] = 5
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                    #cur_frame -= 2                    
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("reg_5050", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                 own['actionTimer'] = 5
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)              
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("fak_5050", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     deck.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                 own['actionTimer'] = 9
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)              
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("reg_noseg.002", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_reg_noseg.002", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                 own['requestAction'] = 'fak_noseg_out'
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)               
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("fak_noseg", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_fak_noseg", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                 own['actionTimer'] = 9
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                 
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("reg_tailg.001", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_reg_tailg.001", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                 own['requestAction'] = 'fak_tailg_out'
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                   
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("fak_tailg", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_fak_tailg", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                 own['requestAction'] = 'fak_nosegr_out'
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)             
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("fak_nosegR", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_fak_nosegR", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                 own['requestAction'] = 'reg_tailgr_out'
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("reg_tailgR", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_reg_tailgR", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                 own['requestAction'] = 'fak_tailgr_out'
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                 
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("fak_tailgR", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_fak_tailgR", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                 own['requestAction'] = 'reg_nosegl_out'
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                    
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("reg_nosegL", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_reg_nosegL", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                 own['requestAction'] = 'fak_nosegl_out'
                 trans_playing = skater.isPlayingAction(trans_layer)
                 if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)
-                    #cur_frame -= 2                    
+                    cur_frame = skater.getActionFrame(trans_layer)                   
                 if trans_playing and cur_frame > 1:                
                     skater.playAction("fak_nosegL", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_fak_nosegL", cur_frame,40, layer=trans_layer, play_mode=0, speed=1)
                 else:                      
                     skater.playAction("fak_tailgL", 30,40, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_fak_tailgL", 30,40, layer=trans_layer, play_mode=0, speed=1)
-                    trucks.playAction("a_fak_tailgL", 30,40, layer=trans_layer, play_mode=0, speed=1)                                         
-                    
+                    trucks.playAction("a_fak_tailgL", 30,40, layer=trans_layer, play_mode=0, speed=1)
                     
             if requestAction == 'reg_manual_out':
                 actionState = 'reg_manual_out'
                 else:                      
                     skater.playAction("fak_nmanual", 10,1, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_reg_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)
-                    trucks.playAction("a_reg_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)                                           
-            
-            
+                    trucks.playAction("a_reg_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)
             
             if requestAction == 'reg-fak_nmanual':
                 own['actionTimer'] = 9
                 own['actionTimer'] = 9 
                 skater.playAction("fak_nmanual", 70,80, layer=trans_layer, play_mode=0, speed=1)
                 deck.playAction("a_reg_manual", 70,80, layer=trans_layer, play_mode=0, speed=1)
-                trucks.playAction("a_reg_manual", 70,80, layer=trans_layer, play_mode=0, speed=1)                                                           
-            
-            
-            
-            
-                    
+                trucks.playAction("a_reg_manual", 70,80, layer=trans_layer, play_mode=0, speed=1)
+
             if requestAction == 'reg_brfoot':
                 actionState = 'reg_brfoot'
                 own['actionTimer'] = 40
                 deck.playAction("a_brfoot", 1, 30, layer=trans_layer, play_mode=0, speed=.75)
                 trucks.playAction("a_brfoot", 1, 30, layer=trans_layer, play_mode=0, speed=.75)                
 
-                                      
-                    
             if requestAction == 'reg_push':
                 own['actionTimer'] = 70
                 skater.playAction("reg_push", 1,35, layer=trans_layer, play_mode=0, speed=.5)
                 own['actionState'] = 'fak_manual_revert_cw'
                 skater.playAction("fak_manual_revert_cw", 70,10, layer=trans_layer, priority=8, play_mode=0, speed=4)
                 deck.playAction("a_fak_manual_revert_cw", 70,10, layer=trans_layer, priority=1, play_mode=0, speed=4)
-                trucks.playAction("a_fak_manual_revert_cw", 70,10, layer=trans_layer, priority=0, play_mode=0, speed=4)                  
+                trucks.playAction("a_fak_manual_revert_cw", 70,10, layer=trans_layer, priority=0, play_mode=0, speed=4)           
                                       
             if requestAction == 'revert1':
                 own['actionTimer'] = 18
                 deck.playAction("a_fak_offboard", 30,1, layer=trans_layer, play_mode=0, speed=1.5)
                 trucks.playAction("a_fak_offboard", 30,1, layer=trans_layer, play_mode=0, speed=1.5)
                 
-                
             if requestAction == 'reg_powerslide_out':
                 actionState = 'reg_powerslide_out'
                 own['actionTimer'] = 40  
                 own['actionTimer'] = 40  
                 skater.playAction("nfak_powerslide", 20,0, layer=trans_layer, play_mode=0, speed=1.5)
                 deck.playAction("a_fak_powerslide_d", 20,0, layer=trans_layer, play_mode=0, speed=1.5)
-                trucks.playAction("a_fak_powerslide_t", 20,0, layer=trans_layer, play_mode=0, speed=1.5)  
-                
+                trucks.playAction("a_fak_powerslide_t", 20,0, layer=trans_layer, play_mode=0, speed=1.5)             
                 
             if requestAction == 'fak-reg_5050':
                 actionState = 'fak-reg_5050'
                 skater.playAction("fak_air", 30,40, layer=trans_layer, play_mode=0, speed=.5)
                 deck.playAction("a_reg", 30,40, layer=trans_layer, play_mode=0, speed=.5)
                 trucks.playAction("a_reg", 30,40, layer=trans_layer, play_mode=0, speed=.5) 
-                
-                
+                     
             if requestAction == 'reg_back_invert_out':
                 own['actionTimer'] = 60
                 actionState = 'reg_back_invert_out'
                 else:                           
                     skater.playAction("nfak_powerslide2", 20,80, layer=loop_layer, play_mode=1, speed=.5)
                     deck.playAction("a_fak_powerslide2_d", 20,80, layer=loop_layer, speed=.5)
-                    trucks.playAction("a_fak_powerslide2_t", 20,80, layer=loop_layer, play_mode=1, speed=.5)                                                            
-
+                    trucks.playAction("a_fak_powerslide2_t", 20,80, layer=loop_layer, play_mode=1, speed=.5)
                     
             #reg_roll    
             if requestAction == 'reg_roll':
                     if flipping == 0:
                         trans_playing = skater.isPlayingAction(trans_layer)
                         if trans_playing:
-                            cur_frame = skater.getActionFrame(trans_layer)
-                            #cur_frame -= 2                    
+                            cur_frame = skater.getActionFrame(trans_layer)                
                         if trans_playing and cur_frame > 1:
-                            #skater.stopAction(trans_layer)
-                            #deck.stopAction(trans_layer)
-                            #trucks.stopAction(trans_layer)
                             skater.playAction("nnoposin", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                             deck.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                             trucks.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                            #print(cur_frame)
                         else: 
                             own['actionTimer'] = 20   
                             skater.playAction("nnoposin", 20,1, layer=trans_layer, play_mode=0, speed=1)
                     trans_playing = skater.isPlayingAction(trans_layer)
                     
                     if trans_playing:
-                        cur_frame = skater.getActionFrame(trans_layer)
-                        #cur_frame -= 2                    
+                        cur_frame = skater.getActionFrame(trans_layer)             
                     if trans_playing and cur_frame > 1:                
                         skater.playAction("nreg_left", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                         deck.playAction("a_reg_left", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                         deck.playAction("a_reg_left", 10,1, layer=trans_layer, play_mode=0, speed=.5)
                         trucks.playAction("a_reg", 10,1, layer=trans_layer, play_mode=0, speed=.5) 
                 if l_actionState == 'reg_Right':
-                    #requestAction = 'reg_turnRight_out'
                     trans_playing = skater.isPlayingAction(trans_layer)
                     if trans_playing:
-                        cur_frame = skater.getActionFrame(trans_layer)
-                        #cur_frame -= 2                    
+                        cur_frame = skater.getActionFrame(trans_layer)                   
                     if trans_playing and cur_frame > 1:                
                         skater.playAction("nreg_right", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                         deck.playAction("a_reg_right", cur_frame,1, layer=trans_layer, play_mode=0, speed=.5)
                     trucks.playAction("a_reg", 1,40, layer=loop_layer, play_mode=1, speed=.5)                           
 
                                                                                                                               
-
             #fak_roll    
             if requestAction == 'fak_roll':
                 if l_actionState == 'fak_pump':
                     trans_playing = skater.isPlayingAction(trans_layer)
                     if trans_playing:
-                        cur_frame = skater.getActionFrame(trans_layer)
-                        #cur_frame -= 2                    
+                        cur_frame = skater.getActionFrame(trans_layer)    
                     if trans_playing and cur_frame > 1:
-                        #skater.stopAction(trans_layer)
-                        #deck.stopAction(trans_layer)
-                        #trucks.stopAction(trans_layer)
                         skater.playAction("nfak_pump_in", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                         deck.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                         trucks.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                        #print(cur_frame)
                     else:    
                         skater.playAction("nfak_pump_in", 20,1, layer=trans_layer, play_mode=0, speed=1)
                         deck.playAction("a_reg", 20,1, layer=trans_layer, play_mode=0, speed=1)
                 if l_actionState == 'fak_opos':
                     trans_playing = skater.isPlayingAction(trans_layer)
                     if trans_playing:
-                        cur_frame = skater.getActionFrame(trans_layer)
-                        #cur_frame -= 2                    
+                        cur_frame = skater.getActionFrame(trans_layer)    
                     if trans_playing and cur_frame > 1:
-                        #skater.stopAction(trans_layer)
-                        #deck.stopAction(trans_layer)
-                        #trucks.stopAction(trans_layer)
                         skater.playAction("fak_oposin", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                         deck.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                         trucks.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                        #print(cur_frame)
+
                     else:
                         own['actionTimer'] = 20    
                         skater.playAction("fak_oposin", 20,1, layer=trans_layer, play_mode=0, speed=1) 
                 if l_actionState == 'fak_nopos':
                     trans_playing = skater.isPlayingAction(trans_layer)
                     if trans_playing:
-                        cur_frame = skater.getActionFrame(trans_layer)
-                        #cur_frame -= 2                    
+                        cur_frame = skater.getActionFrame(trans_layer)    
                     if trans_playing and cur_frame > 1:
-                        #skater.stopAction(trans_layer)
-                        #deck.stopAction(trans_layer)
-                        #trucks.stopAction(trans_layer)
                         skater.playAction("fak_noposin", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                         deck.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
                         trucks.playAction("a_reg", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                        #print(cur_frame)
                     else:    
                         own['actionTimer'] = 20
                         skater.playAction("fak_noposin", 20,1, layer=trans_layer, play_mode=0, speed=1)
                     else:
                         skater.playAction("fak_nmanual", 10,1, layer=trans_layer, play_mode=0, speed=1)                
                         deck.playAction("a_reg_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)
-                        trucks.playAction("a_reg_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)
-                        
-                        
-                        
+                        trucks.playAction("a_reg_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)  
                         
                 if l_actionState == 'fak_turnLeft':
                     trans_playing = skater.isPlayingAction(trans_layer)
                 else:
                     skater.playAction("reg_bsg2", 10,30, layer=loop_layer, play_mode=1, speed=.5)
                     deck.playAction("a_reg", 10,30, layer=loop_layer, play_mode=1, speed=.5)
-                    trucks.playAction("a_reg", 10,30, layer=loop_layer, play_mode=1, speed=.5)
-                    
-                    
+                    trucks.playAction("a_reg", 10,30, layer=loop_layer, play_mode=1, speed=.5)        
                     
             if requestAction == 'fak_frontside_grab':
                 actionState = 'fak_frontside_grab'
                     deck.playAction("a_reg", 10,30, layer=loop_layer, play_mode=1, speed=.5)
                     trucks.playAction("a_reg", 10,30, layer=loop_layer, play_mode=1, speed=.5)  
 
-
             if requestAction == 'frontside_tail_grab':
                 actionState = 'frontside_tail_grab'
                 if l_actionState != 'frontside_tail_grab':
                     trucks.stopAction(flip_layer)
                     skater.playAction("reg_noseg.002", 1,10, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_reg_noseg.002", 1,10, layer=trans_layer, play_mode=0, speed=1)
-                    trucks.playAction("a_reg_noseg.002", 1,10, layer=trans_layer, play_mode=0, speed=1)
-                    #skater.playAction("reg_nmanual", 1,10, layer=trans_layer, play_mode=0, speed=.5)                
-                    #deck.playAction("a_fak_manual", 1,10, layer=trans_layer, play_mode=0, speed=.5)
-                    #trucks.playAction("a_fak_manual", 1,10, layer=trans_layer, play_mode=0, speed=.5)                            
+                    trucks.playAction("a_reg_noseg.002", 1,10, layer=trans_layer, play_mode=0, speed=1)                           
                 else:
                     skater.playAction("reg_noseg.002", 11,40, layer=loop_layer, play_mode=1, speed=.5)
                     deck.playAction("a_reg_noseg.002", 11,40, layer=loop_layer, play_mode=1, speed=.5)
-                    trucks.playAction("a_reg_noseg.002", 11,40, layer=loop_layer, play_mode=1, speed=.5)
-                    #skater.playAction("reg_nmanual", 10,70, layer=loop_layer, play_mode=1, speed=.5) 
-                    #deck.playAction("a_fak_manual", 10,70, layer=loop_layer, play_mode=1, speed=.5)
-                    #trucks.playAction("a_fak_manual", 10,70, layer=loop_layer, play_mode=1, speed=.5)                    
+                    trucks.playAction("a_reg_noseg.002", 11,40, layer=loop_layer, play_mode=1, speed=.5)                   
 
             if requestAction == 'fak_noseg':
                 actionState = 'fak_noseg'
                     trucks.stopAction(flip_layer)                    
                     skater.playAction("fak_noseg", 40,30, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_fak_noseg", 40,30, layer=trans_layer, play_mode=0, speed=1)
-                    trucks.playAction("a_fak_noseg", 40,30, layer=trans_layer, play_mode=0, speed=1)        
-                    #skater.playAction("fak_nmanual", 1,10, layer=trans_layer, play_mode=0, speed=.5)                
-                    #deck.playAction("a_reg_manual", 1,10, layer=trans_layer, play_mode=0, speed=.5)
-                    #trucks.playAction("a_reg_manual", 1,10, layer=trans_layer, play_mode=0, speed=.5)                    
+                    trucks.playAction("a_fak_noseg", 40,30, layer=trans_layer, play_mode=0, speed=1)                            
                 else:
                     skater.playAction("fak_noseg", 30,1, layer=loop_layer, play_mode=1, speed=.5)
                     deck.playAction("a_fak_noseg", 30,1, layer=loop_layer, play_mode=1, speed=.5)
-                    trucks.playAction("a_fak_noseg", 30,1, layer=loop_layer, play_mode=1, speed=.5)
-                    #skater.playAction("fak_nmanual", 10,70, layer=loop_layer, play_mode=1, speed=.5)                
-                    #deck.playAction("a_reg_manual", 10,70, layer=loop_layer, play_mode=1, speed=.5)
-                    #trucks.playAction("a_reg_manual", 10,70, layer=loop_layer, play_mode=1, speed=.5)                    
+                    trucks.playAction("a_fak_noseg", 30,1, layer=loop_layer, play_mode=1, speed=.5)                    
             
             if requestAction == 'reg_tailg':
                 actionState = 'reg_tailg'
                     skater.playAction("reg_tailg.001", 40,30, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_reg_tailg.001", 40,30, layer=trans_layer, play_mode=0, speed=1)
                     trucks.playAction("a_reg_tailg.001", 40,30, layer=trans_layer, play_mode=0, speed=1)
-                    #skater.playAction("reg_manual", 1,10, layer=trans_layer, play_mode=0, speed=.5)                
-                    #deck.playAction("a_reg_manual", 1,10, layer=trans_layer, play_mode=0, speed=.5)
-                    #trucks.playAction("a_reg_manual", 1,10, layer=trans_layer, play_mode=0, speed=.5)                            
+                            
                 else:
                     skater.playAction("reg_tailg.001", 30,1, layer=loop_layer, play_mode=1, speed=.5)
                     deck.playAction("a_reg_tailg.001", 30,1, layer=loop_layer, play_mode=1, speed=.5)
-                    trucks.playAction("a_reg_tailg.001", 30,1, layer=loop_layer, play_mode=1, speed=.5)
-                    #skater.playAction("reg_manual", 10,70, layer=loop_layer, play_mode=1, speed=.5)                
-                    #deck.playAction("a_reg_manual", 10,70, layer=loop_layer, play_mode=1, speed=.5)
-                    #trucks.playAction("a_reg_manual", 10,70, layer=loop_layer, play_mode=1, speed=.5)                    
+                    trucks.playAction("a_reg_tailg.001", 30,1, layer=loop_layer, play_mode=1, speed=.5)                   
 
             if requestAction == 'fak_tailg':
                 actionState = 'fak_tailg'
                     trucks.stopAction(flip_layer)                    
                     skater.playAction("fak_tailg", 40,30, layer=trans_layer, play_mode=0, speed=1)
                     deck.playAction("a_fak_tailg", 40,30, layer=trans_layer, play_mode=0, speed=1)
-                    trucks.playAction("a_fak_tailg", 40,30, layer=trans_layer, play_mode=0, speed=1)        
-                    #skater.playAction("fak_manual", 1,10, layer=trans_layer, play_mode=0, speed=.5)                
-                    #deck.playAction("a_fak_manual", 1,10, layer=trans_layer, play_mode=0, speed=.5)
-                    #trucks.playAction("a_fak_manual", 1,10, layer=trans_layer, play_mode=0, speed=.5)                    
+                    trucks.playAction("a_fak_tailg", 40,30, layer=trans_layer, play_mode=0, speed=1)                            
                 else:
                     skater.playAction("fak_tailg", 30,1, layer=loop_layer, play_mode=1, speed=.5)
                     deck.playAction("a_fak_tailg", 30,1, layer=loop_layer, play_mode=1, speed=.5)
                     trucks.playAction("a_fak_tailg", 30,1, layer=loop_layer, play_mode=1, speed=.5)
-                    #skater.playAction("fak_manual", 10,70, layer=loop_layer, play_mode=1, speed=.5)                
-                    #deck.playAction("a_fak_manual", 10,70, layer=loop_layer, play_mode=1, speed=.5)
-                    #trucks.playAction("a_fak_manual", 10,70, layer=loop_layer, play_mode=1, speed=.5)                                           
+                                                              
             if requestAction == 'reg_tailgr':
                 actionState = 'reg_tailgr'
                 if l_actionState != 'reg_tailgr' and l_actionState != 'reg_air_tail':
                 else:
                     skater.playAction("reg_nosegL", 30,1, layer=loop_layer, play_mode=1, speed=.5)
                     deck.playAction("a_reg_nosegL", 30,1, layer=loop_layer, play_mode=1, speed=.5)
-                    trucks.playAction("a_reg_nosegL", 30,1, layer=loop_layer, play_mode=1, speed=.5)
-            #print("rA:", requestAction)        
+                    trucks.playAction("a_reg_nosegL", 30,1, layer=loop_layer, play_mode=1, speed=.5)       
             if requestAction == 'fak_nosegl':
                 actionState = 'fak_nosegl'
                 print("fak_nosegl state")
                     deck.playAction("a_reg_tails", 30,1, layer=loop_layer, play_mode=1, speed=.5)
                     trucks.playAction("a_reg_tails", 30,1, layer=loop_layer, play_mode=1, speed=.5)                    
 
-
-
-
             if requestAction == 'reg_5050':
                 actionState = 'reg_5050'
                 #own['actionTimer'] = 0
                 #own['actionTimer'] = 0
                 skater.playAction("fak_5050", 1,30, layer=loop_layer, play_mode=1, speed=.5)
                 deck.playAction("a_reg", 1,30, layer=loop_layer, play_mode=1, speed=.5)
-                trucks.playAction("a_reg", 1,30, layer=loop_layer, play_mode=1, speed=.5)                                                                              
+                trucks.playAction("a_reg", 1,30, layer=loop_layer, play_mode=1, speed=.5)
 
             if requestAction == 'reg_bsboard':
                 actionState = 'reg_bsboard'
                 actionState = 'fak_bsboard'
                 skater.playAction("fak_BS_Board2", 1,30, layer=loop_layer, play_mode=1, speed=.5)
                 deck.playAction("a_fak_BS_Board2", 1,30, layer=loop_layer, play_mode=1, speed=.5)
-                trucks.playAction("a_fak_BS_Board2", 1,30, layer=loop_layer, play_mode=1, speed=.5)                                                                              
-
+                trucks.playAction("a_fak_BS_Board2", 1,30, layer=loop_layer, play_mode=1, speed=.5)
             if requestAction == 'reg_fsboard':
                 actionState = 'reg_fsboard'
                 skater.playAction("reg_FS_Board", 1,30, layer=loop_layer, play_mode=1, speed=.5)
                 deck.playAction("a_reg_FS_Board", 1,30, layer=loop_layer, play_mode=1, speed=.5)
-                trucks.playAction("a_reg_FS_Board", 1,30, layer=loop_layer, play_mode=1, speed=.5)                                     
-
-
+                trucks.playAction("a_reg_FS_Board", 1,30, layer=loop_layer, play_mode=1, speed=.5)
 
             if requestAction == 'reg_air_nose':
                 actionState = 'reg_air_nose'
                 else:
                     skater.playAction("fak_hippy", 10,10, layer=loop_layer, play_mode=1, speed=.5)
                     deck.playAction("a_reg", 10,10, layer=loop_layer, play_mode=1, speed=.5)
-                    trucks.playAction("a_reg", 10,10, layer=loop_layer, play_mode=1, speed=.5)                                                              
-                    
-                    
-                             
+                    trucks.playAction("a_reg", 10,10, layer=loop_layer, play_mode=1, speed=.5)
 
     #$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
     #walk anims            
             own['actionState'] = actionState
         else:
             pass
-        #actionTimer = 60
-        #try:
-        #own['actionTimer'] = 60
-        #except: pass
-        #print(actionState)
         own['actionState'] = actionState
         return actionState
             
-    
-    #if (l_actionState == 'reg_land' and own['actionState'] != 'reg_land') or (l_actionState == 'fak_land' and own['actionState'] != 'fak_land'):
-    #if (own['actionState'] != 'reg_land') and (own['actionState'] != 'fak_land'):
     l_playing = skater.isPlayingAction(loop_layer)
     t_playing = skater.isPlayingAction(trans_layer)        
     if l_playing == 1 and t_playing == 1:
     ###
     if own['actionTimer'] > 0:
         own['actionTimer'] -= 1
-        #requestAction = 'empty'
     
 ##############
     #turn off land for manuals
     if (requestAction == 'reg_manual' or requestAction == 'fak_manual' or requestAction == 'reg_nmanual' or requestAction == 'fak_nmanual') and (actionState == 'reg_land' or actionState == 'fak_land'):
         own['actionTimer'] = 0
-        
-    #turn off land for grinds
-    #if requestAction == 'reg_noseg' or requestAction == 'reg_5050' or requestAction == 'fak_5050':
-        #own['actionTimer'] = 0
                   
     if (own['actionTimer'] == 0 or requestAction == 'reg_land' or requestAction == 'fak_land') or requestAction in jump_overrideList:
         actionState = updateAction(requestAction, actionState)
-        #own['actionState'] = actionState
-        
         
     if (own['actionState'] == 'reg_land' or own['actionState'] == 'reg_land') and own['actionTimer'] > 0:
         own['clear_request'] = 1    
     #set last variables
     own['l_actionState'] = actionState
     own['l_requestAction'] = requestAction
-    #own['actionTimer'] = actionTimer
     own['queueAction'] = queueAction
     
 main()

controller2.py

         
         
         if GRAB_ON == True and r_ground.triggered == 0 and aBut == True:
-            own['requestAction'] = 'reg_fp_rback'
-            #skater.playAction("reg_fp_rback", 10,10, layer=2925, priority=8, play_mode=1, speed=.5)
-            #deck.playAction("a_reg_fp_rback", 10,10, layer=2925, priority=8, play_mode=1, speed=.5)
-            #trucks.playAction("a_reg_fp_rback", 10,10, layer=2925, priority=8, play_mode=1, speed=.5)          
+            own['requestAction'] = 'reg_fp_rback'          
         elif GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:
             own['requestAction'] = 'backside_grab'        
             GRAB_PLAYED = True
         GRAB_ON = own["GRAB_ON"]
 
         if GRAB_ON == True and r_ground.triggered == 0 and aBut == True:
-            own['requestAction'] = 'fak_fp_rback'    
-            #skater.playAction("fak_fp_rback", 10,10, layer=2925, priority=8, play_mode=1, speed=.5)
-            #deck.playAction("a_fak_fp_rback", 10,10, layer=2925, priority=8, play_mode=1, speed=.5)
-            #trucks.playAction("a_fak_fp_rback", 10,10, layer=2925, priority=8, play_mode=1, speed=.5)     
+            own['requestAction'] = 'fak_fp_rback'         
         
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:           
             own['requestAction'] = 'fak_frontside_grab' 
         GRAB_PLAYED = own["GRAB_PLAYED"]
         GRAB_ON = own["GRAB_ON"]
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:           
-            #cont.activate(fak_backsidegrab)
             own['requestAction'] = 'fak_backside_tail_grab' 
             GRAB_PLAYED = True
             own["GRAB_PLAYED)"] = GRAB_PLAYED
             SWAG = own.getLinearVelocity(True)
             SWAG = SWAG[1]
             own["swag"] = SWAG
-            #print(SWAG)
             if STANCE == True:
                 if SWAG > 1 and SWAG < 2:
                     rotation = [ 0.0, 0, (SWAG / 200)]
         if framenumber == 900000:
             framenumber = 0
         own["framenum"] = framenumber
-        #print(framenumber)
         
     def push():
         local = True
         lay = grablay + 40
         if STANCE == 0:
             own['requestAction'] = 'reg_brfoot'
-            # skater.playAction("brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # deck.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # trucks.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
+
         if STANCE == 1:
-            own['requestAction'] = 'fak_brfoot'
-            # skater.playAction("fak_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # deck.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # trucks.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED) 
+            own['requestAction'] = 'fak_brfoot' 
         jump()    
     def frfoot():
         lay = grablay + 40
         killact(5)
         if STANCE == 0:
             own['requestAction'] = 'reg_frfoot'
-            # skater.playAction("frfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # deck.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # trucks.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
         if STANCE == 1:
             own['requestAction'] = 'fak_frfoot'
-            # skater.playAction("fakbfrfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # deck.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # trucks.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
         jump()          
     def blfoot():
         lay = grablay + 40
         killact(5)
         if STANCE == 0:
             own['requestAction'] = 'reg_blfoot'
-            # skater.playAction("blfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # deck.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # trucks.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
         if STANCE == 1:
             own['requestAction'] = 'fak_blfoot'
-            # skater.playAction("fakfrfoot.001", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # deck.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # trucks.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
         jump() 
     def flfoot():
         lay = grablay + 40
         killact(5)
         if STANCE == 0:
             own['requestAction'] = 'reg_flfoot'
-            # skater.playAction("flfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # deck.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # trucks.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
         if STANCE == 1:
             own['requestAction'] = 'fak_flfoot'
-            # own['reuqestAction'] = 'fak_flfoot'
-            # skater.playAction("fak_flfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # deck.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED)
-            # trucks.playAction("a_brfoot", 1, 30, layer=lay, blendin=2, play_mode=0, speed=CAVEMAN_SPEED) 
         jump()         
     def rollsound():
         #onground
                     own['grindType'] = "reg_bsboard"
                 else:
                     own['grindType'] = "fak_bsboard"    
-    #            if jumpstance == 1:
-    #                own['grindType'] = "fak_bsboard"
-    #                own["stance"] = True
-    #                STANCE = True
-    #            elif jumpstance == 0:    
-    #                own['grindType'] = "reg_bsboard"
-    #                own["stance"] = False
-    #                STANCE = False
-    #            elif jumpstance == 3:
-    #                if STANCE == True:
-    #                    own['grindType'] = "fak_bsboard"
-    #                else:
-    #                    own['grindType'] = "reg_bsboard"        
+        
             if STANCE == True:    
                 if own['grindType'] == "reg_bsboard":
                     own['grind_stance'] = 0
                     own['grind_stance'] = 0
                 elif own['grindType'] == "fak_noseslide":
                     own['requestAction'] = 'fak_noseslide'  
-                    own['grind_stance'] = 1              
-    #            elif own['grindType'] == "nose_stall":
-    #                own['requestAction'] = 'nose_stall'
-    #                skater.playAction("fak_nose_stall", 1,30, layer=700, blendin=gblend, play_mode=1, speed=.5)
-    #                deck.playAction("a_fak_nose_stall", 1,30, layer=700, blendin=gblend, play_mode=1, speed=.5)
-    #                trucks.playAction("a_fak_nose_stall", 1,30, layer=700, blendin=gblend, play_mode=1, speed=.5)  
-    #            elif own['grindType'] == "tail_stall":
-    #                own['requestAction'] = 'tail_stall'
-    #                skater.playAction("fak_tail_stall", 1,30, layer=700, blendin=gblend, play_mode=1, speed=.5)
-    #                deck.playAction("a_fak_tail_stall", 1,30, layer=700, blendin=gblend, play_mode=1, speed=.5)
-    #                trucks.playAction("a_fak_tail_stall", 1,30, layer=700, blendin=gblend, play_mode=1, speed=.5) 
+                    own['grind_stance'] = 1               
                 else:
                     if STANCE == 0:
                         own['requestAction'] = 'reg_5050'
                     if STANCE == 1:
                         own['requestAction'] = 'fak_5050'
                 
-            #elif STANCE == False and LAST_GRIND == False:
             elif STANCE == False:
                 if own['grindType'] == "reg_bsboard":
                     own['grind_stance'] = 0
                     own['requestAction'] = 'reg_tailslide'
                 elif own['grindType'] == "fak_tailslide":
                     own['grind_stance'] = 1
-                    #own['requestAction'] = 'fak_tailslide'
                     own['requestAction'] = 'reg_noseslide'
-                    print('mod slide')
                 elif own['grindType'] == "reg_noseslide":
                     own['grind_stance'] = 0
                     own['requestAction'] = 'reg_noseslide'
                 elif own['grindType'] == "fak_noseslide":  
                     own['grind_stance'] = 1              
-                    #own['requestAction'] = 'fak_noseslide'
-                    own['requestAction'] = 'reg_tailslide'
-                    
-                    
-    #            elif own['grindType'] == "nose_stall":
-    #                skater.playAction("nose_stall", 1,30, layer=700, blendin=gblend, play_mode=1, speed=.5) 
-    #                deck.playAction("a_nose_stall", 1,30, layer=700, blendin=gblend, play_mode=1, speed=.5)
-    #                trucks.playAction("a_nose_stall", 1,30, layer=700, blendin=gblend, play_mode=1, speed=.5) 
-    #                #print("nose_stall") 
-    #            elif own['grindType'] == "tail_stall":
-    #                skater.playAction("reg_tail_stall", 1,30, layer=700, blendin=gblend, play_mode=1, speed=.5)
-    #                deck.playAction("a_reg_tail_stall", 1,30, layer=700, blendin=gblend, play_mode=1, speed=.5)
-    #                trucks.playAction("a_reg_tail_stall", 1,30, layer=700, blendin=gblend, play_mode=1, speed=.5)
-                    #print("reg_tail_stall")                                 
+                    own['requestAction'] = 'reg_tailslide'                                
                 else:
                     if STANCE == 0:
                         own['requestAction'] = 'reg_5050'
         else:
             own["coping"] = 0    
 
-
     def onboard():
         if own['walk'] == 1:
             cont.deactivate(cam.actuators['replayCam'])
     def grass():
         try:
             if 'grass' in r_ground.hitObject:
-                #print("grass")
                 linVel = own.getLinearVelocity(True)
                 linvelx = linVel.x * .98
                 own.setLinearVelocity((linvelx, linVel.y, linVel.z), 1)
         last_ground_frame = own['lF_ground_frame']
         lF_air_frame = own['lF_air_frame']
         frames_since_ground = framenum - lF_air_frame    
-        #if frames_since_ground  > 20:
         if own['manual_v2_type'] == 'reg manual': 
             own['requestAction'] = 'reg_manual_revert_ccw'   
             print("reg")
         elif own['manual_v2_type'] == 'reg nose manual':
-            own['requestAction'] = 'fak_manual_revert_ccw'    
-            #skater.playAction("fak_manual_revert_ccw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_fak_manual_revert_ccw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_fak_manual_revert_ccw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
+            own['requestAction'] = 'fak_manual_revert_ccw'  
             print("reg nose manual revert")             
         elif own['manual_v2_type'] == 'fak manual': 
             own['requestAction'] = 'fak_manual_revert_ccw'   
-            #skater.playAction("fak_manual_revert_ccw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_fak_manual_revert_ccw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_fak_manual_revert_ccw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("fak manual revert")
         elif own['manual_v2_type'] == 'fak nose manual': 
             own['requestAction'] = 'reg_manual_revert_ccw'   
-            #skater.playAction("reg_manual_revert_ccw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_reg_manual_revert_ccw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_reg_manual_revert_ccw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("fak")           
         else:
             own['requestAction'] = 'revert1'            
         own.applyRotation(rot,local)
         if own['manual_v2_type'] == 'reg manual': 
             own['requestAction'] = 'reg_manual_revert_cw'   
-            #skater.playAction("reg_manual_revert_cw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_reg_manual_revert_cw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_reg_manual_revert_cw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("reg")
         elif own['manual_v2_type'] == 'reg nose manual':    
             own['requestAction'] = 'fak_manual_revert_cw'
-            #skater.playAction("fak_manual_revert_cw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_fak_manual_revert_cw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_fak_manual_revert_cw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("reg nose manual revert")             
         elif own['manual_v2_type'] == 'fak manual':    
             own['requestAction'] = 'fak_manual_revert_cw'
-            #skater.playAction("fak_manual_revert_cw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_fak_manual_revert_cw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_fak_manual_revert_cw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("fak manual revert")
         elif own['manual_v2_type'] == 'fak nose manual':    
             own['requestAction'] = 'reg_manual_revert_cw'
-            #skater.playAction("reg_manual_revert_cw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_reg_manual_revert_cw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_reg_manual_revert_cw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("fak")   
         else:     
             own['requestAction'] = 'revert2'       
         print("real revert 3")  
         if own['manual_v2_type'] == 'reg manual':  
             own['requestAction'] = 'reg_manual_revert_ccw'  
-            #skater.playAction("reg_manual_revert_ccw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_reg_manual_revert_ccw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_reg_manual_revert_ccw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("reg")
         elif own['manual_v2_type'] == 'reg nose manual':    
             own['requestAction'] = 'fak_manual_revert_ccw'
-            #skater.playAction("fak_manual_revert_ccw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_fak_manual_revert_ccw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_fak_manual_revert_ccw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("reg nose manual revert")             
         elif own['manual_v2_type'] == 'fak manual': 
             own['requestAction'] = 'fak_manual_revert_ccw'   
-            #skater.playAction("fak_manual_revert_ccw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_fak_manual_revert_ccw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_fak_manual_revert_ccw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("fak manual revert")
         elif own['manual_v2_type'] == 'fak nose manual':
             own['requestAction'] = 'reg_manual_revert_ccw'    
-            #skater.playAction("reg_manual_revert_ccw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_reg_manual_revert_ccw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_reg_manual_revert_ccw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("fak")   
         else:       
             own['requestAction'] = 'revert3' 
         own.applyRotation(rot,local)  
         if own['manual_v2_type'] == 'reg manual':    
             own['requestAction'] = 'reg_manual_revert_cw'
-            #skater.playAction("reg_manual_revert_cw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_reg_manual_revert_cw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_reg_manual_revert_cw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("reg")
-        #elif own['reg_nmanual'] == 1:
         elif own['manual_v2_type'] == 'reg nose manual':    
             own['requestAction'] = 'fak_manual_revert_cw'
-            #skater.playAction("fak_manual_revert_cw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_fak_manual_revert_cw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_fak_manual_revert_cw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("reg nose manual revert")             
-        #elif own['fak_manual'] == 1 or own['fak_nmanual'] == 1:
         elif own['manual_v2_type'] == 'fak manual':    
             own['requestAction'] = 'fak_manual_revert_cw'
-            #skater.playAction("fak_manual_revert_cw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_fak_manual_revert_cw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_fak_manual_revert_cw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("fak manual revert")
         elif own['manual_v2_type'] == 'fak nose manual':    
             own['requestAction'] = 'reg_manual_revert_cw'
-            #skater.playAction("reg_manual_revert_cw", 70,10, layer=400, priority=8, play_mode=0, speed=4)
-            #deck.playAction("a_reg_manual_revert_cw", 70,10, layer=400, priority=1, play_mode=0, speed=4)
-            #trucks.playAction("a_reg_manual_revert_cw", 70,10, layer=400, priority=0, play_mode=0, speed=4)
             print("fak") 
         else:
             own['requestAction'] = 'revert4'
         nollie_varial_heelflip()
         reset_rtimers()   
 
-
-
-
     #360 shovit
     if q3oncd > 0 and q4oncd > 0 and q5oncd > 0 and q6oncd > 0 and q7oncd > 0 and q7oncd >= q6oncd >= q5oncd >= q4oncd >= q3oncd:
     #    print("q4oncd: ", q4oncd, " q5oncd: ", q5oncd, " q6oncd: ", q6oncd)
         own["Q7oncd"] = q7oncd
     #360 fs shovit    
     if q3oncd > 0 and q4oncd > 0 and q5oncd > 0 and q6oncd >= 0 and q7oncd > 0 and q7oncd <= q6oncd <= q5oncd <= q4oncd <= q3oncd:
-    #    print("q4oncd: ", q4oncd, " q5oncd: ", q5oncd, " q6oncd: ", q6oncd)
-        #print ("______-------360 shovit")
         dict['trick_string'] = '360 Frontside Shovit'
         fsshovit360()
         q3oncd = 0
         own["Q1oncd"] = q1oncd
         own["Q4oncd"] = q4oncd    
 
-
     #shovit
     if q4oncd > 0 and q5oncd > 0 and q6oncd > 0 and q4oncd <= q5oncd <= q6oncd and q3oncd < 1:
        shovit()
         
     #fsshovit
     if q4oncd > 0 and q5oncd > 0 and q6oncd > 0 and q6oncd <= q5oncd <= q4oncd and q7oncd < 1:
-    #    print("q4oncd: ", q4oncd, " q5oncd: ", q5oncd, " q6oncd: ", q6oncd)
-    #    print ("^%*^%*^%*^%fsshovit")
         fsshovit()
         q4oncd = 0
         q5oncd = 0
         
     #nollie_fsshovit
     if q8oncd > 0 and q1oncd > 0 and q2oncd > 0 and q8oncd <= q1oncd <= q2oncd and q7oncd == 0:
-    #    print("q4oncd: ", q4oncd, " q5oncd: ", q5oncd, " q6oncd: ", q6oncd)
         print ("nollie fsshovit")
         nollie_fsshovit()
-        #nollie_shovit()
         q8oncd = 0
         q1oncd = 0
         q2oncd = 0
         STANCE = own["stance"]
         if own['hippy'] == 1 and own['last_hippy'] == 0:
             if STANCE == 0:
-                #own['requestAction'] = 'reg_hippy'
                 own['requestAction'] = 'reg_hippy_in'
-                #skater.playAction("reg_hippy", 1,10, layer=1101, priority=1, layer_weight=0, play_mode=0, speed=.5)
             if STANCE == 1:
-                own['requestAction'] = 'fak_hippy_in'
-                #skater.playAction("fak_hippy", 1,10, layer=1101, priority=1, layer_weight=0, play_mode=0, speed=.5)            
+                own['requestAction'] = 'fak_hippy_in'         
         if own['hippy'] == 1 and own['last_hippy'] == 1:
             if STANCE == 0:
                 own['requestAction'] = 'reg_hippy_in'
-                #skater.playAction("reg_hippy", 10,10, layer=1100, priority=0, layer_weight=0, play_mode=1, speed=.5)
             if STANCE == 1:
                 own['requestAction'] = 'fak_hippy_in'
-                #skater.playAction("fak_hippy", 10,10, layer=1100, priority=0, layer_weight=0, play_mode=1, speed=.5)
         if own['hippy'] == 0 and own['last_hippy'] == 1:
             killact(1100)
             if rLR > turnsens:
                 print("hippy turn")
                 if STANCE == 0:
                     own['requestAction'] = 'reg_hippy_ncw'
-                    #skater.playAction("reg_hippy_ncw", 10,40, layer=1102, priority=1, layer_weight=0, play_mode=0, speed=.5)
                     print('%hip1')
                 if STANCE == 1:
-                    own['requestAction'] = 'fak_hippy_ncw'
-                    #skater.playAction("fak_hippy_ncw", 10,40, layer=1102, priority=1, layer_weight=0, play_mode=0, speed=.5)                
+                    own['requestAction'] = 'fak_hippy_ncw'                
                     print('%hip2')
             elif rLR < -turnsens:
                 local = True
                 own.applyRotation(rot,local)
                 print("hippy turn neg")            
                 if STANCE == 0:
-                    own['requestAction'] = 'fak_hippy_nccw'
-                    #skater.playAction("fak_hippy_nccw", 10,40, layer=1102, priority=1, layer_weight=0, play_mode=0, speed=.5)  
+                    own['requestAction'] = 'fak_hippy_nccw'  
                     print('%hip3')
                 if STANCE == 1:
                     own['requestAction'] = 'reg_hippy_nccw'
-                    #skater.playAction("reg_hippy_nccw", 10,40, layer=1102, priority=1, layer_weight=0, play_mode=0, speed=.5) 
                     print('%hip4')
     ##straight        
             else:
                 if STANCE == 0:
-                    #skater.playAction("reg_hippy", 10,40, layer=1102, priority=1, layer_weight=0, play_mode=0, speed=.5)
                     own['requestAction'] = 'reg_hippy'
                 if STANCE == 1:
-                    own['requestAction'] = 'fak_hippy'
-                    #skater.playAction("fak_hippy", 10,40, layer=1102, priority=1, layer_weight=0, play_mode=0, speed=.5)                                        
+                    own['requestAction'] = 'fak_hippy'                                       
 
     #pushing and hippy jumps
 
     cush = 10
     hippy = 0
     own['hippy'] = 0
-    #print(since_a, "a", since_x, "x")
-
-    #if xBut == 1 and aBut == 1 and since_a <= cush and since_x <= cush and (lTrig < 0.02 and rTrig < 0.02): 
+ 
     if xBut == 1 and aBut == 1 and (lTrig < 0.02 and rTrig < 0.02) and r_ground.triggered == True: 
         #F"hippy")
         hippy = 1
         own['hippy'] = 1
-        #hippy_jump()
-    #print(hippy)
+
     hippy_jump()    
     if since_a > cush and aBut == 1 and lasta == 1 and (lTrig < 0.02 and rTrig < 0.02) and own['last_hippy'] == 0:
-        #print("apush suckka", since_a)
         if xBut == 0 and hippy == 0 and lastaBut_ground == True:
             push()
     if since_x > cush and xBut == 1 and lastx == 1 and (lTrig < 0.02 and rTrig < 0.02) and own['last_hippy'] == 0:
-        #print("push suckka", since_x)
         if aBut == 0 and hippy == 0 and lastxBut_ground == True:
             push_goof()      
     #cavemans 
         
     #push b button
     if bBut == 1:
-        #print("push suckka")
         if linVelocity.x > .05 or linVelocity.x < -.05:
             stop()
         elif linVelocity.x < .05 or linVelocity.x > -.05:
         playing = skater.isPlayingAction(fliplay)
         if playing == 1:
             frame = skater.getActionFrame(fliplay)
-            #print("Flipping frame: ", frame)
             if frame > 16:
                 skater.stopAction(fliplay)
     #frontside grab
             frontside_tail_grab_on()                
 
     #backside grab
-    #if lTrig > 0.02 and GRAB_ON == False and r_ground.triggered == 0:
     if lTrig > 0.02 and r_ground.triggered == 0 and flipping == False:    
         GRAB_ON = True
         own["GRAB_ON"] = GRAB_ON
         own["GRAB_PLAYED"] = GRAB_PLAYED
 
     #frontside pump #backside pump
-
     def footplant():    
         framenum = own['framenum']
         last_ground_frame = own['lF_ground_frame']
         if grindHit == False:
             own['footplant_on'] = 0 
         if own['footplant_on'] == True and rUD < turnsens and rUD > -turnsens:
-            #own.setLinearVelocity([0,0,0],0)
             own.linearVelocity.x = 0
             own.linearVelocity.y = 0
         if own['footplant_on'] == 1 and own['last_footplant'] == True and own['jump_timer'] < 50:
             if skater.isPlayingAction(2925) == False:
                 if STANCE == 0:
-                    own['requestAction'] = 'reg_fp_rback'
-                    #print("requesting footplant0")               
+                    own['requestAction'] = 'reg_fp_rback'              
                 if STANCE == 1:
                     own['requestAction'] = 'fak_fp_rback'
-                    #print("requesting footplant1")
                
     def invert():    
-        if grindHit == True and own['grindpos'] == 'reg_board':
-        #if LAST_GRIND == False and grindHit == True and own['grindpos'] == 'reg_board':    
-            if lBump == 1:
-                #print("invert")
-            #if coping_on ==1 and lBump == 1:
-                #print("invert")   
+        if grindHit == True and own['grindpos'] == 'reg_board':   
+            if lBump == 1:   
                 own['invert_on'] = 1
-                #invert_on = 1
                 own.linearVelocity.x = 0
                 own.linearVelocity.y = 0
         if own["coping"] == 1 and own['invert_on'] == 1:
             if own['invert_on'] == 1 and own['last_invert'] == False:
-                #killall()
                 cont.activate(own.actuators['invertOn_sound'])
                 if STANCE == False:
                     own['invert_type'] = "reg_back_invert_in"
                 if STANCE == True:
                     own['invert_type'] = "fak_fr_invert"                         
         if own['invert_on'] == 0 and own['last_invert'] == True:
-            #print("kill invert")
             own['last_invert_frame'] = frame
             cont.activate(own.actuators['invertOff_Sound'])
      
                 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))
-                #cam.applyMovement([0,-1,0], True)
-                #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))
-                #cam.applyMovement([0,1,0], True)            
-                #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
-
-
-       
-    #start button
-    #print(own['last_stBut'])
-    #print(own['pause_on'])    
+     
+    #start button   
     if stBut == True:
         own.actuators["sroll"].volume = .0001
         cont.deactivate(own.actuators["sroll"])
         own.actuators["sroll"].stopSound()
     if stBut == False and own['last_stBut'] == True:
         if own['pause_on'] == True:
-            own['pause_on'] = False
-            #own.restoreDynamics()     
+            own['pause_on'] = False   
         else:
-            own['pause_on'] = True
-            #own.suspendDynamics()            
+            own['pause_on'] = True           
         
     own['last_stBut'] = stBut
          
                     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
                 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 > -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    
         jumping = None
         gotcd = 25
         force = [0,0,0]
-        grindHit = own['grindTouch'] 
-        #print("grindHit: ", grindHit)     
+        grindHit = own['grindTouch']   
         sincegrinding = own['framenum']  - own['grindstartFrame']
         STANCE = own['stance']
         if rUD > turnsens or rLR > turnsens or rUD < -turnsens or rLR < -turnsens:
             cont.deactivate(own.actuators['grindoutRight'])
             cont.deactivate(own.actuators['grindoutLeft'])   
         if (grindHit == True and jumping == None and sincegrinding > 20)or own['invert_on'] == True:
-        #if grindHit == True and jumping == None:
             outloc = 0.022
             bsoutloc = .07
             bsoutvel = .1
                 if gt_cd == 0:
                     gt_cd = 30
                     own['gt_cd'] = gt_cd        
-        #else:
-
-            #else:
+        
             if own['grindoutturn'] == 0:    
                 cont.deactivate(own.actuators["grindoutRight"])
                 own["grindoutturn"] = 0  
     def air_height():
         height = own["air_height"]
         if lf_ground == True and r_ground.triggered == False:
-            height = 0
-        #if     
+            height = 0    
         
     #wallride
     def wallride():
         distance = own.getDistanceTo(gray.hitPosition)
         upforce = 25
         sideforce = 15
-        #distance = own["air_height"]
         try:
             obj = gray.hitObject
             objpos = obj.worldPosition
             ownpos = own.worldPosition
             distance = ownpos.z - objpos.z
-            #print(distance)
         except:
             pass    
         if wallrideL.triggered and wallride_off == 0 and r_ground.triggered == False:
-            #print("wallrideL", distance)
             own['jump_timer'] = 0
             if r_ground.triggered == False:
                 own["wallride"] = "L"
-                #print(own["wallride"])
                 cont.activate(wallrideconstL)
                 force = [0,sideforce,upforce]
                 own.applyForce(force,1)            
-                #own.alignAxisToVect(obj.worldPosition, 1, .9)
                 #align
                 if STANCE == 0:
                     own['requestAction'] = 'reg_wall_r'
-                    #skater.playAction("reg_wall_r", 10,10, layer=3000, priority=8, play_mode=1, speed=.5)
                 else:
                     own['requestAction'] = 'fak_wall_l'
-                    #skater.playAction("fak_wall_l", 10,10, layer=3000, priority=8, play_mode=1, speed=.5)
-                #deck.playAction("a_reg_wall_r", 10,10, layer=3000, priority=8, play_mode=1, speed=.5)
-                #trucks.playAction("a_reg_wall_r", 10,10, layer=3000, priority=8, play_mode=1, speed=.5)
+
         else:
             if own["wallride"] != "R":
                 own["wallride"] = None
             killact(3002)       
         if wallrideR.triggered and wallride_off == 0:
             own['jump_timer'] = 0
-            #print("wallrideR", distance) 
             if r_ground.triggered == False:
                 own["wallride"] = "R"
                 cont.activate(wallrideconstR)
                 #own.alignAxisToVect(obj.worldPosition, 1, .9)
                 if STANCE == 0: 
                     own['requestAction'] = 'reg_wall_l'
-                    #skater.playAction("reg_wall_l", 10,10, layer=3000, priority=8, play_mode=1, speed=.5)
                 else:
-                    own['requestAction'] = 'fak_wall_r'
-                    #skater.playAction("fak_wall_r", 10,10, layer=3000, priority=8, play_mode=1, speed=.5)
-                #deck.playAction("a_reg_wall_l2", 10,10, layer=3000, priority=8, play_mode=1, speed=.5)
-                #trucks.playAction("a_reg_wall_l2", 10,10, layer=3000, priority=8, play_mode=1, speed=.5)              
+                    own['requestAction'] = 'fak_wall_r'             
         else:
             if own["wallride"] != "L":
                 own["wallride"] = None
             try: 
                 delta = player_pos - jump_obj
             except:
-                #print("delta broke: ", player_pos, grinder_pos)
                 pass 
             delta = delta.cross(vect) 
             deltamove = delta[1] * .25
             move = [deltamove, 0, 0]
-            #print(deltamove)
             if abs(deltamove) < 1 and delta[1] < 1:
                 own.applyMovement(move, True)               
 
     def air_mover():
         if r_ground.triggered == False and jump_timer > 53 and frames_since_grinding > 50:
-            #print(lUD)
             if lUD > 0.075:
-                #print("air_mover", jump_timer)
                 if STANCE == 0:
                     force2 = [120, 0, 10]
                 if STANCE == 1:
                     force2 = [-120, 0, 10]            
                 
                 own.applyForce(force2, True)
-                #own.applyForce([0,0,5], False)
                 own['no_grind_pull'] = 1
         if r_ground.triggered == False and jump_timer > 10 and lUD > 0.075 and frames_since_grinding > 50:
-            #print(lUD)
-            #print("air_mover", jump_timer)
             if STANCE == 0:
                 force2 = [7, 0, 10]
             if STANCE == 1:
     if framenum - lF_air_frame > 30:
         own['no_grind_pull'] = 0
 
-                      
-    #if grindHit == 1:
-    #    skater.applyRotation([0,0,.05], False)
-    #    deck.applyRotation([0,0,.05], False)
-    #    trucks.applyRotation([0,0,.05], False)
-    #else:
-    #    skater.applyRotation([0,0,.0], False)            
-    #    deck.applyRotation([0,0,.0], False)            
-    #    trucks.applyRotation([0,0,.0], False)            
-    #control_calib() #scene must be enabled in main                 
     jump_Timer()
     check_landing()
-    #SWAG()
-
-    #isplaying()
     nextframe()
     wheelroll()
     rollsound()
     own['last_invert'] = invert_on
     own['lastbkBut'] = bkBut
     own['grab_type'] = grab_type
-
     own['last_last_manual'] = own['last_manual']
     own['last_manual'] = own['manual']
     own['last_reg_manual'] = own['reg_manual']     
     if r_ground.triggered and own["jump_timer"] < 20:
         force2 = [0.0, 0, -10]
         own.applyForce(force2, True)
-    #print('grindtouch = ',  own['grindTouch'])
     if (grindDar == False and r_ground.triggered and own['grindTouch'] == False) or own['jump_timer'] > 40:
-        own['grindType'] = ''
-        
-    #print(own['grindType'])   
-
-     
+        own['grindType'] = ''

grindV2.py

     last_grindDar = 0
     last_manual = own["manual"]
     joinit = 0
-    #print(minus)
-#    if grindold == True and minus > 20:
-#        align_strength = .1
-#        print("slow align")
-
     rot = own.getAxisVect( [0.0, 0.0, 1.0])
     dropin = own['dropinTimer']
     nearestObject = None
     grindyvect = None
     skipcol = 0
     skipconst = 0
-    #print("--------frame: ", own['framenum'])
-    #inertia = player.linearVelocity
-    #print(rotz)
     try:
         no_grind_pull = own['no_grind_pull']
     except:    
         no_grind = 1
     
     #check manual
-
     manual = 0
     own["nogrindsound"] = 0
-    #print(frames_since_ground)
-    #print("grindold: ", grindold)
-    
-    
     
 #---------###########___###########-----------    
 #start new                     #######     
     ogrot = own.orientation
     ogrot = player_e
     
-    if (framenum - gsf) > 15:
-        velx = linVelocity2.x
-        vely = linVelocity2.y
-        #print("limit speed")
-    else:    
-        velx = linVelocity2.x
-        vely = linVelocity2.y     
+    # if (framenum - gsf) > 15:
+    #     velx = linVelocity2.x
+    #     vely = linVelocity2.y
+    #     #print("limit speed")
+    # else:    
+    #     velx = linVelocity2.x
+    #     vely = linVelocity2.y     
     if abs(own['pregrind_vely']) > abs(vely) and own['LAST_GRIND'] == 0:
         convely = own['pregrind_vely']
     else:
             grindyvect = "pos"
         if rot < -315: 
             grindvect = "pos"   
-        #                     
-        #print(grindvect, STANCE)
+
         rot = round((rot * .01), 1)
         rot *= 100
-        #print(rot)
 
         #print(own['inverting'])
         if frames_grinding > 20 and own['inverting'] == False: 
                 #print("-90 reg stance")                        
                 own['stance'] = 0
                 STANCE = 0
-        #print("stance: ", STANCE)
     def grindrotvel(obj):        
-        skipconst = 1
-        #print("set jumponinit")              
+        skipconst = 1              
         joinit = 0
         grinder_e = obj.worldOrientation.to_euler()
         grinder_rotz = math.degrees(grinder_e[2]) 
         grinder_vectz = obj.getAxisVect( [0, 0, 1]) 
         rot = player_rotz - grinder_rotz        
         rayhit = ray.hitObject
-        #print(round(rot,2), STANCE, " = rotation") 
         own['grind_rot'] = rot
         vect = obj.getAxisVect( [1.0, 0.0, 0.0])
         xyzb = obj.worldOrientation.to_euler()
         bsrot = [ 0.0, 0.0, 1.570796327]    
         negbsrot = [ 0.0, 0.0, -1.570796327]
         zvel = own.linearVelocity
-        zvel = zvel.z * .95      
-        #print(rot, "rot")
+        zvel = zvel.z * .95
         if grindold == 0:
             if rotz < 0:
                 rotz = rotz + 360
             if rotz < rotzb:
                 sub_converted = rotzb - rotz
 
-        #print("J grindvect: ", grindvect, "align: ", align)
         #z align
         #print("zalign") 
         player.alignAxisToVect(grinder_vectz, 2, .15)                                                  
                 
 #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@        
     def grind(obj):
-        #if (ray.triggered and grindold == False) or (touched == True and own['lastTouched'] == False):
-        #print("gt: ", gt_cd)
         try:
             grindyvect = own['grindyvect']
         except:
             own["grindSound"] = "concrete"
         own['lGobj'] = obj         
         
-        
-        #if 1 == 1:
         grinding = 1                
         
         framenum = own['framenum']
         lastairframe = own['lF_air_frame']
         jumpside = 0
         if (framenum - lastairframe) < 10:
-        #if lastGround == False:
-            player_pos = own['jumpPos']
-            #print("get side from jumpPos", framenum, lastairframe) 
+            player_pos = own['jumpPos'] 
             jumpside = 1   
         else:    
             player_pos = OG_PLAYER_POS
         player_pos = own.worldPosition    
         try:    
             if 1 == 1:       
-                
                 grinder_pos = obj.worldPosition 
-                    #print("touchObj", obj)     
-                #vectTo = player.getVectTo(grinder_pos)    
                 worldVect = [1, 0, 0]
                 vect = obj.getAxisVect(worldVect)      
                 go = obj.worldOrientation
                     #print("delta broke: ", player_pos, grinder_pos)
                     pass 
                 delta = delta.cross(vect)
-                #print(own["grindpos"], touched, "eval broken!!?!", delta[2])
                 if delta[2] >= 0:
-                    #print("right side", grindyvect, round(delta[2], 6))
                     grindside = "right"
                 else:
-                    #print("left side", grindyvect, round(delta[2], 6))
                     grindside = "left"
                 if (delta[2] > .00001 or delta[2] < -.00001) and (delta[2] < .8 or delta[2] < -.8):
                     rotation = own.worldOrientation[2] - obj.worldOrientation[2]
                     player_rotz = math.degrees(player_e[2])
                     grinder_e = obj.worldOrientation.to_euler()
                     grinder_rotz = math.degrees(grinder_e[2])
-                    #print("rotation =", player_rotz - grinder_rotz)
-                    #print( "rotating - grindvect: ", grindvect)
                     deltamove = delta[2] * .3#.25
                     #5050
-                    #print(own["grindpos"], jumpside)
-                    #print("delta move")
                     if own["grindpos"] == "reg_5050":
                         #print("missing delta")
                         if (jumpside == 1 or jumpside == 0) and grindvect == "pos":
                             #print("2deltamove -", deltamove)
                             own.applyMovement(move, True)  
                     #board
-                    #print("turnud: ", own["turnud"], "grindyvect: ", grindyvect)
                     if own["grindpos"] == "reg_board":
                         if grindvect == "neg":
                             if (jumpside == 1 or jumpside == 0) and grindyvect == "pos":
                                 own.applyMovement(move, True)        
                             if (jumpside == 1 or jumpside == 0) and grindyvect == "neg":
                                 move = [-deltamove, 0, 0]
-                                #print("6deltamove -", deltamove)
                                 own.applyMovement(move, True)                    
                 own['grindside'] = grindside    
         except:
             if 'rail' in touchobj:
                 newvelx = velo.x * grindspeed_rail   
                 newvely = velo.y * grindspeed_rail
-                #print("grindspeed limit rail")
             else:
                 newvelx = velo.x * grindspeed_cement  
                 newvely = velo.y * grindspeed_cement            
-            #print("grindspeed limit cement")
-            #print("setting newvely =", newvely)
-            player.setLinearVelocity([newvelx, newvely, velo.z], 1) 
-            #print("grindspeedlimit")  
+            player.setLinearVelocity([newvelx, newvely, velo.z], 1)   
             player_rot = own.worldOrientation[2]
             grinder_rot = touchobj.worldOrientation[2]
             player_rot = own.getAxisVect( [0.0, 0.0, 1.0])
             if (minDist is None or dist < minDist):
                 nearestObject = obj
                 minDist = dist
-        if nearestObject != None:        
-            #vect = nearestObject.getAxisVect( [1.0, 0.0, 0.0])
-        #own.alignAxisToVect(vect, 0, 0)
-            #own.worldPosition = [nearestObject.worldPosition.x, nearestObject.worldPosition.y, nearestObject.worldPosition.z + .2975]
-            #own.setLinearVelocity([0, 0.0, 0], 1)                    
+        if nearestObject != None:                            
             own.linearVelocity.x = 0
             own.linearVelocity.y = 0
-            #print("setting invertpos")
                
             
     
             if (minDist is None or dist < minDist):
                 nearestObject = obj
                 minDist = dist     
-        #print(dist, nearestObject, "grindDar")
         
 #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@        
         #init grind
         
         if invert_on:
             invertpos(detectedObjects)
-            #print('invertOn')
             own['inverting'] = True
         else:
             own['inverting'] = False
             hitObject, hitPoint, hitNormal = own.rayCast(nearestObject.worldPosition, own.worldPosition, .0, 'grind')
             if grindold == 0:
                 if grindTouch.positive:
-                    #print("set grind pos")
                     nearpos = nearestObject.worldPosition
                     if hitNormal != None:
                         own.alignAxisToVect(hitNormal, 2, .05) 
             own["grindHit"] = True
             #print("grinding")
             grind_height_dif = (own.worldPosition[2] - nearestObject.worldPosition[2]) - .287
-            #print(grind_height_dif)
             worldPos = own.worldPosition
             if grind_height_dif > -.05:#02:
-                #print("############################upping z")
-                #own.worldPosition = [worldPos.x, worldPos.y, worldPos.z + .1]
-
                 grindvect(nearestObject)          
                 grindrotvel(nearestObject)
                 grind(nearestObject)
         if own['grindOld'] == 0 and ray.triggered == 0:
             own['aligntimer'] = 0   
             
-#    def invertpos():
-#        minDist = None
-#        nearestObject = None
-#        for obj in invertObjs:
-#            dist = own.getDistanceTo(obj)
-#            if (minDist is None or dist < minDist):
-#                nearestObject = obj
-#                minDist = dist
-#        vect = nearestObject.getAxisVect( [1.0, 0.0, 0.0])
-#        #own.alignAxisToVect(vect, 0, 0)
-#        own.worldPosition = [nearestObject.worldPosition.x, nearestObject.worldPosition.y, nearestObject.worldPosition.z +.1]
-#        #own.setLinearVelocity([0, 0.0, 0], 1)                    
-
     def set_pregrind_vel():
         if grindDar.triggered == False and ray.triggered == False:
-            #print("set pregrind vel") 
             own['pregrind_velx'] = linVelocity2.x
             own['pregrind_vely'] = linVelocity2.y
             own['pregrind_velz'] = linVelocity2.z
     def stop_bounce():
         if grindTouch.triggered and no_grind == 0 and grind_jump == 0 and jump_timer < 30:
             linVelocity4 = own.getLinearVelocity(True)
-            #print(linVelocity4.z)
             if linVelocity4.z > 0:
                 own.setLinearVelocity([linVelocity4.x, linVelocity4.y, 0], 1)
                         
-#        last_posz = own['last_z']
-#        posz = own.worldPosition.z
-#        obj = None
-#        if ray.triggered:
-#            obj = ray.hitObject
-#        if grindTouch.triggered:
-#            obj = grindTouch.hitObject        
-#        #if last_posz < posz and grindold == True and obj != None:
-#        gsf = own['grind_start_frame']
-#        frame = own['framenum']
-#        sub = frame - gsf
-#        linVelocity4 = own.getLinearVelocity(True)
-#        avelx = linVelocity4.x
-#        avely = linVelocity4.y
-#        avelz = linVelocity4.z
-#        num = -.2
-#        num2 = -.1
-#        if avelz > 0:
-#            avelz = 0
-#        avelz = avelz + num
-#                
-#        #if obj != None and sub > 30 and jump_timer < 10:
-#            #own.setLinearVelocity([avelx, avely, num2], 1)
-#        if sub < 3: 
-#            pass
-#            #own.setLinearVelocity([avelx, avely, avelz], 1) 
-            
-              
     if jump_timer < 30 :
         own['grind_jump'] = 0 
     if grindold == False and ray.triggered:
     if grindDar_timer > 0:
         grindDar_timer -= 1
     if grindDar_timer > 0 and ray.triggered == False and touched == True  and own['footplant_on'] == False and manual == 0:
-        #print("timer but ground") 
         obj = grindTouch.hitObject 
         own.worlPosition = obj.worldPosition
     if ray.triggered == False:
     own["grindDar_timer"] = grindDar_timer
     own["last_grindDar"] = last_grindDar
     linVelocity3 = own.getLinearVelocity(True)
-    #print(linVelocity3.z)
     set_pregrind_vel()
     own['last_z'] = own.worldPosition.z
     own["manual"] = manual
 
-
-
 main()