misc cleaning

controller2.py

     #scale = .3
     #action layers
     #0-14 rolling
-    #grablay = 400
     #fliplay = 500
     #grindlay = 700
     os = 'Windows'
     import math
 
     scene = bge.logic.getCurrentScene()
-    objList = scene.objects
     try:
         GameLogic.DictObjects
         init=1
 
 
     cont = GameLogic.getCurrentController() 
-    obj = bge.logic.getCurrentScene().objects
     char = bge.constraints.getCharacter
     own = cont.owner
     dict = bge.logic.globalDict #Get the global dictionary
     q6oncdl = own["Q6oncdl"]
     q7oncdl = own["Q7oncdl"]
     q8oncdl = own["Q8oncdl"]
-
+    fliplay = 4
 
     #setable
-    grablay = 600 #this plus 1
-    fliplay = 4
     MAX_VEL = dict['MAX_VEL']
     SPEEDUP = .055
     SPEEDPUMP = .14 #.09
     JUMPHEIGHT = dict['JUMPHEIGHT'] #775#750
     JUMPSTRENGTH = 0
     own['flip_manual_stance'] = 0
-    #CAVEMAN_SPEED = .75
     LAND_LAYER = 100
     LAND_END = 20
 
         if r_ground.triggered == True and skater.isPlayingAction(fliplay) and own['jump_timer'] < 40 and playing_frame < 14 and playing_frame > 3:
             own['fall'] = 1
             own['last_fall_frame'] = frame
-            #print("fall: ", playing_frame, own['jump_timer'])
             if STANCE == 0:
-                #own['requestAction'] = 'reg_fall1'
                 own['requestAction'] = 'reg_air-walk_air'
-            if STANCE == 1:
-                #own['requestAction'] = 'fak_fall1'                
+            if STANCE == 1:             
                 own['requestAction'] = 'fak_air-walk_air'
     check_fall()
+
     def check_landing():
         lf_ground = own["lF_ground"]
         STANCE = own["stance"]
                     own['manual_v2_type'] = 'fak manual' 
                     
         if STANCE == 0 and (own['manual_v2_type'] == 'fak manual' or own['actionState'] == 'fak-reg_nmanual'):
-            #print('change manual stance')
             own['manual_v2_type'] = 'reg nose manual'  
-            
         if STANCE == 1 and (own['manual_v2_type'] == 'reg manual' or own['actionState'] == 'reg-fak_nmanual'):
-            #print('change manual stance')                        
             own['manual_v2_type'] = 'fak nose manual'
-
         if STANCE == 0 and (own['manual_v2_type'] == 'fak nose manual' or own['actionState'] == 'fak-reg_manual'):
-            #print('change manual stance')
             own['manual_v2_type'] = 'reg manual' 
         if STANCE == 1 and (own['manual_v2_type'] == 'reg nose manual' or own['actionState'] == 'reg-fak_manual'):
-            #print('change manual stance')                        
             own['manual_v2_type'] = 'fak manual'               
  
     #check manual
         own["reg_manual_timer"] = timer
         if timer > 20 and rUD < .04:
             own["reg_manual"] = 0
-            #print("reg_man off")
     if rUD <= dict['man_sens_l'] and (STANCE == 1 or STANCE == 0) and rUD >= -.04:
         own["reg_manual_timer"] = 0
         own["reg_manual"] = 0 
-        #print("reg_man off2")   
     #####
     if own["reg_manual_timer"] > 10 and own["fak_manual"] == 0 and own['reg_nmanual'] == 0:
         own["reg_manual"] = 1
         playing = deck.isPlayingAction(40)
         if own["revert_timer"] < 1 and own['manual_v2'] == 0 and playing == 0:
             own['requestAction'] = 'reg_roll'
-    def reg_stance_off():
-        pass 
         
     def reg_manual_on():
         own['requestAction'] = 'reg_manual'
-  
-    def reg_manual_off():
-        pass 
         
     def fak_manual_on():
         own['requestAction'] = 'fak_manual'
- 
-    def fak_manual_off():
-        pass 
 
     def reg_nmanual_on():
         own['requestAction'] = 'reg_nmanual'   
-    def reg_nmanual_off():
-        pass
         
     def fak_nmanual_on():
-        own['requestAction'] = 'fak_nmanual'
-   
-    def fak_nmanual_off():
-        pass      
+        own['requestAction'] = 'fak_nmanual'    
         
     if own['l_actionState'] == 'reg_manual_revert_ccw':
         own['manual_v2_type'] = 'fak nose manual'
         playing = deck.isPlayingAction(40)
         if own['manual_v2'] == 0 and own["revert_timer"] < 1 and playing == 0 and own['gt_cd2'] < 1:   
             own['requestAction'] = 'fak_roll'
