bunch o crap

Manager.py

         udPad = dict['udPad']
         ddPad = dict['ddPad']    
             
-        
+        try:
+            pause_state = dict['npause']
+            last_pause = dict['last_npause']
+        except:
+            dict['npause'] = 0
+            dict['last_npause'] = 0
+            pause_state = 0
+            last_pause = 0          
            
         #trigs results range 0 - .08
         #print(lTrig, rTrig)
                 else:    
                     own["objIndex"] -= 2
                     logic.setLogicTicRate(frame_rate*1.5)
-            if b_on == True:
+            if b_on == True and pause_state == 0:
                 print("bbut_on")
                 own['objIndex'] = 0
                 own['valueIndex'] = 0 
                 cont.activate(own.actuators['remove_stance'])
                 own['objIndex'] = 0
                 own['valueIndex'] = 3
-                logic.setLogicTicRate(frame_rate*1)               
-                 
+                logic.setLogicTicRate(frame_rate*1)  
+                
+                
+              
+                
+        if dict['rtsBut'] == False and dict['last_rtsBut'] == True:
+            
+            if 'pause' in scene_list:    
+                #cont.activate(own.actuators['remove_overlay']) 
+                cont.activate(own.actuators['add_hud'])
+            else:
+                #cont.activate(own.actuators['add_overlay']) #pause
+                cont.activate(own.actuators['remove_hud']) #replay 
+                cont.activate(own.actuators['pause_replay_remove']) 
+                                            
+        if pause_state == 1 and last_pause == 1 and own["playback"]:
+            #print('pause_on')
+            if 'pause_replay' not in scene_list:
+                cont.activate(own.actuators['pause_replay_add'])
+                print('pause_on')
+                
+        if pause_state != 1 and own["playback"]:
+            if 'pause_replay' in scene_list:
+                cont.activate(own.actuators['pause_replay_remove'])                    
+        if own['playback'] and 'pause' in scene_list:
+            cont.activate(cube.actuators['remove_overlay'])                         
                              
     ####
-        if a_on == 1 and own['a_but'] == False:
+        if a_on == 1 and own['a_but'] == False and pause_state == 0:
             if own['loop_play'] == 1:
                 own['loop_play'] = 0
             else:
         own['a_but'] = a_on
         own['last_ltsBut'] = ltsBut
         own['last_rtsBut'] = rtsBut
-        own['last_playback'] = own['playback']
+        own['last_playback'] = own['playback']
+        dict['playback'] = own['playback']

Record.py

 wheel3 = scene.objects["rollen.002"]
 wheel4 = scene.objects["rollen.003"]
 
+try:
+    throw_deck = scene.objects['throw_deck']
+except:
+    throw_deck = None    
 
 deckact = deck.actuators["Visibility"]
 trucksact = trucks.actuators["Visibility"]
 
 
     def savePosition(obj, cut):
-        
         position = [Vector(obj.worldPosition)[0],
             Vector(obj.worldPosition)[1],
             Vector(obj.worldPosition)[2]]
         position = str(position).strip("[]")
         position = position.replace(", ",",")
-       
         writeData.addPosition(obj, position, cut)
      
-    def saveOrientation(obj, cut):
-            
+    def saveOrientation(obj, cut): 
         orientation = [Vector(obj.localOrientation.to_euler())[0],
             Vector(obj.localOrientation.to_euler())[1],
             Vector(obj.localOrientation.to_euler())[2]]
         orientation = str(orientation).strip("[]")
-        orientation = orientation.replace(", ",",")
-                
+        orientation = orientation.replace(", ",",")     
         writeData.addOrientation(obj, orientation, cut)
                     
-    def saveScale(obj, cut):
-        
+    def saveScale(obj, cut):  
         scale = [Vector(obj.localScale)[0],
             Vector(obj.localScale)[1],
             Vector(obj.localScale)[2]]
         scale = str(scale).strip("[]")
         scale = scale.replace(", ",",")
-         
         writeData.addScale(obj, scale, cut)
-        
     def saveColor(obj, cut):
-        
         color = [Vector(obj.color)[0],
             Vector(obj.color)[1],
             Vector(obj.color)[2],
             Vector(obj.color)[3]]
         color = str(color).strip("[]")
         color = color.replace(", ",",")
-        
         writeData.addColor(obj, color, cut)
-        
     def saveState(obj, cut):
         
         state = str(obj.state)
         writeData.addState(obj, state, cut)
         
     def saveVisibility(obj, cut):
-        
         visible = obj.visible
-        
         if visible:
             visible = 1
         else:
-            visible = 0
-            
+            visible = 0   
         writeData.addVisibility(obj, str(visible), cut)
     
     def saveSkaterAnim(obj, cut):
         writeData.addSlandsound(obj, str(num), cut) 
     def saveSdeckvis(obj, cut):
         num = cube['deckvis']
-        writeData.addSdeckvis(obj, str(num), cut)                                                                
+        writeData.addSdeckvis(obj, str(num), cut)  
+        
+    def savetdPosition(obj, cut):
+        try:
+            obj = scene.objects['throw_deck']
+        except:
+            pass    
+        position = [Vector(obj.worldPosition)[0],
+            Vector(obj.worldPosition)[1],
+            Vector(obj.worldPosition)[2]]
+        position = str(position).strip("[]")
+        position = position.replace(", ",",")
+        writeData.addtdPosition(obj, position, cut)
+     
+    def savetdOrientation(obj, cut): 
+        try:
+            obj = scene.objects['throw_deck']
+        except:
+            pass
+        orientation = [Vector(obj.localOrientation.to_euler())[0],
+            Vector(obj.localOrientation.to_euler())[1],
+            Vector(obj.localOrientation.to_euler())[2]]
+        orientation = str(orientation).strip("[]")
+        orientation = orientation.replace(", ",",")     
+        writeData.addtdOrientation(obj, orientation, cut)
+    def saveSrevertsound(obj, cut):
+        num = cube['revert_sound']
+        writeData.addSrevertsound(obj, str(num), cut)                                                                               
               
 def loadData():
     
     loadedSgrind_railPitch = own["loadedSgrind_railPitch"] 
     loadedSpopsound = own["loadedSpopsound"]            
     loadedSlandsound = own["loadedSlandsound"] 
-    loadedSdeckvis = own["loadedSdeckvis"]    
+    loadedSdeckvis = own["loadedSdeckvis"]  
+    loadedtdPosition = own["loadedtdPosition"]
+    loadedtdOrientation = own["loadedtdOrientation"]      
+    loadedSrevertsound = own["loadedSrevertsound"] 
     
     skater = scene.objects["Char4"]
     deck = scene.objects["deck"]
     own["lengthOri"] = readData.getLengthOri()   
     lengthOri = own["lengthOri"]
     
-    if lengthPos:
+    #if lengthPos:
+    if lengthOri:
   
         if valueIndex > lengthOri-1:
             own["valueIndex"] = 0
             own["objIndex"] = lengthSpopsound-2
         name, spopsound = readData.returnSpopsound(objIndex, valueIndex)   
         if name in scene.objects:
+            #act = sound_empty.actuators["pop"]
             try:
                 #cube = scene.objects[sound_empty]
                 spopsound = round(spopsound, 2)
                 act = cube.actuators["pop"]
+                #act = sound_empty.actuators["pop"]
                 if spopsound == 1:
+                    #act.volume_maximum = .7
+                    #act.is3D = True
+                    #act.distance_reference = 10.0
+                    #act.distance_maximum = 50.0
+                    act.volume = .6
                     act.startSound()
                 #print("grindsound = ", spopsound, sgrind_railPitch)
             except:
                 slandsound = round(slandsound, 2)
                 act = cube.actuators["land"]
                 if slandsound == 1:
+                    act.volume = .6
                     act.startSound()
                 #print("grindsound = ", slandsound, sgrind_railPitch)
             except:
         if name in scene.objects:
             try:
                 cube = scene.objects["control_cube.002"]
-                #slandsound = round(slandsound, 2)
                 if sdeckvis == 1:
-                    print('setting deck visible')
-                    #wheel1.visible = True
-                    #wheel2.visible = True
-                    #wheel3.visible = True
-                    #wheel4.visible = True 
-                    #deck.visible = True
-                    #trucks.setVisible(True, True)
-                    
-                    
+                    #print('setting deck visible')
                     deckact.visibility = True
                     trucksact.visibility = True
                     wheel1act.visibility = True
                     cont.activate(wheel1.actuators['Visibility'])
                     cont.activate(wheel2.actuators['Visibility'])
                     cont.activate(wheel3.actuators['Visibility'])
