v0.1.2 freeze

Manager.py

                     own["objIndex"] -= 2
                     logic.setLogicTicRate(frame_rate*1.5)
             if b_on == True and pause_state == 0:
-                print("bbut_on")
+                #print("bbut_on")
                 own['objIndex'] = 0
                 own['valueIndex'] = 0 
                 logic.setLogicTicRate(frame_rate*1)                       
                 deck.stopAction(9999)
                 trucks.stopAction(9999)
                 cont.activate(own.actuators['replayCam'])
-                print("unbreak")
+                #print("unbreak")
                 own['loop_play'] = 0
                 #own['valueIndex'] = 0
                 #own["objIndex"] += 2
                 #own['objectIndex'] = 0
                 #print("valueIndex = ", own['valueIndex'])
         if back_on == 1 and own['back_but'] == 0:
-            print("change back state")
+            #print("change back state")
             if own['back_state'] == True:
                 own['back_state'] = False
             #elif own['back_state'] == False:
                 own['camnum'] = 0
                 cam = camList["Camera.003"]
                 scene.active_camera = cam                        
-                print("turning replay off", own['playback'])
+                #print("turning replay off", own['playback'])
                 
               
             if own['last_playback'] == False:
-                print("turning replay on", own['playback'])
+                #print("turning replay on", own['playback'])
                 cont.activate(own.actuators['add_hud'])
                 cont.activate(own.actuators['remove_stance'])
                 own['objIndex'] = 0
                 
               
                 
-        if dict['rtsBut'] == False and dict['last_rtsBut'] == True:
+        if dict['rtsBut'] == False and dict['last_rtsBut'] == True and own['playback'] == True:
             
             if 'pause' in scene_list:    
                 #cont.activate(own.actuators['remove_overlay']) 
             #print('pause_on')
             if 'pause_replay' not in scene_list:
                 cont.activate(own.actuators['pause_replay_add'])
-                print('pause_on')
+                #print('pause_on')
                 
         if pause_state != 1 and own["playback"]:
             if 'pause_replay' in scene_list:

Settings.py

     own["profile"] = int(data[12])
     dict = bge.logic.globalDict #Get the global dictionary
     
-    dict['resx'] = resx
-    dict['resy'] = resy   
+    dict['resx'] = own["resx"]
+    dict['resy'] = own["resy"]   
     level = data[5]
     level = level.split(None, 1)[0]
     level = str(level)
     dict['sun_strength'] = float(data[45])
     dict['sun_rot_x'] = float(data[46])
     dict['sun_rot_y'] = float(data[47])            
-    dict['shadow_on'] = float(data[48])
-    dict['ambient_strength'] = float(data[49])        
+    dict['shadow_on'] = int(data[48])
+    dict['ambient_strength'] = float(data[49]) 
+    dict['fullscreen_on'] = int(data[51]) 
+    dict['bloom_on'] = int(data[53])        
     
     
     
         writing.write(str("//level (e.g. spine, city, city2)")+"\n")
         writing.write(str(own["level"])+"\n")
         writing.write(str("//resolution")+"\n")
-        writing.write(str(own["resx"])+"\n")
-        writing.write(str(own["resy"])+"\n")
+        writing.write(str(dict["resx"])+"\n")
+        writing.write(str(dict["resy"])+"\n")
         writing.write(str("//show framerate")+"\n")
         writing.write(str(own["framerate"])+"\n")
         writing.write(str("//show profile")+"\n")
         writing.write(str(dict["sun_rot_x"])+"\n")                           
         writing.write(str(dict["sun_rot_y"])+"\n")                           
         writing.write(str(dict["shadow_on"])+"\n")                                     
-        writing.write(str(dict["ambient_strength"])+"\n")                             
-        
-        
-        
+        writing.write(str(dict["ambient_strength"])+"\n") 
+        writing.write(str("//fullscreen on (0,1)")+"\n")
+        writing.write(str(dict["fullscreen_on"])+"\n") 
+        writing.write(str("//bloom on (0,1)")+"\n")
+        writing.write(str(dict["bloom_on"])+"\n")         
         
         
         
         #writing.write(str(own["framerate"])+"\n")
         print("writing settings")
         writing.close()