-    def fak_stance_off():
-        pass
         
     def fak_stance_left_on():
         if own['manual_v2'] == 0 and own["revert_timer"] < 1 and own['gt_cd2'] < 1 and ground_since > 30:
                 reg_nmanual = own['reg_nmanual']
                 fak_nmanual = own["fak_nmanual"]             
                 if LAST_STANCE != STANCE or LAST_GROUND != r_ground.triggered:
-                    fak_stance_off()
                     reg_air_off()
                     fak_air_off()
                 if reg_manual == 0 and fak_manual == 0:  
                     last_manual = own['last_reg_manual']
-                    if last_manual == 1:
-                        reg_manual_off()                   
-                        fak_manual_off()
                     reg_stance_on(inc)
                 if own['manual_v2_type'] == 'reg manual':    
                     reg_manual_on()                   
                 reg_nmanual = own['reg_nmanual']
                 fak_nmanual = own["fak_nmanual"]
                 if LAST_STANCE != STANCE or LAST_GROUND != r_ground.triggered:    
-                    reg_stance_off()
                     reg_air_off()
                     fak_air_off 
                 if fak_manual == 0:                    
                     last_manual = own['last_fak_manual']
-                    if last_manual == 1:
-                        fak_manual_off()
-                        reg_manual_off()
                     fak_stance_on(inc)                    
                 if own['manual_v2_type'] == 'fak manual':
                     fak_manual_on()
             if STANCE == 0:
                 if LAST_STANCE != STANCE or LAST_GROUND != r_ground.triggered:                
                     fak_air_off()
-                    reg_stance_off()
-                    fak_stance_off()
                     reg_stance_left_off() 
                     reg_stance_right_off()
                     fak_stance_left_off()  
                 reg_air_on()
             if STANCE == 1:
                 if LAST_STANCE != STANCE or LAST_GROUND != r_ground.triggered:
-                    reg_air_off()  
-                    reg_stance_off()
-                    fak_stance_off()  
+                    reg_air_off()   
                     reg_stance_left_off()
                     reg_stance_right_off()
                     fak_stance_left_off()  
                     fak_stance_right_off()  
                 fak_air_on()
-        if grindHit == True:
-            reg_stance_off()
-            fak_stance_off()        
+       
                            
     ###################
     #trick definitions#
     ###################
     def jump():
         #print("jump funct")
-        jump_timer = own['jump_timer']       
-        reg_manual_off()
-        fak_manual_off()
-        reg_nmanual_off()
-        fak_nmanual_off()    
+        jump_timer = own['jump_timer']          
         cont.deactivate(wallrideconstL)
         cont.deactivate(wallrideconstR) 
         own['last_jump_frame'] = frame    
         dict['trick_string'] = 'Frigid'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
             own['requestAction'] = 'reg_frigid'
-            grablay2 = grablay + 1
             GRAB_PLAYED = True
             own["GRAB_PLAYED)"] = GRAB_PLAYED
     def reg_fsonefoot_grab_on():
         dict['trick_string'] = 'FS One Foot'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
             own['requestAction'] = 'reg_fsonefoot'
-            grablay2 = grablay + 1
             GRAB_PLAYED = True
             own["GRAB_PLAYED)"] = GRAB_PLAYED
     def reg_onefoot_grab_on():
         dict['trick_string'] = 'One Foot'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
             own['requestAction'] = 'reg_onefoot'
-            grablay2 = grablay + 1
             GRAB_PLAYED = True
             own["GRAB_PLAYED)"] = GRAB_PLAYED
 
         dict['trick_string'] = 'Frigid'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
             own['requestAction'] = 'fak_frigid'
-            grablay2 = grablay + 1
             GRAB_PLAYED = True
             own["GRAB_PLAYED)"] = GRAB_PLAYED
     def fak_fsonefoot_grab_on():
         dict['trick_string'] = 'FS One Foot'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
             own['requestAction'] = 'fak_fsonefoot'
-            grablay2 = grablay + 1
             GRAB_PLAYED = True
             own["GRAB_PLAYED)"] = GRAB_PLAYED
     def fak_onefoot_grab_on():
         dict['trick_string'] = 'One Foot'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
             own['requestAction'] = 'fak_onefoot'