-                    cont.activate(wheel4.actuators['Visibility'])                     
-                               
+                    cont.activate(wheel4.actuators['Visibility'])  
+                    for n in scene.objects:
+                        if 'throw_deck' in n.name and 'empty' not in n.name:
+                            n.endObject() 
+#                    if 'throw_deck' in scene.objects:
+                            #print('ending td', n)
+                            cont.activate(throw_deck.actuators['end_throw_deck'])                   
+                     
+                    #throwdeck.visibility = False                               
                 else:
-                    print('setting deck invisible')
-                    #wheel1.visible = False
-                    #wheel2.visible = False
-                    #wheel3.visible = False
-                    #wheel4.visible = False
-                    #deck.visible = False
-                    #trucks.setVisible(False, False)
-
+                    #print('setting deck invisible')
                     deckact.visibility = False
                     trucksact.visibility = False
                     wheel1act.visibility = False
                     cont.activate(wheel1.actuators['Visibility'])
                     cont.activate(wheel2.actuators['Visibility'])
                     cont.activate(wheel3.actuators['Visibility'])
-                    cont.activate(wheel4.actuators['Visibility'])                     
+                    cont.activate(wheel4.actuators['Visibility'])  
+                    #if throw_deck == None:
+                    if 'throw_deck' not in scene.objects:
+                        #print('no throwdeck')
+                        #cont.deactivate(throw_deck.actuators['end_throw_deck']) 
+                        #throw_deck_empty.wordPosition.z = throw_deck_empty.wordPosition.z + 1
+                        cont.activate(throw_deck_empty.actuators['throw_dec_act']) 
+                        #scene.addObject('throw_deck')
+                    #throwdeck.visibility = True
+                    throw_deck.suspendDynamics()
 
+            except:
+                pass
+##    
+    #-----Position-----#
+    own["lengthtdPos"] = readData.getLengthtdPos()
+    lengthPos = own["lengthtdPos"] 
+    
+    if lengthPos:
+        
+        if objIndex > lengthPos-1:
+            own["objIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthPos-2
+
+        name, position = readData.returntdPosition(objIndex, valueIndex)
+        name = 'throw_deck'
+        if name in scene.objects:
+            try:
+                scene.objects[name].worldPosition = position
+                #print('recording tdPos', position)
+            except:
+                pass
+    #-----Orientation-----#
+    own["lengthtdOri"] = readData.getLengthtdOri()   
+    lengthOri = own["lengthtdOri"]
+    
+    #if lengthPos:
+    if lengthOri:
+  
+        if valueIndex > lengthOri-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthOri-2
 
+        name, orientation = readData.returntdOrientation(objIndex, valueIndex)
+        name = 'throw_deck'
+        if name in scene.objects:
+            
+            oXYZ = scene.objects[name].localOrientation.to_euler()
 
+            oXYZ[0] = float(orientation[0])
+            oXYZ[1] = float(orientation[1])
+            oXYZ[2] = float(orientation[2])
+            
+            try:
+                #print('recording tdOri')
+                scene.objects[name].localOrientation = oXYZ.to_matrix()
             except:
                 pass
-##    
+
+#
+    #-----revert sound-----#
+    own["lengthSrevertsound"] = readData.getLengthSrevertsound()
+    lengthSrevertsound = own["lengthSrevertsound"]
+    if lengthSrevertsound:
+        if valueIndex > lengthSrevertsound-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthSrevertsound-2
+        name, srevertsound = readData.returnSrevertsound(objIndex, valueIndex)   
+        if name in scene.objects:
+            try:
+                #cube = scene.objects[sound_empty]
+                srevertsound = round(srevertsound, 2)
+                act = cube.actuators["revertSound"]
+                if srevertsound == 1:
+                    act.startSound()
+                #print("grindsound = ", spopsound, sgrind_railPitch)
+            except:
+                print("sound passed")
+                pass
 
                                             
                        
         getData.saveSgrind_railPitch(obj, recording_cutoff)
         getData.saveSpopsound(obj, recording_cutoff)            
         getData.saveSlandsound(obj, recording_cutoff) 
-        getData.saveSdeckvis(obj, recording_cutoff)                               
+        getData.saveSdeckvis(obj, recording_cutoff) 
+        getData.savetdPosition(obj, recording_cutoff)
+        getData.savetdOrientation(obj, recording_cutoff)
+        getData.saveSrevertsound(obj, recording_cutoff)                                       
             
          
 def breakOut():

Settings.py

     print("Game play recorder on: ", recorder_on) 
     #dict = bge.logic.globalDict
     dict['recorder_on'] = recorder_on
-    own['recorder_on'] = recorder_on    
+    own['recorder_on'] = recorder_on  
+    dict["shirt_color_r"] = float(data[16])
+    dict["shirt_color_g"] = float(data[17])
+    dict["shirt_color_b"] = float(data[18])
+    dict["shoe_color_r"] = float(data[20])
+    dict["shoe_color_g"] = float(data[21])
+    dict["shoe_color_b"] = float(data[22]) 
+    dict["deck_color_r"] = float(data[24])
+    dict["deck_color_g"] = float(data[25])
+    dict["deck_color_b"] = float(data[26]) 
+    dict["shirt_logo"] = int(data[28])  
+    dict["bc"] = int(data[30])
+    dict["BC_BRIGHTNESS"] = float(data[31])
+    dict["BC_CONTRAST"] = float(data[32])  
+    dict['hdr'] = int(data[34])
+    dict['avgL'] = float(data[35])
+    dict['HDRamount'] = float(data[36])
+    dict['ao'] = int(data[38])
+    dict['onlyAO'] = int(data[39])
+    dict['aowidth'] = float(data[40])
+    dict['aoradius'] = float(data[41])
+    dict['dof_on'] = float(data[43])
+    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])        
+    
+    
+    
+    
+    #print('bc = ', dict['bc'])        
+    #dict['music_player_on'] = int(data[16])  
 def writeSettings():
     import GameLogic
     import bge
     cont = GameLogic.getCurrentController()
     own = cont.owner
     scenes = bge.logic.getSceneList()
+    dict = bge.logic.globalDict
     main_scene = [scene for scene in scenes if scene.name=="main"][0]
     own = main_scene.objects['Empty']
     print("writing called")
         writing.write(str("//show profile")+"\n")
         writing.write(str(own["profile"])+"\n")
         writing.write(str("//Game play recorder off/on (0,1)")+"\n")
-        writing.write(str(own["recorder_on"])+"\n")        
+        writing.write(str(own["recorder_on"])+"\n") 
+        writing.write(str("//Shirt color [r,g,b]")+"\n")
+        writing.write(str(dict["shirt_color_r"])+"\n") #16
+        writing.write(str(dict["shirt_color_g"])+"\n")
+        writing.write(str(dict["shirt_color_b"])+"\n")    # 
+        writing.write(str("//Shoe color [r,g,b]")+"\n")
+        writing.write(str(dict["shoe_color_r"])+"\n") #16
+        writing.write(str(dict["shoe_color_g"])+"\n")
+        writing.write(str(dict["shoe_color_b"])+"\n")    # 
+        writing.write(str("//Deck color [r,g,b]")+"\n")
+        writing.write(str(dict["deck_color_r"])+"\n") #24
+        writing.write(str(dict["deck_color_g"])+"\n")
+        writing.write(str(dict["deck_color_b"])+"\n")    #                           
+        writing.write(str("//Shirt Logo")+"\n")
+        writing.write(str(dict["shirt_logo"])+"\n") #24
+        writing.write(str("//Brightness/Contrast: On, brightness, contrast")+"\n")
+        writing.write(str(dict["bc"])+"\n")
+        writing.write(str(dict["BC_BRIGHTNESS"])+"\n")
+        writing.write(str(dict["BC_CONTRAST"])+"\n")
+        writing.write(str("//HDR: On, avgL, amount")+"\n")
+        writing.write(str(dict["hdr"])+"\n")
+        writing.write(str(dict["avgL"])+"\n")
+        writing.write(str(dict["HDRamount"])+"\n") 
+        writing.write(str("//AO: On, only, width, radius")+"\n")
+        writing.write(str(dict["ao"])+"\n")
+        writing.write(str(dict["onlyAO"])+"\n")
+        writing.write(str(dict["aowidth"])+"\n")                
+        writing.write(str(dict["aoradius"])+"\n") 
+        writing.write(str("//dof on")+"\n")
+        writing.write(str(dict["dof_on"])+"\n") 
+        writing.write(str("//sun settings: strength, rotx, roty, shadow on, ambient strength")+"\n")
+        writing.write(str(dict["sun_strength"])+"\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(own["framerate"])+"\n")
         print("writing settings")
         writing.close()

SortData.py

 spopsoundList = []
 slandsoundList = []
 sdeckvisList = []
+positiontdList = []
+orientationtdList = []
+srevertsoundList = []
 
 allDataList = []
 allDataPath = path+gameName+" replay.dat"
         sdeckvisList.append(sdeckvis)
         if len(sdeckvisList) >= cut and cut > 0:
             del sdeckvisList[0]
-            del sdeckvisList[0]                                                                                       
+            del sdeckvisList[0]     
+            
+    def addtdPosition(obj, pos, cut):
+        global positiontdList
+        positiontdList.append(" "+str(obj))
+        positiontdList.append(pos)
+        
+        if len(positiontdList) >= cut and cut > 0:
+            del positiontdList[0]
+            del positiontdList[0]
+        
+    def addtdOrientation(obj, ori, cut):
+        global orientationtdData
+        orientationtdList.append(" "+str(obj))
+        orientationtdList.append(ori)
+        
+        if len(orientationtdList) >= cut and cut > 0:
+            del orientationtdList[0]
+            del orientationtdList[0]  
+##
+    def addSrevertsound(obj, srevertsound, cut):
+        global srevertsoundData
+        srevertsoundList.append(" "+str(obj))
+        srevertsoundList.append(srevertsound)
+        if len(srevertsoundList) >= cut and cut > 0:
+            del srevertsoundList[0]
+            del srevertsoundList[0]                       
+                                                                                              
             
     def saveAll():
 
             " ".join(sgrind_railPitchList),
             " ".join(spopsoundList),
             " ".join(slandsoundList),
-            " ".join(sdeckvisList)]    
+            " ".join(sdeckvisList),
+            " ".join(positiontdList),
+            " ".join(orientationtdList),
+            " ".join(spopsoundList)]    
         try:
             with open(allDataPath,'w') as all:
                 all.write("|".join(allDataList))
         global sgrind_railPitchList
         global spopsoundList
         global slandsoundList 