+       
+       
+def setres():
+    import GameLogic
+    import bge
+    scenes = bge.logic.getSceneList()
+    main_scene = [scene for scene in scenes if scene.name=="main"][0]
+    own = main_scene.objects['Empty']
+    cont = GameLogic.getCurrentController()
+    own2 = cont.owner
+    dict = bge.logic.globalDict 
+    resx = dict["resx"]
+    resy = dict["resy"]
+    fullscreen = bge.render.getFullScreen()
+    print("fullscreen = ", fullscreen)
+    if fullscreen != True:
+        if dict['fullscreen_on'] == 1:
+            bge.render.setFullScreen(True)
+    if fullscreen == True:
+        if dict['fullscreen_on'] == 0:
+            bge.render.setFullScreen(False) 
+            
+    bge.render.setWindowSize(resx, resy)         
+    print("resolution = ", resx, resy)       
         
 def loadlevel():
     import GameLogic
     cont = GameLogic.getCurrentController()
     own2 = cont.owner
     #readSettings()
-    resx = own["resx"]
-    resy = own["resy"]
+
     dict = bge.logic.globalDict #Get the global dictionary
-    dict['resx'] = resx
-    dict['resy'] = resy
-    bge.render.setWindowSize(resx, resy)
-    fullscreen = bge.render.getFullScreen()
-    print("fullscreen = ", fullscreen)
-    if fullscreen != True:
-        bge.render.setFullScreen(True)
-    print("resolution = ", resx, resy)
+    
+#    resx = dict["resx"]
+#    resy = dict["resy"]
+#    #dict['resx'] = resx
+#    #dict['resy'] = resy
+#    
+#    fullscreen = bge.render.getFullScreen()
+#    print("fullscreen = ", fullscreen)
+#    if fullscreen != True:
+#        if dict['fullscreen_on'] == 1:
+#            bge.render.setFullScreen(True)
+#    if fullscreen == True:
+#        if dict['fullscreen_on'] == 0:
+#            bge.render.setFullScreen(False) 
+#            
+#    bge.render.setWindowSize(resx, resy)         
+#    print("resolution = ", resx, resy)
     #objList = scene.objects
     if own["framerate"] == 1:    
         bge.render.showFramerate(1)

co_ActionState.py

         l_actionState = 'empty'
         l_requestAction = 'empty'
     if requestAction == 'empty':
-        print("*******empty request****")
-        
+        #print("*******empty request****")
+        pass
     isplaying = skater.isPlayingAction(flip_layer)
     transPlaying = skater.isPlayingAction(trans_layer)
         
         actionState = requestAction
         own['actionState'] = requestAction 
         if l_requestAction != 'revert1' and l_requestAction != 'revert2' and l_requestAction != 'revert3' and l_requestAction != 'revert4' and l_requestAction != 'fak_revert1' and l_requestAction != 'fak_revert2' and l_requestAction != 'fak_revert3' and l_requestAction != 'fak_revert4':   
-            print("stopping revert layers")     
+            #print("stopping revert layers")     
             skater.stopAction(loop_layer)
             trucks.stopAction(loop_layer)
             deck.stopAction(loop_layer)
             
         if l_actionState == 'fak_air_tail' and requestAction in ('reg_roll', 'reg_manual', 'fak_land'):
             requestAction = 'fak_air_tail to manual'
-            print('fucking manuals')
+            #print('fucking manuals')
             
 #        if l_actionState == 'reg_air_tail' and requestAction in ('fak_roll', 'fak_manual'):
 #            requestAction = 'reg_manual'
         
         if l_actionState == 'reg_air_tail' and requestAction in ('fak_manual', 'fak_roll', 'reg_land'):
             requestAction = 'reg_air_tail to manual'
-            print('fucking manuals')
+            #print('fucking manuals')
                
 #        if l_actionState == 'reg_air_tail' and requestAction in ('fak_manual', 'fak_roll'):
 #            requestAction = 'fak_nmanual'
             
         if l_actionState == 'fak_air_nose' and requestAction in ('reg_roll', 'reg_nmanual', 'fak_land'):
             requestAction = 'fak_air_nose to nmanual'
-            print('fucking manuals')
+            #print('fucking manuals')
             
         if l_actionState == 'reg_air_nose' and requestAction in ('fak_roll', 'fak_nmanual', 'reg_land'):
             requestAction = 'reg_air_nose to nmanual'