-            grablay2 = grablay + 1
             GRAB_PLAYED = True
             own["GRAB_PLAYED)"] = GRAB_PLAYED
 
         dict['trick_string'] = 'Judo'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
             own['requestAction'] = 'reg_judo'
-            grablay2 = grablay + 1
             GRAB_PLAYED = True
             own["GRAB_PLAYED)"] = GRAB_PLAYED
 
         dict['trick_string'] = 'Judo'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
             own['requestAction'] = 'fak_judo'
-            grablay2 = grablay + 1
             GRAB_PLAYED = True
             own["GRAB_PLAYED)"] = GRAB_PLAYED            
                 
         dict['trick_string'] = 'Mute'
         if GRAB_ON == True and GRAB_PLAYED == False and r_ground.triggered == 0:         
             own['requestAction'] = 'frontside_grab'
-            #skater.playAction("reg_fg", 10,30, layer=400, priority=5, play_mode=1, speed=.5)
-            grablay2 = grablay + 1
-
             GRAB_PLAYED = True
             own["GRAB_PLAYED)"] = GRAB_PLAYED
                 
             own['requestAction'] = 'reg_push_goof'
 
     def brfoot():
-        lay = grablay + 40
         if STANCE == 0:
             own['requestAction'] = 'reg_brfoot'
-
         if STANCE == 1:
             own['requestAction'] = 'fak_brfoot' 
         jump()   
 
     def frfoot():
-        lay = grablay + 40
         if STANCE == 0:
             own['requestAction'] = 'reg_frfoot'
         if STANCE == 1:
         jump()         
 
     def blfoot():
-        lay = grablay + 40
         if STANCE == 0:
             own['requestAction'] = 'reg_blfoot'
         if STANCE == 1:
         jump() 
 
     def flfoot():
-        lay = grablay + 40
         if STANCE == 0:
             own['requestAction'] = 'reg_flfoot'
         if STANCE == 1:
             own['powerslide_on'] = 0
             own['powerslide_counter'] = 0
             if own['last_powerslide_on'] == 0:    
-                own['powerslide'] = None
-    def killmanuals():
-        if own['last_manual_v2'] == 1 and own['manual_v2'] == 0:    
-            fak_manual_off()
-            reg_manual_off()                
-            fak_nmanual_off()
-            reg_nmanual_off()                
+                own['powerslide'] = None              
 
     def killopos():
         pass    
     check_powerslide()
     powerslide_state()
     powerslide_sound()
-    killmanuals()
     killopos()
     grind()
     #onboard()    
         lq6on = 1
         q6oncdl = countdown
         own["Q6oncdl"] = q6oncdl
-        #print("lq6on")
     elif q6oncdl > 0:
         lq6on = 0
         q6oncdl = q6oncdl - 1
         lq8on = 1
         q8oncdl = countdown
         own["Q8oncdl"] = q8oncdl
-        #print("lq8on")
     elif q8oncdl > 0:
         lq8on = 0
         q8oncdl = q8oncdl - 1
         lq2on = 1
         q2oncdl = countdown
         own["Q2oncdl"] = q2oncdl
-        #print("lq2on")
     elif q2oncdl > 0:
         lq2on = 0
         q2oncdl = q2oncdl - 1
         lq4on = 1
         q4oncdl = countdown
         own["Q4oncdl"] = q4oncdl
-        #print("lq4on")
     elif q4oncdl > 0:
         lq4on = 0
         q4oncdl = q4oncdl - 1
         lq5on = 1
         q5oncdl = countdown
         own["Q5oncdl"] = q5oncdl
-        #print("lq5on")
     elif q5oncdl > 0:
         lq5on = 0
         q5oncdl = q5oncdl - 1
     if lUD < -0.070 and lq8on !=1 and lq2on != 1:
         lq1on = 1
         q1oncdl = countdown
-        own["Q1oncdl"] = q1oncdl
-        #print("lq1on")              
+        own["Q1oncdl"] = q1oncdl           
     elif q1oncdl > 0:
         lq1on = 0
         q1oncdl = q1oncdl - 1
     if lLR < -0.070 and lq8on != 1 and lq6on != 1:
         lq7on = 1
         q7oncdl = countdown
-        own["Q7oncdl"] = q7oncdl
-        #print("lq7on")       
+        own["Q7oncdl"] = q7oncdl     
     elif q7oncdl > 0:
         lq7on = 0
         q7oncdl = q7oncdl - 1
         lq3on = 1
         q3oncdl = countdown
         own["Q3oncdl"] = q3oncdl