-        global sdeckvisList                                        
+        global sdeckvisList     
+        global positiontdList
+        global orientationtdList 
+        global srevertsoundList                                          
             
         if not allDataList:
             try:
                             spopsoundList = allDataList[17].split()
                             slandsoundList = allDataList[18].split()
                             sdeckvisList = allDataList[19].split()
+                            positiontdList = allDataList[20].split()
+                            orientationtdList = allDataList[21].split()                            
+                            srevertsoundList = allDataList[22].split()
                             
                             if printDebug:
                                 print("Read file "+allDataPath)
         if positionList:
             name = positionList[objIndex-2]   #That -2 is a little workaround to a list index out of range error.
             position = positionList[valueIndex-2]
-
             name = name.replace(" ","")
-
             position = str(position)
             position = position.replace(","," ")
-
             pX = float(position.split()[0])
             pY = float(position.split()[1])
             pZ = float(position.split()[2])
-
             position = [pX,pY,pZ]
-
             return(name, position)
 
     def returnOrientation(objIndex, valueIndex):
-        
         if orientationList:
             name = orientationList[objIndex-2]
             orientation = orientationList[valueIndex-2]
-            
             name = name.replace(" ","")
-            
             orientation = str(orientation)
             orientation = orientation.replace(","," ")
             orientation = orientation.split()
-
             return(name, orientation)
 
     def returnScale(objIndex, valueIndex):
             sdeckvis = str(sdeckvis)
             sdeckvis = sdeckvis.replace(","," ")
             sdeckvis = int(sdeckvis)
-            return(name, sdeckvis)                
+            return(name, sdeckvis) 
+        
+    def returntdPosition(objIndex, valueIndex):
+        
+        if positiontdList:
+            name = positiontdList[objIndex-2]   #That -2 is a little workaround to a list index out of range error.
+            position = positiontdList[valueIndex-2]
+            name = name.replace(" ","")
+            position = str(position)
+            position = position.replace(","," ")
+            pX = float(position.split()[0])
+            pY = float(position.split()[1])
+            pZ = float(position.split()[2])
+            position = [pX,pY,pZ]
+            return(name, position)
+
+    def returntdOrientation(objIndex, valueIndex):
+        if orientationtdList:
+            name = orientationtdList[objIndex-2]
+            orientation = orientationtdList[valueIndex-2]
+            name = name.replace(" ","")
+            orientation = str(orientation)
+            orientation = orientation.replace(","," ")
+            orientation = orientation.split()
+            return(name, orientation)     
+        
+    def returnSrevertsound(objIndex, valueIndex):
+        if srevertsoundList:
+            name = srevertsoundList[objIndex-2]
+            srevertsound = srevertsoundList[valueIndex-2]
+            name = name.replace(" ","")
+            srevertsound = str(srevertsound)
+            srevertsound = srevertsound.replace(","," ")
+            srevertsound = int(srevertsound)
+            return(name, srevertsound)           
+                       
 ####                
 
     def getLengthPos():
             return(len(slandsoundList)) 
     def getLengthSdeckvis():
         if sdeckvisList:
-            return(len(sdeckvisList))                                                                                               
+            return(len(sdeckvisList))   
+    def getLengthtdPos():
+        if positiontdList:
+            return(len(positiontdList))
+    def getLengthtdOri():
+        if orientationtdList:
+            return(len(orientationtdList))
+    def getLengthSrevertsound():
+        if srevertsoundList:
+            return(len(srevertsoundList))    
+             
+                                                                                                    

Startup.py

     dict['overlay_fadeout'] = 0
     dict['load_timer'] = 0
     dict['reload_timer'] = 0
+    dict['menu_idle_timer'] = 0
     if not any(logic.joysticks):
         print("joystick not connnected")
         dict['joy_con'] = 0
     dict['mTrig'] = 0.0 
     dict['lTrig'] = 0.0
     dict['rTrig'] = 0.0 
+    #dict['shirt_color'] = [.5,1,1,1]
+    
+    dict['mu_last_track'] = ''
+    dict['mu_artist'] = ''
+    dict['mu_title'] = ''    
 
 main()

co_ActionState.py

             own['actionTimer'] = 0
             actionTimer = 0 
     #print(own['manual_v2_timer'], 'man_timer###@!')                   
-    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:
-    #if (requestAction == 'reg_land' or requestAction == 'fak_land') and own['manual_v2_timer'] > 2:
-        requestAction = own['l_requestAction']
-        print("changing land")
-        #pass
+#    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:
+#    #if (requestAction == 'reg_land' or requestAction == 'fak_land') and own['manual_v2_timer'] > 2:
+#        requestAction = own['l_requestAction']
+#        own['actionTimer'] = 5
+#        print("changing land")
+#        #pass
         
-    #dirty manual fix
-    if l_actionState == 'reg_air_tail' and requestAction == 'reg_roll':
-        requestAction = 'reg_air_tail'
-    if l_actionState == 'reg_air_nose' and requestAction == 'reg_roll':
-        requestAction = 'reg_air_nose'
-    if l_actionState == 'fak_air_tail' and requestAction == 'fak_roll':
-        requestAction = 'fak_air_tail'
-    if l_actionState == 'fak_air_nose' and requestAction == 'fak_roll':
-        requestAction = 'fak_air_nose'                
+        
+    
+        
+        
+#    #dirty manual fix
+#    if l_actionState == 'reg_air_tail' and requestAction == 'reg_roll':
+#        requestAction = 'reg_air_tail'
+#    if l_actionState == 'reg_air_nose' and requestAction == 'reg_roll':
+#        requestAction = 'reg_air_nose'
+#    if l_actionState == 'fak_air_tail' and requestAction == 'fak_roll':
+#        requestAction = 'fak_air_tail'
+#    if l_actionState == 'fak_air_nose' and requestAction == 'fak_roll':
+#        requestAction = 'fak_air_nose'                
         
     #dirt invert fix
     if 'invert' in requestAction:
         if (l_actionState == 'fak_5050_out' and requestAction == 'fak_roll') or (l_actionState in {'fak_noseg_out', 'fak_nosegr_out', 'fak_nosegl_out', 'fak_tailg_out', 'fak_tailgr_out', 'fak_tailgl_out'} and actionTimer < 10): 
             requestAction = 'fak_5050-roll'
             actionState = 'fak_5050-roll' 
+
+
+
+
+
+#####
+
+
             
-        if l_actionState == 'fak_air_tail' and requestAction in ('reg_roll', 'reg_manual'):
-            requestAction = 'fak_manual'
-        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'):
-            requestAction == 'reg_air_tail to manual'   
-        if l_actionState == 'reg_air_tail' and requestAction in ('fak_manual', 'fak_roll'):
-            requestAction = 'fak_nmanual'
+        if l_actionState == 'fak_air_tail' and requestAction in ('reg_roll', 'reg_manual', 'fak_land'):
+            requestAction = 'fak_air_tail to manual'
+            print('fucking manuals')
             