-            print('fucking manuals') 
+            #print('fucking manuals') 
         #own['requestAction'] = requestAction
 #        if l_actionState == 'reg_air_nose' and requestAction in ('fak_nmanual', 'fak_roll', 'reg_nmanual', 'reg_roll', 'reg_manual'):
 #            requestAction == 'reg_air_nose to nmanual' 
             
 #        if l_actionState == 'fak_air_nose to nmanual' and requestAction == 'reg_nmanual':
 #            requestAction = 'fak-reg_manual'  
-#            print('this???')
+#            #print('this???')
 #        if l_actionState == 'fak-reg_manual' and requestAction == 'reg_nmanual':
 #            requestAction = 'reg_manual'                
             
 #            own['l_actionState'] = 'reg_manual'             
                                                                                                                                                         
     else:
-        print("action over written")               
+        #print("action over written") 
+        pass              
     def updateAction(requestAction, actionState):
         try:
             flip_start_frame = own['flip_start_lay']
                 skater.stopAction(trans_layer)
                 trucks.stopAction(trans_layer)
                 deck.stopAction(trans_layer)
-                print("stopping loop and trans")                                
+                #print("stopping loop and trans")                                
                 actionState = 'reg_land'
                 requestAction = 'reg_land'
                 own['actionTimer'] = 37
                 skater.playAction("reg_land", 1,20, 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)                        
-                print("play land") 
+                #print("play land") 
             if requestAction == 'fak_land' and own["grindHit"] == False:
                 actionState = 'fak_land'
                 requestAction = 'fak_land'
                 skater.playAction("fak_land", 1,20, 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)        
-                print("play land")
+                #print("play land")
 
             if requestAction == 'reg_dropin':
                 actionState = 'reg_dropin'
                 trucks.playAction("a_brfoot", 1, 30, layer=trans_layer, play_mode=0, speed=.75)
 
             if requestAction == 'reg_blfoot':
-                print("playing blfoot broke")
+                #print("playing blfoot broke")
                 actionState = 'reg_blfoot'
                 own['actionTimer'] = 40
                 skater.playAction("blfoot", 1, 30, layer=trans_layer, play_mode=0, speed=.75)
                 trucks.playAction("a_revert2", 1,10, layer=trans_layer, play_mode=0, speed=.3)                
 
             if requestAction == 'reg_ollie':
-                print("*****reg ollie act")
+                #print("*****reg ollie act")
                 actionState = 'reg_ollie'
                 own['actionState'] = 'reg_ollie'
                 own['actionTimer'] = 28           
                     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")
+                #print("fak_nosegl state")
                 if l_actionState != 'fak_nosegl' and l_actionState != 'fak_air_nose':
                     skater.stopAction(flip_layer)
                     deck.stopAction(flip_layer)
                         skater.setActionFrame(cur_frame, loop_layer)
                         deck.setActionFrame(cur_frame, loop_layer)
                         trucks.setActionFrame(cur_frame, loop_layer)
-                        print("set last walk frame", cur_frame)                                       
+                        #print("set last walk frame", cur_frame)                                       
                 #loop
                 else:
                     skater.playAction("reg_nwalk", 0,35, layer=loop_layer, play_mode=1, speed=1)

controller2.py

         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'])
+            #print("fall: ", playing_frame, own['jump_timer'])
             if STANCE == 0:
                 #own['requestAction'] = 'reg_fall1'
                 own['requestAction'] = 'reg_air-walk_air'
                 if own['manual_v2_type'] == 'fak nose manual':
                     own['manual_v2_type'] = 'reg manual'
                 if lAs == 'fak_air_tail to manual' and own['manual_v2_type'] == 'reg manual':
-                    print('---requesting reg nose manual')
+                    #print('---requesting reg nose manual')
                     own['manual_v2_type'] = 'reg nose manual' 
                 if lAs == 'fak_air_nose to nmanual' and own['manual_v2_type'] == 'reg nose manual':
-                    print('---requesting reg nose manual')
+                    #print('---requesting reg nose manual')
                     own['manual_v2_type'] = 'reg manual'                                          
             if own['jump_stance'] == 1:
-                print('flipstance 1')
+                #print('flipstance 1')
                 if own['manual_v2_type'] == 'reg manual':
                     own['manual_v2_type'] = 'fak nose manual'
                 if own['manual_v2_type'] == 'reg nose manual':
                     #print("asdfasdfasdfsdfasdfasdf")
                     own['manual_v2_type'] = 'fak manual'   
                 if lAs == 'reg_air_tail to manual' and own['manual_v2_type'] == 'fak manual':