-        #print("lq3on") 
     elif q3oncdl > 0:
         lq3on = 0
         q3oncdl = q3oncdl - 1
         own["Q3oncdl"] = q3oncdl       
-    #34567
+
     own['set_revert_timer'] = 0
     ground_since = own["framenum"] - own['lF_air_frame']
     if ground_since > 80 and frames_since_grinding > 40:
         q1on = 0
         q1oncd = q1oncd - 1
         own["Q1oncd"] = q1oncd
-        own["last_nOpos"] = False   
-    #print(q1oncd)       
+        own["last_nOpos"] = False      
     #q7
     if rLR < -0.070:
         if q8on == 0 and q6on == 0:
             q7on = 1
             q7oncd = countdown
-            own["Q7oncd"] = q7oncd
-            #print("q7on")
-           
+            own["Q7oncd"] = q7oncd           
     elif q7oncd > 0:
         q7on = 0
         q7oncd = q7oncd - 1
         q6oncd = 0
         q7oncd = 0
         q8oncd = 0 
-    # 360 flip
-    # 3 > 4 > 5 > 8
-
-    # laser flip
-    # 7 > 6 > 5 > 2  
 
     #nollie 360 shuvit
     if q7oncd > 0 and q8oncd > 0 and q1oncd > 0 and q2oncd > 0 and q3oncd > 0 and q7oncd <= q8oncd <= q1oncd <= q2oncd <= q3oncd:
     if q7oncd > 0 and q1oncd > 0 and q8oncd > 0 and q1oncd <= q8oncd <= q7oncd:# and q3oncd == 0:
         nollie_shuvit()
         print('nollie shuvit')
-        #nollie_fsshuvit()
         reset_rtimers()   
         q1oncd = 0
         q2oncd = 0
         q5oncd = 0
         q6oncd = 0
         q7oncd = 0
-        q8oncd = 0 
-    #360 shuvit
-
-    # 360 shuvit
-    # 3 > 4 > 5 >6 > 7
-
-    # fs 360 shuvit
-    # 7 > 6 > 5 > 4 > 3     
+        q8oncd = 0     
 
     def hippy_jump():
         STANCE = own["stance"]
 
     hippy_jump()    
     if ((since_a > cush and aBut == 1 and lasta == 1) or dict['kb_ua'] == 2) and (lTrig < 0.02 and rTrig < 0.02) and own['last_hippy'] == 0:
-        #print('push')
         if xBut == 0 and hippy == 0 and (lastaBut_ground == True or dict['kb_ua'] == 2):
             push()
     if since_x > cush and xBut == 1 and lastx == 1 and (lTrig < 0.02 and rTrig < 0.02) and own['last_hippy'] == 0:
             if STANCE == False:
                 reg_frigid_grab_on()        
             else:
-                fak_judo_grab_on()                  
-                
-                
-                           
+                fak_judo_grab_on()                                      
 
     #backside grab
     if lTrig > 0.02 and r_ground.triggered == 0 and flipping == False:    
                 reg_onefoot_grab_on()        
             else:
                 fak_frigid_grab_on()                    
-                 
-#        else:
-#            if STANCE == False:
-#                reg_judo_grab_on()
-#            elif STANCE == True:
-#                fak_judo_grab_on()            
                                             
             
     #kill grabs        
         own.actuators["sroll"].volume = .0001
         cont.deactivate(own.actuators["sroll"])
         own.actuators["sroll"].stopSound()
-    if stBut == False and own['last_stBut'] == True:
+    if (stBut == False and dict['last_stBut'] == True) or dict['kb_en'] == 1:
         if own['pause_on'] == True:
             own['pause_on'] = False   
         else:
             own['pause_on'] = True           
-        
-    own['last_stBut'] = stBut
          
     def ylimit():
         lgf = own['last_grind_frame']
     def move_followcam():
         if own['camera'] == 2:
             #if rtsBut == False and own['lastrts'] == True:
-            if own['lastbkBut'] == True and bkBut == False:
+            if dict['last_bkBut'] == True and bkBut == False:
                 #print("activate move followcam") 
                 if own['move_followcam'] == False:
                     own['move_followcam'] = True
                     cont.deactivate(followcam.actuators["rotright"])                       
     def move_flycam():
         if own['camera'] == 1:
-            if own['lastbkBut'] == True and bkBut == False: 
+            if dict['last_bkBut'] == True and bkBut == False: 
                 if own['move_freecam'] == False:
                     own['move_freecam'] = True
                 else:
         if grindHit == False:
             cont.deactivate(own.actuators['grindoutRight'])
             cont.deactivate(own.actuators['grindoutLeft'])  