-        if l_actionState == 'fak_air_nose' and requestAction in ('reg_roll', 'reg_nmanual'):
-            requestAction = 'fak_nmanual'
-        if l_actionState == 'reg_air_nose' and requestAction in ('fak_roll', 'fak_nmanual'):
-            requestAction = 'reg_nmanual'
+#        if l_actionState == 'reg_air_tail' and requestAction in ('fak_roll', 'fak_manual'):
+#            requestAction = 'reg_manual'
         
-        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 == 'reg_air_nose' and requestAction in ('fak_nmanual', 'fak_roll'):
-            requestAction = 'fak_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')
+               
+#        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')
+            
+        if l_actionState == 'reg_air_nose' and requestAction in ('fak_roll', 'fak_nmanual', 'reg_land'):
+            requestAction = 'reg_air_nose to nmanual'
+            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 == 'reg_air_nose' and requestAction in ('fak_nmanual', 'fak_roll'):
+#            requestAction = 'fak_manual' 
+
+
+
+#        if requestAction == 'reg_nmanual' and l_requestAction in ['fak-reg_manual', 'reg_nmanual']:
+#            requestAction == 'reg_manual'
 
+
+
+####
+
+
+        #print(requestAction)
         if l_actionState == 'reg_air_tail to manual' and requestAction == 'fak_nmanual':
             requestAction = 'reg-fak_nmanual'
         if l_actionState == 'fak_air_tail to manual' and requestAction == 'reg_nmanual':
             requestAction = 'fak-reg_nmanual' 
+        if l_actionState == 'fak_air_tail to nmanual' and requestAction == 'reg_nmanual':
+            requestAction = 'fak-reg_manual'   
             
         if l_actionState == 'reg_air_nose to nmanual' and requestAction == 'fak_manual':
             requestAction = 'reg-fak_manual'
         if l_actionState == 'fak_air_nose to nmanual' and requestAction == 'reg_manual':
-            requestAction = 'fak-reg_manual'  
+            requestAction = 'fak-reg_manual' 
+            
+            
+#        if l_actionState == 'fak_air_nose to nmanual' and requestAction == 'reg_nmanual':
+#            requestAction = 'fak-reg_manual'  
+#            print('this???')
+#        if l_actionState == 'fak-reg_manual' and requestAction == 'reg_nmanual':
+#            requestAction = 'reg_manual'                
             
             
         if l_actionState == 'reg_ollie_north' and requestAction != 'reg_ollie_north':
         if l_actionState == 'fak_air_nose to nmanual' and requestAction == 'reg_roll':
             requestAction = 'fak_nmanual_out'            
         if l_actionState == 'reg_air_tail to manual' and requestAction == 'fak_roll':
-            requestAction = 'reg_nmanual_out'
+            requestAction = 'reg_manual_out'
         if l_actionState == 'fak_air_tail to manual' and requestAction == 'reg_roll':
-            requestAction = 'fak_nmanual_out'            
+            requestAction = 'fak_manual_out'            
 
         if l_actionState == 'frontside_grab' and requestAction != 'frontside_grab':
             requestAction = 'frontside_grab_out'
         if requestAction in ('fak_roll', 'reg_roll') and l_actionState in ('fak_ollie_north_out', 'fak_ollie_north', 'fak_ollie_south_out', 'fak_ollie_south', 'fak_backside_grab', 'fak_frontside_grab', 'fak_frontside_nose_grab', 'fak_frontside_tail_grab', 'fak_backside_nose_grab', 'fak_backside_tail_grab', 'fak_backside_grab_out', 'fak_frontside_grab_out', 'fak_frontside_nose_grab_out', 'fak_frontside_tail_grab_out', 'fak_backside_nose_grab_out', 'fak_backside_tail_grab_out', 'fak_judo_out') and actionTimer < 2:
             requestAction = 'fak_land'  
 
-        if l_actionState in ('reg_air_tail', 'reg_air_nose') and requestAction in ('fak_opos', 'fak_nopos'):
-            requestAction = 'reg_land'
-        if l_actionState in ('fak_air_tail', 'fak_air_nose') and requestAction in ('reg_opos', 'reg_nopos'):
-            requestAction = 'fak_land'    
+#        if l_actionState in ('reg_air_tail', 'reg_air_nose') and requestAction in ('fak_opos', 'fak_nopos'):
+#            requestAction = 'reg_land'
+#        if l_actionState in ('fak_air_tail', 'fak_air_nose') and requestAction in ('reg_opos', 'reg_nopos'):
+#            requestAction = 'fak_land'    
             
             
         if l_actionState == 'reg_air' and requestAction == 'fak_air':
         if l_actionState in ('reg_noseslide_out', 'regtailslide_out') and requestAction == ' fak_roll':
             requestAction = 'reg-fak_roll'
         if l_actionState in ('fak_noseslide_out', 'faktailslide_out') and requestAction == ' reg_roll':
-            requestAction = 'fak-reg_roll'            
+            requestAction = 'fak-reg_roll'     
+            
+            
+#        if (l_actionState == 'fak_air-roll' and requestAction == 'fak_manual'):
+#            actionTimer = 0
+#            own['actionTimer'] = 0  
+#            l_actionState = 'fak_manual'
+#            own['l_actionState'] = 'fak_manual' 
+#        if (l_actionState == 'reg_air-roll' and requestAction == 'reg_manual'):
+#            actionTimer = 0
+#            own['actionTimer'] = 0                      
+#            l_actionState = 'reg_manual'
+#            own['l_actionState'] = 'reg_manual'             
                                                                                                                                                         
     else:
         print("action over written")               
                 actionState = 'reg_manual_out'
                 own['actionTimer'] = 9
                 trans_playing = skater.isPlayingAction(trans_layer)