-                    print('---requesting fak nose manual')
+                    #print('---requesting fak nose manual')
                     own['manual_v2_type'] = 'fak nose manual'
                 if lAs == 'reg_air_nose to nmanual' and own['manual_v2_type'] == 'fak nose manual':
-                    print('---requesting fak nose manual')
+                    #print('---requesting fak nose manual')
                     own['manual_v2_type'] = 'fak manual' 
                     
         if STANCE == 0 and own['manual_v2_type'] == 'fak manual':
-            print('change manual stance')
+            #print('change manual stance')
             own['manual_v2_type'] = 'reg nose manual' 
         if STANCE == 1 and own['manual_v2_type'] == 'reg manual':
-            print('change manual stance')                        
+            #print('change manual stance')                        
             own['manual_v2_type'] = 'fak nose manual'
 
         if STANCE == 0 and own['manual_v2_type'] == 'fak nose manual':
-            print('change manual stance')
+            #print('change manual stance')
             own['manual_v2_type'] = 'reg manual' 
         if STANCE == 1 and own['manual_v2_type'] == 'reg nose manual':
-            print('change manual stance')                        
+            #print('change manual stance')                        
             own['manual_v2_type'] = 'fak manual'  
             
                                       
         if zvel < 7 and jump_timer == 60:
             cont.activate(own.actuators["pop"])
             own['pop_sound'] = 1
-            print("jump")
+            #print("jump")
             #
             posx = own.worldPosition[0]
             posy = own.worldPosition[1]
             # apply force
             try:
                 if 'trans' in r_ground.hitObject:
-                    print('jump from trans')
+                    #print('jump from trans')
                     own['jump_from_trans'] = 1
                     own['trans_jump_obj'] = r_ground.hitObject
             except:
-                print('trans jump broke')
+                #print('trans jump broke')
+                pass
             if grindHit == False:
                 own.applyForce(force, local)
                 force2 = [0.0, 0, 150]
             if own["wallride"] == "R":
                 force = [0,170,0]
                 own.applyForce(force, True)
-                print("****walljumpforce R")
+                #print("****walljumpforce R")
                 cont.activate(own.actuators["pop2"])
                 jump_timer = 60
                 own['jump_timer'] = jump_timer            
             if own["wallride"] == "L":
                 force = [0,-170,0] #325
                 own.applyForce(force, True)                    
-                print("****walljumpforce L")
+                #print("****walljumpforce L")
                 cont.activate(own.actuators["pop2"])
                 jump_timer = 60
                 own['jump_timer'] = jump_timer
         outvel = own.linearVelocity
         if own["coping"] == 1:
             reg_rot = reg_rot *3
-            print('coping on')
+            #print('coping on')
         if own['gt_cd2'] > 50 and own['jump_timer'] < 20:
             if own['grind_out_type'] == 'reg right':
-                print("do 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") 
+                #print("do fak right") 
             if own['grind_out_type'] == 'reg left':
-                print("do 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") 
+                #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")
+                #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") 
+                #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")                        
+                #print("do reg fak left")                        
             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")
+                #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':
         linvelx = linVelocity.x
         lastx = own["linvelx"]
         if frames_since_ground > 20 and (abs(lastx) - abs(linvelx)) > .5:
-            print('::::::wallhit')
+            #print('::::::wallhit')
             force = (linVelocity.x * -.7, linVelocity.y, linVelocity.z )                    
             own.setLinearVelocity(force, True)        
     
         linvelx = linVelocity.x
         lastx = own["linvelx"]
         if frames_since_ground < 2 and (abs(lastx) - abs(linvelx)) > .5:
-            print('**_____________land boost')
+            #print('**_____________land boost')
             force = (lastx, linVelocity.y, linVelocity.z )                    
             own.setLinearVelocity(force, True)             
         

grindV2.py

             
     
     if grindDar.positive == False and grindTouch.positive and grindold == 0 and dropin == 0 and grind_jump == 0 and own["grindoutturn"] == 0 and gt_cd == 0 and manual == 0 and no_grind == 0 and nearestObject != lastObject and own['grindjumpturn'] == 0 and own['gt_cd2'] == 0 and own['air_mover'] == False:
-        print("touching, no dar")
+        #print("touching, no dar")
+        pass
     #print(grindold, "grindold")        
     if grindDar.positive:
         detectedObjects = grindDar.hitObjectList
             own['inverting'] = False
         grind_dist = .8#.6
         if dist < grind_dist and grindold == 0 and dropin == 0 and grind_jump == 0 and own["grindoutturn"] == 0 and gt_cd == 0 and manual == 0 and no_grind == 0 and nearestObject != lastObject and own['grindjumpturn'] == 0 and own['gt_cd2'] == 0 and invert_on == False and own['air_mover'] == False and no_grind_pull == 0:   
-            print("new grind trigger")           
+            #print("new grind trigger")           
             npos = nearestObject.worldPosition
             
             
                     if hitNormal != None:
                         stre = .05
                         own.alignAxisToVect(hitNormal, 2, stre) 
-                        print("align")                   
+                        #print("align")                   
                     own.worldPosition = [nearpos.x, nearpos.y, nearpos.z + .2975]
-                    print('moving world')
+                    #print('moving world')
 
 
             #print("grinding")

inputs.py

         if dict['joy_con'] == 0 and dict['last_joy_con'] == 1:
             if 'joy_warn' not in scenes:
                 #add scene
-                print('print add joy overlay')
+                #print('print add joy overlay')
                 cont.activate(cont.actuators['add_controller'])
         else:
             if dict['joy_con'] == 1 and dict['last_joy_con'] == 0:
                 #remove scene            
-                print('print remove joy overlay')            
+                #print('print remove joy overlay')            
                 cont.activate(cont.actuators['remove_controller'])
 #get controller axis value 0-100   
     if dict['joy_con'] == 1: 

menuV3.py

 #exit functions
 #=======
 def endpoint(funct, motion, dict, cont):
-    print('endpoint', funct,motion)
+    #print('endpoint', funct,motion)
     scene = bge.logic.getCurrentScene()
     
     scenes = bge.logic.getSceneList()
     cam = scene.objects['Camera.003']       
     c_move = .025 #color move amount  
     if funct == 'exit':
-        print("exit function", motion)
+        #print("exit function", motion)
         bge.logic.endGame()
     if funct == 'restart':
-        print("restart function", motion)  
+        #print("restart function", motion)  
         bge.logic.restartGame()      
     if funct == 'shirt color r':
         s_color = shirt.color
                 s_color_b = 0          
         new_col = [s_color[0], s_color[1], s_color_b, s_color[3]]
         shirt.color = new_col   
-        print(new_col)          
+        #print(new_col)          
         dict['shirt_color_b'] = new_col[2]
         
         
         new_col = [s_color[0], s_color[1], s_color_b, s_color[3]]
         shoeL.color = new_col   
         shoeR.color = new_col
-        print(new_col)          
+        #print(new_col)          
         dict['shoe_color_b'] = new_col[2]     
         
         
         new_col = [s_color[0], s_color[1], s_color_b, s_color[3]]
         deck.color = new_col   
         throw_deck.color = new_col
-        print(new_col)          
+        #print(new_col)          
         dict['deck_color_b'] = new_col[2]  
         
     if funct == 'shirt logo':
             cam['dof_on'] = 0
             dict['dof_on'] = 0      
             
+    if funct == 'bloom on':
+        if motion == 'inc':
+            cont.activate(cam.actuators["Bloom"])
+            cam['bloom_on'] = 1
+            dict['bloom_on'] = 1
+        else:
+            cont.activate(cam.actuators["bloom_off"])            
+            cam['bloom_on'] = 0
+            dict['bloom_on'] = 0  
+
+    if funct == 'shadow on':
+        if motion == 'inc':
+            cam['shadow_on'] = 1
+            dict['shadow_on'] = 1
+            #bge.render.setGLSLMaterialSetting("shadows", 1)                
+        else:
+            #cont.activate(cam.actuators["bloom_off"])            
+            cam['shadow_on'] = 0
+            dict['shadow_on'] = 0  
+            #bge.render.setGLSLMaterialSetting("shadows", 0)                
+
+            
+                     
         
     if funct == 'sun strength':
         b = cam['sun_strength']
             dict['load_timer'] = load_timer
             dict['reload_timer'] = 250
             dict['overlay_fadein'] = 1  