-        #ground_since = own["framenum"] - own['lF_air_frame'] 
         if (grindHit == True and jumping == None and sincegrinding > 20 and ground_since > 20)or own['invert_on'] == True and own['last_grind'] == 1:
             outloc = 0.022
             bsoutloc = .07
         outvel = own.linearVelocity
         if own["coping"] == 1:
             reg_rot = reg_rot *3
-            #print('coping on')
         if own['gt_cd2'] > 50 and own['jump_timer'] < 20:
             if own['grind_out_type'] == 'reg right':
-                #print("do reg right")
                 own.applyMovement([0,reg_move,0], True)
                 own.applyRotation([0,0,-reg_rot],True)
             if own['grind_out_type'] == 'fak right':
                 own.applyMovement([0,-reg_move,0], True)
                 own.applyRotation([0,0,-reg_rot],True)
-                #print("do fak right") 
             if own['grind_out_type'] == 'reg left':
-                #print("do reg left")
                 own.applyMovement([0,-reg_move,0], True)
                 own.applyRotation([0,0,reg_rot],True)           
             if own['grind_out_type'] == 'fak left':
                 own.applyMovement([0,reg_move,0], True)
                 own.applyRotation([0,0,reg_rot],True)
-                #print("do fak left") 
             if own['grind_out_type'] == 'reg fak right':
                 if own['gt_cd2'] > 55:
                     own.applyMovement([0,reg_move2,0], True)
                 own.applyRotation([0,0,reg_rot2],True)            
-                #print("do reg fak right")
             if own['grind_out_type'] == 'fak fak right':
                 if own['gt_cd2'] > 55:
                     own.applyMovement([0,-reg_move2,0], True)
                 own.applyRotation([0,0,reg_rot2],True)            
-                #print("do fak fak right") 
             if own['grind_out_type'] == 'reg fak left':
                 if own['gt_cd2'] > 55:
                     own.applyMovement([0,-reg_move2,0], True)
-                own.applyRotation([0,0,-reg_rot2],True)             
-                #print("do reg fak left")                        
+                own.applyRotation([0,0,-reg_rot2],True)                                
             if own['grind_out_type'] == 'fak fak left':
                 if own['gt_cd2'] > 55:
                     own.applyMovement([0,reg_move2,0], True)
                 own.applyRotation([0,0,-reg_rot2],True)            
-                #print("do fak fak left")
             if own['grind_out_type'] == 'reg right' or own['grind_out_type'] == 'reg left' or own['grind_out_type'] == 'fak right' or own['grind_out_type'] == 'fak left':   
                 own.setLinearVelocity([outvel.x * 1.01, outvel.y, outvel.z], True)
             if own['grind_out_type'] == 'reg fak right' or own['grind_out_type'] == 'reg fak left' or own['grind_out_type'] == 'fak fak right' or own['grind_out_type'] == 'fak fak left':
                         STANCE = False
             if own['grind_out_type'] == 'bs reg back' or own['grind_out_type'] == 'bs fak forward':
                 if own['gt_cd2'] > 50:
-                    #print('a')
                     if STANCE == True:
                         own.applyForce([bsforce, 0, 0], True)
                     if STANCE == False:
                     own.applyMovement([bs_dloc,0,0], True)    
             if own['grind_out_type'] == 'bs fak back' or own['grind_out_type'] == 'bs reg forward':
                 if own['gt_cd2'] > 50:
-                    #print('b')
                     if STANCE == True:
                         own.applyForce([-bsforce, 0, 0], True)
                     if STANCE == False:
             cont.deactivate(wallrideconstR)   
 
     def wallride_sound():
-        
         sact = own.actuators["wallSound"]
         if own["wallride"] != None and (own['actionState'] == 'reg_wall_r' or own['actionState'] == 'reg_wall_l' or own['actionState'] == 'fak_wall_r' or own['actionState'] == 'fak_wall_l'):
             sact.volume = .2
             own["Q5oncd"] = 0
             own["Q6oncd"] = 0
             own["Q7oncd"] = 0
-            own["Q8oncd"] = 0  
+            own["Q8oncd"] = 0 
+
     def grindout_cleanup():             
         lgf = own['last_grind_frame']
+
     def trans_jump():
         if own['jump_from_trans'] == 1:
             ground_ray = cont.sensors['ground_look']                        
             jump_obj = own['trans_jump_obj']
             jump_obj = scene.objects[str(own['trans_jump_obj'])]