-                if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)                   
-                if trans_playing and cur_frame > 1:                
-                    skater.playAction("reg_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                    deck.playAction("a_reg_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                    trucks.playAction("a_reg_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                    #own['actionTimer'] = cur_frame
-                else:                      
-                    skater.playAction("reg_manual", 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)                     
-                    
+#                if trans_playing:
+#                    cur_frame = skater.getActionFrame(trans_layer)                   
+#                if trans_playing and cur_frame > 1:                
+#                    skater.playAction("reg_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
+#                    deck.playAction("a_reg_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
+#                    trucks.playAction("a_reg_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
+#                    #own['actionTimer'] = cur_frame
+#                else:                      
+                skater.playAction("reg_manual", 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)                     
+                
                     
             if requestAction == 'fak_manual_out':
                 actionState = 'fak_manual_out'
                 own['actionTimer'] = 9
                 trans_playing = skater.isPlayingAction(trans_layer)
-                if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)                   
-                if trans_playing and cur_frame > 1:                
-                    skater.playAction("fak_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                    deck.playAction("a_fak_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                    trucks.playAction("a_fak_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                    #own['actionTimer'] = cur_frame
-                else:                      
-                    skater.playAction("fak_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)
-                    deck.playAction("a_fak_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)
-                    trucks.playAction("a_fak_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)                     
-                    
+#                if trans_playing:
+#                    cur_frame = skater.getActionFrame(trans_layer)                   
+#                if trans_playing and cur_frame > 1:                
+#                    skater.playAction("fak_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
+#                    deck.playAction("a_fak_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
+#                    trucks.playAction("a_fak_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
+#                    #own['actionTimer'] = cur_frame
+                #else:                      
+                skater.playAction("fak_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)
+                deck.playAction("a_fak_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)
+                trucks.playAction("a_fak_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)                     
+                
             if requestAction == 'reg_nmanual_out':
                 actionState = 'reg_nmanual_out'
                 own['actionTimer'] = 9
                 trans_playing = skater.isPlayingAction(trans_layer)
-                if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)                   
-                if trans_playing and cur_frame > 1:                
-                    skater.playAction("reg_nmanual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                    deck.playAction("a_fak_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                    trucks.playAction("a_fak_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                    #own['actionTimer'] = cur_frame
-                else:                      
-                    skater.playAction("reg_nmanual", 10,1, layer=trans_layer, play_mode=0, speed=1)
-                    deck.playAction("a_fak_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)
-                    trucks.playAction("a_fak_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)                     
+#                if trans_playing:
+#                    cur_frame = skater.getActionFrame(trans_layer)                   
+#                if trans_playing and cur_frame > 1:                
+#                    skater.playAction("reg_nmanual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
+#                    deck.playAction("a_fak_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
+#                    trucks.playAction("a_fak_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
+#                    #own['actionTimer'] = cur_frame
+                #else:                      
+                skater.playAction("reg_nmanual", 10,1, layer=trans_layer, play_mode=0, speed=1)
+                deck.playAction("a_fak_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)
+                trucks.playAction("a_fak_manual", 10,1, layer=trans_layer, play_mode=0, speed=1)                     
                     
                     
             if requestAction == 'fak_nmanual_out':
                 actionState = 'fak_nmanual_out'
                 own['actionTimer'] = 9
                 trans_playing = skater.isPlayingAction(trans_layer)
-                if trans_playing:
-                    cur_frame = skater.getActionFrame(trans_layer)                   
-                if trans_playing and cur_frame > 1:                
-                    skater.playAction("fak_nmanual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                    deck.playAction("a_reg_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                    trucks.playAction("a_reg_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
-                    #own['actionTimer'] = cur_frame
-                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)
+#                if trans_playing:
+#                    cur_frame = skater.getActionFrame(trans_layer)                   
+#                if trans_playing and cur_frame > 1:                
+#                    skater.playAction("fak_nmanual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
+#                    deck.playAction("a_reg_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
+#                    trucks.playAction("a_reg_manual", cur_frame,1, layer=trans_layer, play_mode=0, speed=1)
+#                    #own['actionTimer'] = cur_frame
+                #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)
             
             if requestAction == 'reg-fak_nmanual':
                 own['actionTimer'] = 9
                 
             if l_requestAction == 'fak_air_nose to nmanual':
                 own['actionTimer'] = 20
-                actionState = 'fak_air_tail to nmanual'                    
+                actionState = 'fak_air_nose to nmanual'                    
                 skater.playAction("fak_nmanual", 90,110, layer=trans_layer, play_mode=0, speed=1)                
                 deck.playAction("a_reg_manual", 90,110, layer=trans_layer, play_mode=0, speed=1)
                 trucks.playAction("a_reg_manual", 90,110, layer=trans_layer, play_mode=0, speed=1)                                                                 
     
 ##############
     #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
+#    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
                   
     if (own['actionTimer'] == 0 or requestAction == 'reg_land' or requestAction == 'fak_land') or requestAction in jump_overrideList:
         actionState = updateAction(requestAction, actionState)
         
-    if (own['actionState'] == 'reg_land' or own['actionState'] == 'reg_land') and own['actionTimer'] > 0:
-        own['clear_request'] = 1    
+#    if (own['actionState'] == 'reg_land' or own['actionState'] == 'reg_land') and own['actionTimer'] > 0:
+#        own['clear_request'] = 1    
   
 ###################  
     
     if trans_playing:
         cur_frame = skater.getActionFrame(trans_layer)  
         cur_frame = round(cur_frame, 2)     
-    print("oG: ", og_request, "rA:", requestAction, "|aS:", own['actionState'], "q", queueAction, own['actionTimer'], 'cf', cur_frame)
+    #print("oG: ", og_request, "rA:", requestAction, "|aS:", own['actionState'], "q", queueAction, own['actionTimer'], 'cf', cur_frame)
     cur_frame = skater.getActionFrame(trans_layer)
     #print(cur_frame)
     def printplaying():

controller2.py

     fliplay = 470
     MAX_VEL = 6.7
     SPEEDUP = .055
-    SPEEDPUMP = .12 #.09
-    SPEEDPUMPFAST = .14 #.13
+    SPEEDPUMP = .14 #.09
+    SPEEDPUMPFAST = .16 #.13
     PUMP_SPEED_SENS = .4
     PUMP_SENS = .98
     ACCEL = 10
                     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('::::::wallhit')
             force = (linVelocity.x * -.7, linVelocity.y, linVelocity.z )                    
             own.setLinearVelocity(force, True)        
-
+    
+    def land_boost():
+        linvelx = linVelocity.x
+        lastx = own["linvelx"]
+        if frames_since_ground < 2 and (abs(lastx) - abs(linvelx)) > .5:
+            print('**_____________land boost')
+            force = (lastx, linVelocity.y, linVelocity.z )                    
+            own.setLinearVelocity(force, True)             
+        
+    
     jump_Timer()
     check_landing()
     nextframe()
     onboard()   
     #wallhit() 
     linvelx = own.getLinearVelocity(True)
-
+    land_boost()
     own["linvelx"] = linvelx.x
     LAST_STANCE = STANCE
     LAST_STANCE = own["stance"]

npause.py

 import bge
+import menuV3
+import Settings
 
 
+#replay huds:
+#add_hud
+#remove_hud (on control_cube)
+
 def main():
 
     cont = bge.logic.getCurrentController()
     scene = bge.logic.getCurrentScene()
-    own = cont.owner
+    #own = cont.owner
     dict = bge.logic.globalDict 
     
     skater = scene.objects["Char4"]
     deck = scene.objects["deck"]
     trucks = scene.objects["trucks"]
+    own = scene.objects["control_cube.002"]
+    
+    camList = scene.cameras
+    freecam = camList["freecam"] 
+    mcam = camList['Camera.003']   
+    
+    #freecam = scene.objects['freecam']
+    cube = scene.objects['control_cube.002']
     
     try:
         pause_state = dict['npause']
         own['pre_pause_linvel'] = [own['linvelx'], own['linVely'], 0]
         own.setLinearVelocity([0,0,0],1)  
         cont.activate(cont.actuators['empty'])
-        cont.activate(cont.actuators['add_overlay']) 
-        printplaying()
+        if mcam['playback'] == False:
+            cont.activate(cont.actuators['add_overlay']) 
+            #pass
+        #printplaying()
+        cont.activate(cont.actuators['remove_stance'])  
+        cube['camera'] = 2
+        cube['camnum'] = 2 
+        scene.active_camera = freecam 
+        #print('set freecam', scene.active_camera)
+        freecam.lens = mcam['focal_length'] 
+        freecam.worldPosition = mcam.worldPosition
+        freecam.worldOrientation = mcam.worldOrientation                      
 
-    if pause_state == 1:        
-        layer = 450
-        if skater.isPlayingAction(layer):
-            skater.stopAction(layer)
-        if deck.isPlayingAction(layer):    
-            deck.stopAction(layer)
-        if trucks.isPlayingAction(layer):    
-            trucks.stopAction(layer)
-        layer = 460
-        if skater.isPlayingAction(layer):
-            skater.stopAction(layer)
-        if deck.isPlayingAction(layer):    
-            deck.stopAction(layer)
-        if trucks.isPlayingAction(layer):    
-            trucks.stopAction(layer)
-        layer = 470
-        if skater.isPlayingAction(layer):
-            skater.stopAction(layer)
-        if deck.isPlayingAction(layer):    
-            deck.stopAction(layer)
-        if trucks.isPlayingAction(layer):    
-            trucks.stopAction(layer)
-                                                            
+    if pause_state == 1: 
+        if mcam['playback'] == False:       
+            layer = 450
+            if skater.isPlayingAction(layer):
+                skater.stopAction(layer)
+            if deck.isPlayingAction(layer):    
+                deck.stopAction(layer)
+            if trucks.isPlayingAction(layer):    
+                trucks.stopAction(layer)
+            layer = 460
+            if skater.isPlayingAction(layer):
+                skater.stopAction(layer)
+            if deck.isPlayingAction(layer):    
+                deck.stopAction(layer)
+            if trucks.isPlayingAction(layer):    
+                trucks.stopAction(layer)
+            layer = 470
+            if skater.isPlayingAction(layer):
+                skater.stopAction(layer)
+            if deck.isPlayingAction(layer):    
+                deck.stopAction(layer)
+            if trucks.isPlayingAction(layer):    
+                trucks.stopAction(layer)
+        menuV3.main(cont)                                                    
         
         
         
     #exit pause     
     if pause_state == 0 and last_pause == 1:
         #print("unpause")
+        Settings.writeSettings()
         own.restoreDynamics()
+        #own['camera'] = 0
         #own.setlinearVelocity([0,0,0],1] 
-        cont.activate(cont.actuators['roll'])
+        
+        if own['walk'] == False:
+            cont.activate(cont.actuators['roll'])
+        else:
+            cont.activate(cont.actuators['walk'])    
         #print("pre_pause_linvel = ", own['pre_pause_linvel'])
         try:
             own.setLinearVelocity(own['pre_pause_linvel'], 1) 
         except:
             pass    
-        cont.activate(cont.actuators['remove_overlay'])           
+        cont.activate(cont.actuators['remove_overlay'])  
+        cont.activate(cont.actuators['add_stance']) 
+        
+    if pause_state == 1 and dict['rtsBut'] == False and dict['last_rtsBut'] == True:
+        scenes = bge.logic.getSceneList()
+        if 'pause' in scenes:    
+            cont.activate(cont.actuators['remove_overlay']) 
+        else:
+            cont.activate(cont.actuators['add_overlay'])                                   
     #print(pause_state)
     dict['last_npause'] = pause_state
+    #print(scene.active_camera, cube['camera'])
     
 main()

pause.py

     pstate = own["pstate"]
     scene = bge.logic.getCurrentScene()
     dict = bge.logic.globalDict
-    resume = scene.objects["resume"]
-    settings = scene.objects["settings"]
+#    resume = scene.objects["resume"]
+#    settings = scene.objects["settings"]
     level = scene.objects["level"]
     dict['level'] = level
-    levelselect = scene.objects["levelselect"]
-    restart = scene.objects["restart"]
-    exit = scene.objects["exit"]
-    submenu_on = own["submenu_on"]
-    level_text = scene.objects["level_text"]
-    level_text.resolution = 8
+#    levelselect = scene.objects["levelselect"]
+#    restart = scene.objects["restart"]
+#    exit = scene.objects["exit"]
+#    submenu_on = own["submenu_on"]
+#    level_text = scene.objects["level_text"]
+#    level_text.resolution = 8
     lastup = own["lastup"]
     lastdown = own["lastdown"]
     lastleft = own["lastleft"]
     #sSelect = cont.actuators["sSelect"]
     cont.deactivate(own.actuators['restart'])                                        
     #joy down
-    if down == 1 and lastdown != 1:
-        #own.stopAction(0)
-        pstate = own["pstate"]
-                    
-        if pstate == 0 and submenu_on == 0:
-            resume.playAction("p_resume", 10,0, layer=1, priority=0, play_mode=0, speed=playspeed)
-        if pstate == 1 and submenu_on == 0:
-            settings.playAction("p_settings", 10,0, layer=1, priority=0, play_mode=0, speed=playspeed)
-        if pstate == 2 and submenu_on == 0:
-            level.playAction("p_level", 10,0, layer=1, priority=0, play_mode=0, speed=playspeed)
-            #level.playAction("p_level_select", 10,0, layer=1, priority=0, play_mode=0, speed=playspeed)
-        if pstate == 3 and submenu_on == 0:
-            restart.playAction("p_restart", 10,0, layer=1, priority=0, play_mode=0, speed=playspeed)
-        if pstate == 4 and submenu_on == 0:
-            exit.playAction("p_exit", 10,0, layer=1, priority=0, play_mode=0, speed=playspeed)           
-            
-        if pstate < 4 and submenu_on == 0:
-            own["pstate"] = own["pstate"] + 1
-        if pstate == 4 and submenu_on == 0:
-            own["pstate"] = 0    
-        pstate = own["pstate"]
-        #print(pstate)   
-        cont.activate(own.actuators['sSelect']) 
-    #joy up    
-    if up == 1 and lastup != 1:
-        pstate = own["pstate"]
-                    
-        if pstate == 0 and submenu_on == 0:
-            resume.playAction("p_resume", 10,0, layer=0, priority=0, play_mode=0, speed=playspeed)
-        if pstate == 1 and submenu_on == 0:
-            settings.playAction("p_settings", 10,0, layer=0, priority=0, play_mode=0, speed=playspeed)
-        if pstate == 2 and submenu_on == 0:
-            level.playAction("p_level", 10,0, layer=0, priority=0, play_mode=0, speed=playspeed)
-        if pstate == 3 and submenu_on == 0:
-            restart.playAction("p_restart", 10,0, layer=0, priority=0, play_mode=0, speed=playspeed)
-        if pstate == 4 and submenu_on == 0:
-            exit.playAction("p_exit", 10,0, layer=0, priority=0, play_mode=0, speed=playspeed)
-            
-            
-        if pstate > 0 and submenu_on == 0:
-            own["pstate"] = own["pstate"] - 1
-        if pstate == 0 and submenu_on == 0:
-            own["pstate"] = 4    
-        pstate = own["pstate"]
-        #print(pstate)    
-        cont.activate(own.actuators['sSelect'])  
-    if right == 1 and lastright !=1:
-        cont.activate(own.actuators['sSelect']) 
-    if left == 1 and lastleft != 1:    
-        cont.activate(own.actuators['sSelect'])
+#    if down == 1 and lastdown != 1:
+#        #own.stopAction(0)
+#        pstate = own["pstate"]
+#                    
+#        if pstate == 0 and submenu_on == 0:
+#            resume.playAction("p_resume", 10,0, layer=1, priority=0, play_mode=0, speed=playspeed)
+#        if pstate == 1 and submenu_on == 0:
+#            settings.playAction("p_settings", 10,0, layer=1, priority=0, play_mode=0, speed=playspeed)
+#        if pstate == 2 and submenu_on == 0:
+#            level.playAction("p_level", 10,0, layer=1, priority=0, play_mode=0, speed=playspeed)
+#            #level.playAction("p_level_select", 10,0, layer=1, priority=0, play_mode=0, speed=playspeed)
+#        if pstate == 3 and submenu_on == 0:
+#            restart.playAction("p_restart", 10,0, layer=1, priority=0, play_mode=0, speed=playspeed)
+#        if pstate == 4 and submenu_on == 0:
+#            exit.playAction("p_exit", 10,0, layer=1, priority=0, play_mode=0, speed=playspeed)           
+#            
+#        if pstate < 4 and submenu_on == 0:
+#            own["pstate"] = own["pstate"] + 1
+#        if pstate == 4 and submenu_on == 0:
+#            own["pstate"] = 0    
+#        pstate = own["pstate"]
+#        #print(pstate)   
+#        cont.activate(own.actuators['sSelect']) 
+#    #joy up    
+#    if up == 1 and lastup != 1:
+#        pstate = own["pstate"]
+#                    
+#        if pstate == 0 and submenu_on == 0:
+#            resume.playAction("p_resume", 10,0, layer=0, priority=0, play_mode=0, speed=playspeed)
+#        if pstate == 1 and submenu_on == 0:
+#            settings.playAction("p_settings", 10,0, layer=0, priority=0, play_mode=0, speed=playspeed)
+#        if pstate == 2 and submenu_on == 0:
+#            level.playAction("p_level", 10,0, layer=0, priority=0, play_mode=0, speed=playspeed)
+#        if pstate == 3 and submenu_on == 0:
+#            restart.playAction("p_restart", 10,0, layer=0, priority=0, play_mode=0, speed=playspeed)
+#        if pstate == 4 and submenu_on == 0:
+#            exit.playAction("p_exit", 10,0, layer=0, priority=0, play_mode=0, speed=playspeed)
+#            
+#            
+#        if pstate > 0 and submenu_on == 0:
+#            own["pstate"] = own["pstate"] - 1
+#        if pstate == 0 and submenu_on == 0:
+#            own["pstate"] = 4    
+#        pstate = own["pstate"]
+#        #print(pstate)    
+#        cont.activate(own.actuators['sSelect'])  
+#    if right == 1 and lastright !=1:
+#        cont.activate(own.actuators['sSelect']) 
+#    if left == 1 and lastleft != 1:    
+#        cont.activate(own.actuators['sSelect'])
         
 #level*****************************************************
 
-    if own["submenu"] == "level":
-        #print("submenu is level")
-        active_level_select = own["active_level_select"]
-        
-        import Settings
-        if left == 1 and lastleft != 1:
-            if active_level_select >= 0:
-               active_level_select -= 1
-            if active_level_select < 0:
-                active_level_select = 8    
-            #if active_level_select == -1:    
-                #active_level_select = 0
-        #print(active_level_select)        
-            #move up
-            #play up            
-        if right == 1 and lastright != 1:    
-            if active_level_select < 9:
-               active_level_select += 1               
-            if active_level_select == 9:
-                active_level_select = 0
-            if active_level_select == -1:    
-                active_level_select = 0
-        #print(active_level_select)                        
-            #move down
-            #play down
-        if active_level_select == 0:
-            level_text.text = "Empty Lot"
-        if active_level_select == 1:
-            level_text.text = "Waterfall"
-        if active_level_select == 2:
-            level_text.text = "Warehouse" 
-        if active_level_select == 3:
-            level_text.text = "City"          
-        if active_level_select == 4:
-            level_text.text = "Training"          
-        if active_level_select == 5:
-            level_text.text = "Spine" 
-        if active_level_select == 6:
-            level_text.text = "Apricot Park" 
-        if active_level_select == 7:
-            level_text.text = "Newday Bowl"                           
-        if active_level_select == 8:
-            level_text.text = "Garage 18"                                                                      
-        own["active_level_select"] = active_level_select 
-        load_timer = 100
-#indoor
-        if aBut == False and active_level_select == 0 and lasta == 1:
-            level_text.text = ""
-            cont.activate(own.actuators['loading']) 
-            level = "lot"
-            main_empty["level"] = "lot"
-            own["level"] = level
-            Settings.writeSettings()
-            #print("not")
-            Settings.readSettings()
-            #cont.activate(own.actuators['restart'])
-            dict['reload_timer'] = 250
-            dict['overlay_fadein'] = 1
-            #Settings.loadlevel() 
-            dict['load_timer'] = load_timer
-        else: 
-            
-            cont.deactivate(own.actuators['restart']) 
-#woodbowl               
-        if aBut == False and active_level_select == 1 and lasta == 1:
-            level_text.text = ""
-            #cont.activate(own.actuators['loading']) 
-            level = "mini_scene"
-            main_empty["level"] = "mini_scene"
-            own["level"] = level
-            Settings.writeSettings()
-            Settings.readSettings()
-            #cont.activate(own.actuators['restart']) 
-            dict['reload_timer'] = 250
-            dict['overlay_fadein'] = 1
-            #Settings.loadlevel()
-            dict['load_timer'] = load_timer
-        else: cont.deactivate(own.actuators['restart']) 
-#mini        
-        if aBut == False and active_level_select == 2 and lasta == 1:
-            level_text.text = ""
-            #cont.activate(own.actuators['loading']) 
-            level = "warehouse"
-            main_empty["level"] = "warehouse"
-            own["level"] = level
-            Settings.writeSettings()
-            Settings.readSettings()
-            #cont.activate(own.actuators['restart']) 
-            dict['reload_timer'] = 250
-            dict['overlay_fadein'] = 1
-            #Settings.loadlevel()
-            dict['load_timer'] = load_timer
-        else: cont.deactivate(own.actuators['restart'])
-#level3        
-        if aBut == False and active_level_select == 3 and lasta == 1:
-            level_text.text = ""
-            level = "city2"
-            main_empty["level"] = "city2"
-            own["level"] = level
-            Settings.writeSettings()
-            Settings.readSettings()
-            #cont.activate(own.actuators['restart']) 
-            dict['reload_timer'] = 250
-            dict['overlay_fadein'] = 1
-            #Settings.loadlevel()
-            dict['load_timer'] = load_timer
-        else: cont.deactivate(own.actuators['restart']) 
-#hubbas rail        
-        if aBut == False and active_level_select == 4 and lasta == 1:
-            level_text.text = ""
-            level = "train"
-            main_empty["level"] = "train"
-            own["level"] = level
-            Settings.writeSettings()
-            Settings.readSettings()
-            #cont.activate(own.actuators['restart']) 
-            dict['reload_timer'] = 250
-            dict['overlay_fadein'] = 1
-            #Settings.loadlevel()
-            dict['load_timer'] = load_timer
-        else: cont.deactivate(own.actuators['restart']) 
-#training        
-        if aBut == False and active_level_select == 5 and lasta == 1:
-            level_text.text = ""
-            level = "spine"
-            main_empty["level"] = "spine"
-            own["level"] = level
-            Settings.writeSettings()
-            Settings.readSettings()
-            #cont.activate(own.actuators['restart']) 
-            dict['reload_timer'] = 250
-            dict['overlay_fadein'] = 1
-            #Settings.loadlevel()
-            dict['load_timer'] = load_timer
-        else: cont.deactivate(own.actuators['restart'])  
-        if aBut == False and active_level_select == 6 and lasta == 1:
-            level_text.text = ""
-            level = "gt"
-            main_empty["level"] = "gt"
-            own["level"] = level
-            Settings.writeSettings()
-            Settings.readSettings()
-            #cont.activate(own.actuators['restart']) 
-            dict['reload_timer'] = 250
-            dict['overlay_fadein'] = 1
-            #Settings.loadlevel()
-            dict['load_timer'] = load_timer
-        else: cont.deactivate(own.actuators['restart']) 
-        if aBut == False and active_level_select == 7 and lasta == 1:
-            level_text.text = ""
-            level = "newday"
-            main_empty["level"] = "newday"
-            own["level"] = level
-            Settings.writeSettings()
-            Settings.readSettings()
-            #cont.activate(own.actuators['restart']) 
-            dict['reload_timer'] = 250
-            dict['overlay_fadein'] = 1
-            #Settings.loadlevel()
-            dict['load_timer'] = load_timer
-        else: cont.deactivate(own.actuators['restart']) 
-        if aBut == False and active_level_select == 8 and lasta == 1:
-            level_text.text = ""
-            level = "garage18"
-            main_empty["level"] = "garage18"
-            own["level"] = level
-            Settings.writeSettings()
-            Settings.readSettings()
-            #cont.activate(own.actuators['restart']) 
-            #Settings.loadlevel()
-            dict['load_timer'] = load_timer
-            dict['reload_timer'] = 250
-            dict['overlay_fadein'] = 1
-        else: cont.deactivate(own.actuators['restart'])                                               
-    else:
-        own["active_level_select"] = -1 
-    if bBut == True:    
-        levelselect.playAction("p_level_select", 10,0, layer=3, priority=0, play_mode=0, speed=playspeed)                                         
+#    if own["submenu"] == "level":
+#        #print("submenu is level")
+#        active_level_select = own["active_level_select"]
+#        
+#        import Settings
+#        if left == 1 and lastleft != 1:
+#            if active_level_select >= 0:
+#               active_level_select -= 1
+#            if active_level_select < 0:
+#                active_level_select = 8    
+#            #if active_level_select == -1:    
+#                #active_level_select = 0
+#        #print(active_level_select)        
+#            #move up
+#            #play up            
+#        if right == 1 and lastright != 1:    
+#            if active_level_select < 9:
+#               active_level_select += 1               
+#            if active_level_select == 9:
+#                active_level_select = 0
+#            if active_level_select == -1:    
+#                active_level_select = 0
+#        #print(active_level_select)                        
+#            #move down
+#            #play down
+#        if active_level_select == 0:
+#            level_text.text = "Empty Lot"
+#        if active_level_select == 1:
+#            level_text.text = "Waterfall"
+#        if active_level_select == 2:
+#            level_text.text = "Warehouse" 
+#        if active_level_select == 3:
+#            level_text.text = "City"          
+#        if active_level_select == 4:
+#            level_text.text = "Training"          
+#        if active_level_select == 5:
+#            level_text.text = "Spine" 
+#        if active_level_select == 6:
+#            level_text.text = "Apricot Park" 
+#        if active_level_select == 7:
+#            level_text.text = "Newday Bowl"                           
+#        if active_level_select == 8:
+#            level_text.text = "Garage 18"                                                                      
+#        own["active_level_select"] = active_level_select 
+#        load_timer = 100
+##indoor
+#        if aBut == False and active_level_select == 0 and lasta == 1:
+#            level_text.text = ""
+#            cont.activate(own.actuators['loading']) 
+#            level = "lot"
+#            main_empty["level"] = "lot"
+#            own["level"] = level
+#            Settings.writeSettings()
+#            #print("not")
+#            Settings.readSettings()
+#            #cont.activate(own.actuators['restart'])
+#            dict['reload_timer'] = 250
+#            dict['overlay_fadein'] = 1
+#            #Settings.loadlevel() 
+#            dict['load_timer'] = load_timer
+#        else: 
+#            
+#            cont.deactivate(own.actuators['restart']) 
+##woodbowl               
+#        if aBut == False and active_level_select == 1 and lasta == 1:
+#            level_text.text = ""
+#            #cont.activate(own.actuators['loading']) 
+#            level = "mini_scene"
+#            main_empty["level"] = "mini_scene"
+#            own["level"] = level
+#            Settings.writeSettings()
+#            Settings.readSettings()
+#            #cont.activate(own.actuators['restart']) 
+#            dict['reload_timer'] = 250
+#            dict['overlay_fadein'] = 1
+#            #Settings.loadlevel()
+#            dict['load_timer'] = load_timer
+#        else: cont.deactivate(own.actuators['restart']) 
+##mini        
+#        if aBut == False and active_level_select == 2 and lasta == 1:
+#            level_text.text = ""
+#            #cont.activate(own.actuators['loading']) 
+#            level = "warehouse"
+#            main_empty["level"] = "warehouse"
+#            own["level"] = level
+#            Settings.writeSettings()
+#            Settings.readSettings()
+#            #cont.activate(own.actuators['restart']) 
+#            dict['reload_timer'] = 250
+#            dict['overlay_fadein'] = 1
+#            #Settings.loadlevel()
+#            dict['load_timer'] = load_timer
+#        else: cont.deactivate(own.actuators['restart'])
+##level3        
+#        if aBut == False and active_level_select == 3 and lasta == 1:
+#            level_text.text = ""
+#            level = "city2"
+#            main_empty["level"] = "city2"
+#            own["level"] = level
+#            Settings.writeSettings()
+#            Settings.readSettings()
+#            #cont.activate(own.actuators['restart']) 
+#            dict['reload_timer'] = 250
+#            dict['overlay_fadein'] = 1
+#            #Settings.loadlevel()
+#            dict['load_timer'] = load_timer
+#        else: cont.deactivate(own.actuators['restart']) 
+##hubbas rail        
+#        if aBut == False and active_level_select == 4 and lasta == 1:
+#            level_text.text = ""
+#            level = "train"
+#            main_empty["level"] = "train"
+#            own["level"] = level
+#            Settings.writeSettings()
+#            Settings.readSettings()
+#            #cont.activate(own.actuators['restart']) 
+#            dict['reload_timer'] = 250
+#            dict['overlay_fadein'] = 1
+#            #Settings.loadlevel()
+#            dict['load_timer'] = load_timer
+#        else: cont.deactivate(own.actuators['restart']) 
+##training        
+#        if aBut == False and active_level_select == 5 and lasta == 1:
+#            level_text.text = ""
+#            level = "spine"
+#            main_empty["level"] = "spine"
+#            own["level"] = level
+#            Settings.writeSettings()
+#            Settings.readSettings()
+#            #cont.activate(own.actuators['restart']) 
+#            dict['reload_timer'] = 250
+#            dict['overlay_fadein'] = 1
+#            #Settings.loadlevel()
+#            dict['load_timer'] = load_timer
+#        else: cont.deactivate(own.actuators['restart'])  
+#        if aBut == False and active_level_select == 6 and lasta == 1:
+#            level_text.text = ""
+#            level = "gt"
+#            main_empty["level"] = "gt"
+#            own["level"] = level
+#            Settings.writeSettings()
+#            Settings.readSettings()
+#            #cont.activate(own.actuators['restart']) 
+#            dict['reload_timer'] = 250
+#            dict['overlay_fadein'] = 1
+#            #Settings.loadlevel()
+#            dict['load_timer'] = load_timer
+#        else: cont.deactivate(own.actuators['restart']) 
+#        if aBut == False and active_level_select == 7 and lasta == 1:
+#            level_text.text = ""
+#            level = "newday"
+#            main_empty["level"] = "newday"
+#            own["level"] = level
+#            Settings.writeSettings()
+#            Settings.readSettings()
+#            #cont.activate(own.actuators['restart']) 
+#            dict['reload_timer'] = 250
+#            dict['overlay_fadein'] = 1
+#            #Settings.loadlevel()
+#            dict['load_timer'] = load_timer
+#        else: cont.deactivate(own.actuators['restart']) 
+#        if aBut == False and active_level_select == 8 and lasta == 1:
+#            level_text.text = ""
+#            level = "garage18"
+#            main_empty["level"] = "garage18"
+#            own["level"] = level
+#            Settings.writeSettings()
+#            Settings.readSettings()
+#            #cont.activate(own.actuators['restart']) 
+#            #Settings.loadlevel()
+#            dict['load_timer'] = load_timer
+#            dict['reload_timer'] = 250
+#            dict['overlay_fadein'] = 1
+#        else: cont.deactivate(own.actuators['restart'])                                               
+#    else:
+#        own["active_level_select"] = -1 
+#    if bBut == True:    
+#        levelselect.playAction("p_level_select", 10,0, layer=3, priority=0, play_mode=0, speed=playspeed)                                         
 #**********************************************************   
 
 
 
-    if bBut == 1:
-        cont.activate(own.actuators['sBack']) 
-        #cont.activate(own.actuators['exit']) 
-        #print("bbut")
-    #go to level submenu        
-    if aBut == True and pstate == 2:
-        cont.activate(own.actuators['sEnter']) 
-        #cont.activate(own.actuators['quit']) 
-        #print("level")       
-        own["submenu_on"] = 1
-        own["submenu"] = "level"
-        level_text.text = "<choose>"
-        levelselect.playAction("p_level_select", -10,10, layer=3, priority=0, play_mode=0, speed=playspeed)
-    #exit submenu
-    if bBut and submenu_on == 1:
-        own["submenu_on"] = 0  
-        own["submenu"] = None  
-        level_text.text = "" 
-    
-    #exit    
-    if aBut == 1 and pstate == 4:
-        cont.activate(own.actuators['sEnter']) 
-        cont.activate(own.actuators['quit']) 
-        print("bbut")  
+ 
 
-    if pstate == 0 and submenu_on == 0 and lastpstate != 0:
-        resume.playAction("p_resume", -10,10, layer=0, priority=0, play_mode=0, speed=playspeed)
-    if pstate == 1 and submenu_on == 0 and lastpstate != 1:
-        settings.playAction("p_settings", -10,10, layer=0, priority=0, play_mode=0, speed=playspeed)
-    if pstate == 2 and submenu_on == 0 and lastpstate != 2:
-        level.playAction("p_level", -10,10, layer=0, priority=0, play_mode=0, speed=playspeed)
-        #level.playAction("p_level_select", -10,10, layer=0, priority=0, play_mode=0, speed=playspeed)
-    if pstate == 3 and submenu_on == 0 and lastpstate != 3:
-        restart.playAction("p_restart", -10,10, layer=0, priority=0, play_mode=0, speed=playspeed)
-    if pstate == 4 and submenu_on == 0 and lastpstate != 4:
-        exit.playAction("p_exit", -10,10, layer=0, priority=0, play_mode=0, speed=playspeed)                
+#    if pstate == 0 and submenu_on == 0 and lastpstate != 0:
+#        resume.playAction("p_resume", -10,10, layer=0, priority=0, play_mode=0, speed=playspeed)
+#    if pstate == 1 and submenu_on == 0 and lastpstate != 1:
+#        settings.playAction("p_settings", -10,10, layer=0, priority=0, play_mode=0, speed=playspeed)
+#    if pstate == 2 and submenu_on == 0 and lastpstate != 2:
+#        level.playAction("p_level", -10,10, layer=0, priority=0, play_mode=0, speed=playspeed)
+#        #level.playAction("p_level_select", -10,10, layer=0, priority=0, play_mode=0, speed=playspeed)
+#    if pstate == 3 and submenu_on == 0 and lastpstate != 3:
+#        restart.playAction("p_restart", -10,10, layer=0, priority=0, play_mode=0, speed=playspeed)
+#    if pstate == 4 and submenu_on == 0 and lastpstate != 4:
+#        exit.playAction("p_exit", -10,10, layer=0, priority=0, play_mode=0, speed=playspeed)                
 
 
     #find the scene and object

scene_init.py

     level = dict['level']
     scene = bge.logic.getCurrentScene()
     cam = scene.objects['Camera.003']
-    print("scene innnnnnnnnnnnnit1")
     curscene = bge.logic.getCurrentScene()
     
 #    scenes = bge.logic.getSceneList()
     scenes = bge.logic.getSceneList()
     own['pre_pause_linvel'] = 0.0
     #own['last_roll_frame'] = 0
+    
+    
+    
+    
     for i in scenes:
         if i.name == "main":
             main = i
         #main.mistStart = 1
         #main.mistDistance = 5
     elif level == 'pats':
+        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 
+        
+    elif level == 'j_scene':
         print('setting color of', curscene)
         main.world.zenithColor = [1.0, .9, .975, 0]
         main.world.horizonColor = [.42, .555, .823, 0]  
         #main.mistEnable = True
         #main.mistIntensity = .9
         #main.mistStart = 1
-        #main.mistDistance = 5        
+        #main.mistDistance = 5                
     else:
-        cam['BC_BRIGHTNESS'] = 1.0   
-        cam['BC_CONTRAST'] = 1.0
+        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["bc_off"])  
+    if dict['hdr'] == 1:
+        cont.activate(cam.actuators["hdr"])
+
+    else:
+        cont.activate(cam.actuators["hdr_off"])
+                            
+    if dict['ao'] == 1:
+        cont.activate(cam.actuators["ao"])
+
+    else:
+        cont.activate(cam.actuators["ao_off"])                    
+
+    if dict['dof_on'] == 1:
+        cont.activate(cam.actuators["DOF"])
+
+    else:
+        cont.activate(cam.actuators["DOF_off"])
+    scene.world.envLightEnergy = dict['ambient_strength']   
+    
+    cam['BC_BRIGHTNESS'] = dict['BC_BRIGHTNESS'] 
+    cam['BC_CONTRAST'] = dict['BC_CONTRAST']
+    cam['bc'] = dict['bc']  
+    cam['hdr'] = dict['hdr']
+    cam['avgL'] = dict['avgL']
+    cam['HDRamount'] = dict['HDRamount']
+    cam['ao'] = dict['ao']  
+    cam['onlyAO'] = dict['onlyAO']
+    cam['aowidth'] = dict['aowidth']
+    cam['aoradius'] = dict['aoradius']  
+    cam['ambient_strength'] = dict['ambient_strength']
+    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']    
+           
 main()