+                                         
+                                         
+#'1920x1080', '1280x720', '1024x768', '800x600', 'fullscreen'                            
+    if funct == '1920x1080':
+        #pass
+        if motion == 'inc':
+            dict['resx'] = 1920
+            dict['resy'] = 1080
+            Settings.writeSettings()
+            bge.render.setWindowSize(1920, 1080)
+#            if dict['fullscreen_on'] == 1:
+#                bge.render.setFullScreen(True)  
+#            else:
+#                bge.render.setFullScreen(False)              
+    if funct == '1280x720':
+        if motion == 'inc':
+            dict['resx'] = 1280
+            dict['resy'] = 720
+            Settings.writeSettings()
+            bge.render.setWindowSize(1280, 720)
+#            if dict['fullscreen_on'] == 1:
+#                bge.render.setFullScreen(True)  
+#            else:
+#                bge.render.setFullScreen(False)              
+    if funct == '1024x768':
+        if motion == 'inc':
+            dict['resx'] = 1024
+            dict['resy'] = 768
+            Settings.writeSettings()
+            bge.render.setWindowSize(1024, 768)
+#            if dict['fullscreen_on'] == 1:
+#                bge.render.setFullScreen(True)  
+#            else:
+#                bge.render.setFullScreen(False)              
+    if funct == '800x600':
+        if motion == 'inc':
+            dict['resx'] = 800
+            dict['resy'] = 600
+  
+            Settings.writeSettings()
+            bge.render.setWindowSize(800, 600)
+#            if dict['fullscreen_on'] == 1:
+#                bge.render.setFullScreen(True)  
+#            else:
+#                bge.render.setFullScreen(False)                
+    if funct == 'fullscreen':
+        if motion == 'inc':            
+            dict['fullscreen_on'] = 1
+            bge.render.setFullScreen(True)
+            Settings.writeSettings()
+        else:
+            dict['fullscreen_on'] = 0   
+            bge.render.setFullScreen(False)
+            Settings.writeSettings()
+                            
                                                                                     
 
 #=======
     if dict['mlevel'] == 1:
         if dict['lv0_opt'] == 'settings':
         #if opt == 'settings':
-            dict['current_list'] = ['graphics', 'player', 'level', 'camera', 'physics']
+            dict['current_list'] = ['resolution', 'graphics', 'player', 'level', 'camera', 'physics']
         if dict['lv0_opt'] == 'replay':
             dict['current_list'] = ['enter replay', 'recorder on', 'record length'] 
         if dict['lv0_opt'] == 'level':
-            dict['current_list'] = ['Demo Scene', 'Empty Lot', 'Park A', 'Training', 'Spine', 'Warehouse']     
+            dict['current_list'] = ['Demo Scene', 'Empty Lot', 'Park A', 'Training', 'Spine', 'Warehouse']  
+            
+    if dict['mlevel'] == 2:
+        if dict['lv1_opt'] == 'resolution':
+        #if opt == 'settings':
+            dict['current_list'] = ['1920x1080', '1280x720', '1024x768', '800x600', 'fullscreen']               
     if dict['mlevel'] == 2:
         if dict['lv1_opt'] == 'graphics':
         #if opt == 'settings':
-            dict['current_list'] = ['brightness / contrast', 'ao', 'hdr', 'dof']
+            dict['current_list'] = ['brightness / contrast', 'ao', 'hdr', 'dof', 'bloom']
     if dict['mlevel'] == 2:
         if dict['lv1_opt'] == 'player':
         #if opt == 'settings':
         if dict['lv2_opt'] == 'hdr':
             dict['current_list'] = ['hdr on', 'avgL', 'hdr strength']
         if dict['lv2_opt'] == 'dof':
-            dict['current_list'] = ['dof on']    
+            dict['current_list'] = ['dof on']  
+        if dict['lv2_opt'] == 'bloom':
+            dict['current_list'] = ['bloom on']                
 
 def get_inputs(dict, cont):
     #opt = dict['current_list'][dict['current_index']]
                                        
 
 def init(own, dict):
-    print('initing')
+    #print('initing')
     own['inited'] = True
     dict['lv0_opt'] = 0
     dict['lv0_index'] = 0
     dict['mlevel'] = 0
     dict['current_opt'] = ''
     dict['pause_menu_text'] = ''