-            #print(jump_obj)
             worldVect = [1, 0, 0]
             vect = jump_obj.getAxisVect(worldVect)      
             go = jump_obj.worldOrientation
 
     def air_mover():
         if r_ground.triggered == False and jump_timer > 53 and frames_since_grinding > 50:
-            #if grindDar2.positive:
-                #print('grinddaring')
             if lUD > 0.075:
                 if STANCE == 0:
                     force2 = [120, 0, 10]
-                    #own.applyRotation([0,.5,0], True)
                 if STANCE == 1:
                     force2 = [-120, 0, 10]            
-                
                 own.applyForce(force2, True)
                 own['no_grind_pull'] = 1
         if r_ground.triggered == False and jump_timer > 53 and frames_since_grinding > 50:
-            #if grindDar2.positive:
-                #print('grinddaring')
             if lUD < -0.075:
-#                if STANCE == 0:
-#                    force2 = [-120, 0, 10]
-#                    #own.applyRotation([0,.5,0], True)
-#                if STANCE == 1:
-#                    force2 = [120, 0, 10]            
-#                
-#                own.applyForce(force2, True)
                 own['no_grind_pull'] = 1                
         if r_ground.triggered == False and jump_timer > 10 and lUD > 0.075 and frames_since_grinding > 50:
             if STANCE == 0:
                 force2 = [7, 0, 10]
             if STANCE == 1:
                 force2 = [-7, 0, 10]            
-            
             own.applyForce(force2, True)
             own.applyForce([0,0,5], False)
             own['air_mover'] = True
     own['lastrts'] = rtsBut
     own["lF_ground2"] = own["lF_ground"]
     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.applyForce(force2, True)
     if (grindDar == False and r_ground.triggered and own['grindTouch'] == False) or own['jump_timer'] > 40:
         own['grindType'] = ''
-        
-    #print('q1:', q1oncd, 'q2:', q2oncd, 'q3:', q3oncd, 'q4:', q4oncd, 'q5:', q5oncd, 'q6:', q6oncd, 'q7:', q7oncd, 'q8:', q8oncd)   
     
     dict['walk'] = 0  

menuV3.py

     if dict['mlevel'] == 1:
         if dict['lv0_opt'] == 'settings':
         #if opt == 'settings':
-            dict['current_list'] = ['resolution', 'graphics', 'player', 'level', 'camera', 'physics']
+            dict['current_list'] = ['resolution', 'graphics', 'player', 'deck', 'level', 'camera', 'physics']
         if dict['lv0_opt'] == 'replay':
             dict['current_list'] = ['enter replay (press back button)', 'recorder on', 'record length (n/a)'] 
         if dict['lv0_opt'] == 'level':
     if dict['mlevel'] == 2:
         if dict['lv1_opt'] == 'player':
         #if opt == 'settings':
-            dict['current_list'] = ['character', 'shirt color r', 'shirt color g', 'shirt color b', 'shirt logo', 'shoe color r', 'shoe color g', 'shoe color b', 'deck graphic', 'deck color r', 'deck color g', 'deck color b', 'trucks color r', 'trucks color g', 'trucks color b', 'wheel color r', 'wheel color g', 'wheel color b', 'wheel1 color r', 'wheel1 color g', 'wheel1 color b', 'wheel2 color r', 'wheel2 color g', 'wheel2 color b', 'wheel3 color r', 'wheel3 color g', 'wheel3 color b', 'wheel4 color r', 'wheel4 color g', 'wheel4 color b']            
+            dict['current_list'] = ['character', 'shirt color r', 'shirt color g', 'shirt color b', 'shirt logo', 'shoe color r', 'shoe color g', 'shoe color b'] 
+    if dict['mlevel'] == 2:
+        if dict['lv1_opt'] == 'deck':
+        #if opt == 'settings':
+            dict['current_list'] = ['deck graphic', 'deck color r', 'deck color g', 'deck color b', 'trucks color r', 'trucks color g', 'trucks color b', 'wheel color r', 'wheel color g', 'wheel color b', 'wheel1 color r', 'wheel1 color g', 'wheel1 color b', 'wheel2 color r', 'wheel2 color g', 'wheel2 color b', 'wheel3 color r', 'wheel3 color g', 'wheel3 color b', 'wheel4 color r', 'wheel4 color g', 'wheel4 color b']                        
 
     if dict['mlevel'] == 2:
         if dict['lv1_opt'] == 'level':