-    dict['menu_end_points'] = ['exit', 'restart', 'shirt color r', 'shirt color g', 'shirt color b', 'shoe color r', 'shoe color g', 'shoe color b','deck color r', 'deck color g', 'deck color b', 'shirt logo', 'brightness / contrast on', 'brightness value', 'contrast value', 'hdr on', 'avgL', 'hdr strength', 'ao on', 'ao radius', 'ao width', 'ao only', 'dof on', 'sun strength', 'sun rot x', 'sun rot y', 'shadow on', 'ambient strength', 'Demo Scene', 'Empty Lot', 'Park A', 'Training', 'Spine', 'Warehouse']
+    dict['menu_end_points'] = ['exit', 'restart', 'shirt color r', 'shirt color g', 'shirt color b', 'shoe color r', 'shoe color g', 'shoe color b','deck color r', 'deck color g', 'deck color b', 'shirt logo', 'brightness / contrast on', 'brightness value', 'contrast value', 'hdr on', 'avgL', 'hdr strength', 'ao on', 'ao radius', 'ao width', 'ao only', 'dof on', 'sun strength', 'sun rot x', 'sun rot y', 'shadow on', 'ambient strength', 'Demo Scene', 'Empty Lot', 'Park A', 'Training', 'Spine', 'Warehouse', '1920x1080', '1280x720', '1024x768', '800x600', 'fullscreen', 'bloom on']
     
 def output(dict):
     try:
         opt = dict['current_list'][dict['current_index']]
     except:
-        print('broken!!', dict['current_list'], dict['current_index'])    
+        pass
+        #print('broken!!', dict['current_list'], dict['current_index'])    
     dict['current_opt'] = opt
     #print(dict['lv1_index'], 'level: ', dict['mlevel'], dict['lv0_opt'], dict['current_index'], dict['current_list'], dict['current_opt'])    
     outp = 'menu > '
         #print('adding end point value')
         if dict['current_opt'] == 'shirt color r':
             outp = outp + ': ' + str(dict['shirt_color_r'])
-            print(outp + ': ' + str(dict['shirt_color_r']))
+            #print(outp + ': ' + str(dict['shirt_color_r']))
         if dict['current_opt'] == 'shirt color g':
             outp = outp + ': ' + str(dict['shirt_color_g'])
         if dict['current_opt'] == 'shirt color b':
             
         if dict['current_opt'] == 'shoe color r':
             outp = outp + ': ' + str(dict['shoe_color_r'])
-            print(outp + ': ' + str(dict['shoe_color_r']))
+            #print(outp + ': ' + str(dict['shoe_color_r']))
         if dict['current_opt'] == 'shoe color g':
             outp = outp + ': ' + str(dict['shoe_color_g'])
         if dict['current_opt'] == 'shoe color b':
             outp = outp + ': ' + str(dict['shoe_color_b'])      
         if dict['current_opt'] == 'deck color r':
             outp = outp + ': ' + str(dict['deck_color_r'])
-            print(outp + ': ' + str(dict['deck_color_r']))
+            #print(outp + ': ' + str(dict['deck_color_r']))
         if dict['current_opt'] == 'deck color g':
             outp = outp + ': ' + str(dict['deck_color_g'])
         if dict['current_opt'] == 'deck color b':
         if dict['current_opt'] ==  'sun rot y':
             outp = outp + ': ' + str(dict['sun_rot_y'])                
         if dict['current_opt'] ==  'shadow on':
-            outp = outp + ': ' + str(dict['shadow_on'])  
+            #outp = outp + ': ' + str(dict['shadow_on']) 
+            outp = outp + ': (not available)'  
         if dict['current_opt'] ==  'ambient strength':
-            outp = outp + ': ' + str(dict['ambient_strength'])                          
+            outp = outp + ': ' + str(dict['ambient_strength'])   
+        if dict['current_opt'] ==  'fullscreen':
+            outp = outp + ': ' + str(dict['fullscreen_on'])  
+        if dict['current_opt'] ==  'bloom on':
+            outp = outp + ': ' + str(dict['bloom_on'])                                                 
             
     dict['pause_menu_text'] = outp
 def main(cont):

scene_init.py

         brightness = 2.6
         cam['BC_BRIGHTNESS'] = 1.3
         cam['BC_CONTRAST'] = 1.5
-    elif level == 'lot':
-        brightness = 2.6
-        cam['BC_BRIGHTNESS'] = 1
-        cam['BC_CONTRAST'] = 1   
-        #main.world.zenithColor = [1.0, .9, .975, 0]
-        #main.world.horizonColor = [.42, .555, .823, 0] 
-        curscene.world.zenithColor = [1.0, .9, .975, 0]
-        curscene.world.horizonColor = [.42, .555, .823, 0]                 
-        print("sadfasdfsdfasdfasdfasdfasdfasdf")
+#    elif level == 'lot':
+#        brightness = 2.6
+#        cam['BC_BRIGHTNESS'] = 1
+#        cam['BC_CONTRAST'] = 1   
+#        #main.world.zenithColor = [1.0, .9, .975, 0]
+#        #main.world.horizonColor = [.42, .555, .823, 0] 
+#        curscene.world.zenithColor = [1.0, .9, .975, 0]
+#        curscene.world.horizonColor = [.42, .555, .823, 0]                 
+        #print("sadfasdfsdfasdfasdfasdfasdfasdf")
     elif level == 'spine':
         brightness = 2.6
         cam['BC_BRIGHTNESS'] = .85
         #main.mistStart = 1
         #main.mistDistance = 5 
         
-    elif level == 'j_scene':
-        print('setting color of', curscene)
-        main.world.zenithColor = [1.0, .9, .975, 0]
-        main.world.horizonColor = [.42, .555, .823, 0]  
-        cam['BC_BRIGHTNESS'] = 1.35
-        cam['BC_CONTRAST'] = 1.3 
-        cam['avgL'] = .6
-        cam['HDRamount'] = .45                 
+#    elif level == 'j_scene':
+#        print('setting color of', curscene)
+#        main.world.zenithColor = [1.0, .9, .975, 0]
+#        main.world.horizonColor = [.42, .555, .823, 0]  
+#        cam['BC_BRIGHTNESS'] = 1.35
+#        cam['BC_CONTRAST'] = 1.3 
+#        cam['avgL'] = .6
+#        cam['HDRamount'] = .45                 
         #main.mistEnable = True
         #main.mistIntensity = .9
         #main.mistStart = 1
         #main.mistDistance = 5                
-    else:
-        cam['BC_BRIGHTNESS'] = dict['BC_BRIGHTNESS'] 
-        cam['BC_CONTRAST'] = dict['BC_CONTRAST']
-        cam['bc'] = dict['bc']         
-        main.world.zenithColor = [1.0, .9, .975, 0]
-        main.world.horizonColor = [.42, .555, .823, 0] 
+#    else:
+#        cam['BC_BRIGHTNESS'] = dict['BC_BRIGHTNESS'] 
+#        cam['BC_CONTRAST'] = dict['BC_CONTRAST']
+#        cam['bc'] = dict['bc']         
+        #main.world.zenithColor = [1.0, .9, .975, 0]
+        #main.world.horizonColor = [.42, .555, .823, 0] 
         #main.mistEnable = False        
     if dict['bc'] == 1:
         cont.activate(cam.actuators["bc"])
 
     else:
         cont.activate(cam.actuators["DOF_off"])
+        
+    if dict['bloom_on'] == 1:
+        cont.activate(cam.actuators["Bloom"])
+
+    else:
+        cont.activate(cam.actuators["bloom_off"])
+        
+#    print(dict['shadow_on'], 'shadow_on')    
+#    if dict['shadow_on'] == 1:
+#        bge.render.setGLSLMaterialSetting("shadows", 1) 
+#    else:
+#        bge.render.setGLSLMaterialSetting("shadows", 0)         
+        
     scene.world.envLightEnergy = dict['ambient_strength']   
     
     cam['BC_BRIGHTNESS'] = dict['BC_BRIGHTNESS'] 
     cam['sun_strength'] = dict['sun_strength']
     cam['sun_pos_x'] = dict['sun_rot_x']
     cam['sun_pos_y'] = dict['sun_rot_y']
-    cam['shadow_on'] = dict['shadow_on']    
+    #cam['shadow_on'] = dict['shadow_on']
+    cam['dof_on'] = dict['dof_on']
+    cam['bloom_on'] = dict['bloom_on']    
            
 main()