zS128

Manager.py

@@ -0,0 +1,548 @@
+#"""
+#Modified BGE Gameplay Recorder Version 2
+#originally written by Nicholas Anderson, aka Red Frost Games.
+#"""
+
+#####Tweakables###############
+#Watch out! These numbers might bite!
+frame_rate = 60    #Set this to the framerate of your game.
+optimization = 1    #An integer, must be at least 1! Higher value will make a smaller saved file size. I do not reccomend setting it to anything other than 1 though.
+recording_cutoff = 7300 #3600   #Frames at which the oldest recorded frame will be deleted. 0 is no cutoff.
+recorder_state = 1   #This is the main state of the recorder object. State will be reverted to this value when the user breaks out of the playback.
+allow_playback_break = True   #Allow the player to resume playing from the position in the recording.
+#####Sensor names#############
+record_sensor = "Record"
+save_recording_sensor = "Save"
+load_recording_sensor = "Load"
+track_left_sensor = "Left"
+track_right_sensor = "Right"
+break_sensor = "Break"
+##############################
+
+from bge import logic
+import Record
+import SortData
+
+cont = logic.getCurrentController()
+own = cont.owner
+
+cont.sensors[record_sensor].skippedTicks = optimization
+dict = logic.globalDict
+
+#dict['recorder_on'] = recorder_on
+recorder_on = dict.get('recorder_on')
+own['recorder_on'] = recorder_on
+#print("recorder on: ", recorder_on) 
+
+if recorder_on == 1:
+    #----
+    scene = logic.getCurrentScene()
+    scene_list = logic.getSceneList()
+    camList = scene.cameras
+    followcam = camList["followcam"]
+    freecam = camList["freecam"]
+    skater = scene.objects["Char4"]
+    cube = scene.objects["control_cube.002"]
+    deck = scene.objects["deck"]
+    trucks = scene.objects["trucks"]
+    replay_cam_axis = own['replay_cam_axis']
+    cam = own.actuators['Camera']
+    #----
+    joybutsens = "joyBut"
+    #butt = cont.sensors[joybutsens]
+    #aXis = cont.sensors["joysticksens"]
+    #bk_but = 4
+    back_on = dict['bkBut']
+    #a_but = 0
+    a_on = dict['aBut']
+    #b_but = 1
+    b_on = dict['bBut']
+    #print(a on)
+    last_back = own['last_back_but']
+    #last_back = own['last_a_but']
+#    reduction = 400000
+#    axisTh = 0.03 
+#    lt = 4
+#    rt = 5
+#    lts_pr = 7
+#    rts_pr = 8
+
+#    lar_lts = 0
+#    uad_lts = 1
+#    lar_rts = 2 
+#    uad_rts = 3 
+    #lts_pr = 7
+    #rts_pr = 8
+#    lTrig = aXis.axisValues[lt] / reduction
+#    rTrig = aXis.axisValues[rt] / reduction
+#    lLR = aXis.axisValues[lar_lts] / reduction
+#    lUD = aXis.axisValues[uad_lts] / reduction
+#    rLR = aXis.axisValues[lar_rts] / reduction
+#    rUD = aXis.axisValues[uad_rts] / reduction
+#    ltsBut = butt.getButtonStatus(lts_pr)
+#    rtsBut = butt.getButtonStatus(rts_pr) 
+#        
+    lLR = dict['lLR']
+    lUD = dict['lUD']
+    rLR = dict['rLR']
+    rUD = dict['rUD']
+    lTrig = dict['lTrig']
+    rTrig = dict['rTrig']
+    aBut = dict['aBut']
+    bBut = dict['bBut']
+    xBut = dict['xBut']
+    yBut = dict['yBut']
+    lBump = dict['lBump']
+    rBump = dict['rBump']
+    bkBut = dict['bkBut']
+    stBut = dict['stBut']
+    xbBut = dict['xbBut']
+    ltsBut = dict['ltsBut']
+    rtsBut = dict['rtsBut']
+    ldPad = dict['ldPad']
+    rdPad = dict['rdPad']
+    udPad = dict['udPad']
+    ddPad = dict['ddPad']    
+        
+    
+       
+    #trigs results range 0 - .08
+    #print(lTrig, rTrig)
+
+    #if cont.sensors[record_sensor].positive:
+    if own["playback"] != True:    
+        Record.main(recording_cutoff)
+        
+    if cont.sensors[save_recording_sensor].positive:
+        SortData.writeData.saveAll()
+        
+    #if cont.sensors[load_recording_sensor].positive or (cube["sel"] == 1 and cube["last_sel"] == 0):
+    if own['back_state'] == 1 and back_on == 1 and last_back == 0:
+        cube["last_sel"] == 1
+        SortData.writeData.saveAll()
+        own["playback"] = True
+        own["playbackBroken"] = False
+        freecam.worldPosition = own.worldPosition
+        followcam.worldPosition = own.worldPosition
+        
+
+    if own["playback"]:
+        Record.loadData()
+    #..................
+    if cont.sensors[track_left_sensor].positive:
+        own["objIndex"] -= 2
+        logic.setLogicTicRate(frame_rate*own["playbackSpeed"])
+        
+    if cont.sensors[track_right_sensor].positive:
+        own["objIndex"] += 2
+        logic.setLogicTicRate(frame_rate*own["playbackSpeed"])
+
+    if own["playback"] == True:    
+        if rTrig > .01 and rTrig < .02:
+            own["objIndex"] += 2
+            logic.setLogicTicRate(frame_rate*.5) 
+        if (rTrig >= .02 and rTrig < .06) or own['loop_play'] == 1:
+            own["objIndex"] += 2
+            logic.setLogicTicRate(frame_rate*1)
+            #print(own['objIndex'])
+        if rTrig >= .06 and rTrig < .09:
+            own["objIndex"] += 2
+            logic.setLogicTicRate(frame_rate*1.5) 
+        if lTrig > .01 and lTrig < .02:
+            own["objIndex"] -= 2
+            logic.setLogicTicRate(frame_rate*.5) 
+        if lTrig >= .02 and lTrig < .06:
+            own["objIndex"] -= 2
+            logic.setLogicTicRate(frame_rate*1)
+        if lTrig >= .06 and lTrig < .09:
+            if own['loop_play'] == 1:
+                own["objIndex"] -= 6
+                #logic.setLogicTicRate(frame_rate*1.5)
+            else:    
+                own["objIndex"] -= 2
+                logic.setLogicTicRate(frame_rate*1.5)
+        if b_on == True:
+            print("bbut_on")
+            own['objIndex'] = 0
+            own['valueIndex'] = 0 
+            logic.setLogicTicRate(frame_rate*1)                       
+
+    #....................
+    if allow_playback_break:
+
+        if own['back_state'] == 0 and back_on == 1 and last_back == 0:       
+            own["playbackBroken"] = True
+            own["playback"] = False
+            #print("break - add hud, remove stance (back_state == False)")
+            #cont.activate(own.actuators['add_hud'])
+            #cont.activate(own.actuators['remove_stance'])
+            #removescene = cont.actuators["remove_hud"]
+            #removescene.scene = "replay_HUD"
+            #addscene = cont.actuators["add_hud"]
+            #addscene.scene = "stance"
+            #cont.activate(addscene)        
+            #cont.activate(removescene)
+        elif own["playbackBroken"] and back_on == 0:
+            Record.breakOut()
+            #cont.activate(own.actuators['remove_hud'])
+            #cont.activate(own.actuators['add_stance'])
+            #addscene = cont.actuators["add_hud"]
+            #addscene.scene = "replay_HUD"
+            #removescene = cont.actuators["remove_hud"]
+            #removescene.scene = "stance"
+            #cont.activate(addscene)
+            #cont.activate(removescene)
+            
+            logic.setLogicTicRate(frame_rate)
+            #set value index
+            own.state = recorder_state
+            own["playbackBroken"] = False
+            skater.stopAction(9999)
+            deck.stopAction(9999)
+            trucks.stopAction(9999)
+            cont.activate(own.actuators['replayCam'])
+            print("unbreak")
+            own['loop_play'] = 0
+            #own['valueIndex'] = 0
+            #own["objIndex"] += 2
+            #logic.setLogicTicRate(frame_rate*1)
+            #own['objectIndex'] = 0
+            #print("valueIndex = ", own['valueIndex'])
+    if back_on == 1 and own['back_but'] == 0:
+        print("change back state")
+        if own['back_state'] == True:
+            own['back_state'] = False
+        #elif own['back_state'] == False:
+        else:
+            own['back_state'] = True
+###
+    if own['last_playback'] != own['playback']:
+        if own['last_playback'] == True:
+            cont.activate(own.actuators['remove_hud'])
+            cont.activate(own.actuators['add_stance']) 
+            own['camnum'] = 0
+            cam = camList["Camera.003"]
+            scene.active_camera = cam                        
+            print("turning replay off", own['playback'])
+            
+          
+        if own['last_playback'] == False:
+            print("turning replay on", own['playback'])
+            cont.activate(own.actuators['add_hud'])
+            cont.activate(own.actuators['remove_stance'])
+            own['objIndex'] = 0
+            own['valueIndex'] = 3
+            logic.setLogicTicRate(frame_rate*1)               
+             
+                         
+####
+    if a_on == 1 and own['a_but'] == False:
+        if own['loop_play'] == 1:
+            own['loop_play'] = 0
+        else:
+            own['loop_play'] = 1            
+    if rLR > .05 and own["playback"]:
+        act = cont.actuators["replayCam"]
+        if rLR > .07:
+            act.dLoc = [ .06, 0.0, 0.0]
+        else:
+            act.dLoc = [ .03, 0.0, 0.0]
+        #cont.deactivate(own.actuators['Camera'])
+        cont.activate(own.actuators['replayCam']) 
+        #print("move") 
+    elif rLR < -.05 and own["playback"]:
+        act = cont.actuators["replayCam"]
+        if rLR < -.07:
+            act.dLoc = [ -.06, 0.0, 0.0]
+        else:    
+            act.dLoc = [ -.03, 0.0, 0.0]
+        #cont.deactivate(own.actuators['Camera'])
+        #act.damping = 6
+        cont.activate(own.actuators['replayCam']) 
+        #print("move")         
+    else:  
+        #pass      
+        cont.deactivate(own.actuators['replayCam'])
+        #cont.activate(own.actuators['Camera'])
+    #print("back state: ", own['back_state'], "last_back_but: ", own['last_back_but'], "back_but :", own['back_but'])  
+    #integer
+    # 
+    #0 = +X axis
+    # 
+    #1 = +Y axis
+    # 
+    #2 = +Z axis
+    # 
+    #3 = -X axis
+    # 
+    #4 = -Y axis
+    # 
+    #5 = -Z axis
+#    if rLR > .05 and own["playback"]:
+#        if own['last_rtsBut'] == True and rtsBut == False:
+#            if replay_cam_axis == 0:
+#               replay_cam_axis = 1
+#            elif replay_cam_axis == 1:
+#                replay_cam_axis = 3
+#            elif replay_cam_axis == 3 :
+#                replay_cam_axis = 4
+#            elif replay_cam_axis == 4:
+#                replay_cam_axis = 0 
+#        cam.axis = replay_cam_axis
+#        cont.activate(cam)
+#        print("set replay_cam_axis: ", replay_cam_axis)
+#        own['replay_cam_axis'] = replay_cam_axis
+    if own['last_ltsBut'] == True and ltsBut == False and own['playback']:
+        # get camera named SecurityCam
+        if own['camnum'] == 1:
+            own['camnum'] = 2
+        elif own['camnum'] == 0:
+            own['camnum'] = 1 
+        elif own['camnum'] == 2:
+            own['camnum'] = 0    
+    if own['last_rtsBut'] == True and rtsBut == False and own['playback']:
+        # get camera named SecurityCam
+        if "replay_HUD" in scene_list:
+            cont.activate(own.actuators['remove_hud'])
+        else:
+            cont.activate(own.actuators['add_hud'])
+    if own['camnum'] == 1 and own['playback']:
+        
+        scene.active_camera = followcam 
+        #################
+        camspeed1 = .04 #.015
+        camspeed2 = .1 #.055
+        camrot1 = .02 #.005
+        camrot2 = .04 #.02
+        #up
+        if lUD < -0.080:
+            followcam.actuators["up"].dLoc = [ 0, 0, -camspeed2]
+            cont.activate(followcam.actuators["up"])
+            #print("fastup")
+        else:
+            cont.deactivate(followcam.actuators["up"])    
+#            #down    
+        if lUD > .080:
+            followcam.actuators["down"].dLoc = [ 0, 0, camspeed2]
+            cont.activate(followcam.actuators["down"])
+        else:
+            cont.deactivate(followcam.actuators["down"])                    
+#            #left
+        if lLR < -0.080:
+            followcam.actuators["left"].dLoc = [-camspeed2, 0, 0]                
+            cont.activate(followcam.actuators["left"])
+        else:
+            cont.deactivate(followcam.actuators["left"])                    
+#            #right
+        if lLR > 0.080:         
+            followcam.actuators["right"].dLoc = [camspeed2, 0, 0]                
+            cont.activate(followcam.actuators["right"])
+        else:
+            cont.deactivate(followcam.actuators["right"])  
+        #up
+        if rUD < -0.080:
+            followcam.actuators["rotup"].dLoc = [0, 0, camrot2]
+            cont.activate(followcam.actuators["rotup"])
+            #print("uppppppppppppppppppppppppppp")
+        else:
+            cont.deactivate(followcam.actuators["rotup"])    
+#            #down    
+        if rUD > .080:
+            followcam.actuators["rotdown"].dLoc = [0, 0, -camrot2]                
+            cont.activate(followcam.actuators["rotdown"])
+        else:
+            cont.deactivate(followcam.actuators["rotdown"])                    
+#            #left
+        if rLR < -0.080:
+            followcam.actuators["rotleft"].dRot = [0, 0, camrot2]                
+            cont.activate(followcam.actuators["rotleft"])
+        else:
+            cont.deactivate(followcam.actuators["rotleft"])                    
+#            #right
+        if rLR > 0.080:         
+            followcam.actuators["rotright"].dRot = [0, 0, -camrot2]
+            cont.activate(followcam.actuators["rotright"])
+        else:
+            cont.deactivate(followcam.actuators["rotright"]) 
+
+#*********************************************                
+            
+        if lUD > -0.080 and lUD < -0.030:
+            followcam.actuators["up"].dLoc = [ 0, 0, -camspeed1]
+            cont.activate(followcam.actuators["up"])
+            #print(lUD)
+        else:
+            cont.deactivate(followcam.actuators["up"])    
+#            #down    
+        if lUD < .080 and lUD > .03:
+            followcam.actuators["down"].dLoc = [ 0, 0, camspeed1]                
+            cont.activate(followcam.actuators["down"])
+        else:
+            cont.deactivate(followcam.actuators["down"])                    
+#            #left
+        if lLR > -0.080 and lLR < -0.030:
+            followcam.actuators["left"].dLoc = [-camspeed1, 0, 0]                
+            cont.activate(followcam.actuators["left"])
+        else:
+            cont.deactivate(followcam.actuators["left"])                    
+#            #right
+        if lLR < .080 and lLR > .03:       
+            followcam.actuators["right"].dLoc = [camspeed1, 0, 0]
+            cont.activate(followcam.actuators["right"])
+        else:
+            cont.deactivate(followcam.actuators["right"])  
+        #up
+        if rUD > -0.080 and rUD < -0.030:
+            followcam.actuators["rotup"].dRot = [camrot1, 0, 0]                
+            cont.activate(followcam.actuators["rotup"])
+        else:
+            cont.deactivate(followcam.actuators["rotup"])    
+#            #down    
+        if rUD < .080 and rUD > .03:
+            followcam.actuators["rotdown"].dRot = [-camrot1, 0, 0]                
+            cont.activate(followcam.actuators["rotdown"])
+        else:
+            cont.deactivate(followcam.actuators["rotdown"])                    
+#            #left
+        if rLR > -0.080 and rLR < -0.030:
+            followcam.actuators["rotleft"].dRot = [0, 0, camrot1]
+            cont.activate(followcam.actuators["rotleft"])
+        else:
+            cont.deactivate(followcam.actuators["rotleft"])                    
+#            #right
+        if rLR < .080 and rLR > .03:         
+            followcam.actuators["rotright"].dRot = [0, 0, -camrot1]
+            cont.activate(followcam.actuators["rotright"])
+        else:
+            cont.deactivate(followcam.actuators["rotright"])          
+        
+        #################
+        
+    if own['camnum'] == 2 and own['playback']:
+        
+        scene.active_camera = freecam
+        
+        #act = freecam.actuators[
+        camspeed1 = .015
+        camspeed2 = .055
+        camrot1 = .005
+        camrot2 = .02
+        #up
+        if lUD < -0.080:
+            freecam.actuators["up"].dLoc = [ 0, 0, -camspeed2]
+            cont.activate(freecam.actuators["up"])
+            #print("fastup")
+        else:
+            cont.deactivate(freecam.actuators["up"])    
+#            #down    
+        if lUD > .080:
+            freecam.actuators["down"].dLoc = [ 0, 0, camspeed2]
+            cont.activate(freecam.actuators["down"])
+        else:
+            cont.deactivate(freecam.actuators["down"])                    
+#            #left
+        if lLR < -0.080:
+            freecam.actuators["left"].dLoc = [-camspeed2, 0, 0]                
+            cont.activate(freecam.actuators["left"])
+        else:
+            cont.deactivate(freecam.actuators["left"])                    
+#            #right
+        if lLR > 0.080:         
+            freecam.actuators["right"].dLoc = [camspeed2, 0, 0]                
+            cont.activate(freecam.actuators["right"])
+        else:
+            cont.deactivate(freecam.actuators["right"])  
+        #up
+        if rUD < -0.080:
+            freecam.actuators["rotup"].dRot = [camrot2, 0, 0]
+            cont.activate(freecam.actuators["rotup"])
+        else:
+            cont.deactivate(freecam.actuators["rotup"])    
+#            #down    
+        if rUD > .080:
+            freecam.actuators["rotdown"].dRot = [-camrot2, 0, 0]                
+            cont.activate(freecam.actuators["rotdown"])
+        else:
+            cont.deactivate(freecam.actuators["rotdown"])                    
+#            #left
+        if rLR < -0.080:
+            freecam.actuators["rotleft"].dRot = [0, 0, camrot2]                
+            cont.activate(freecam.actuators["rotleft"])
+        else:
+            cont.deactivate(freecam.actuators["rotleft"])                    
+#            #right
+        if rLR > 0.080:         
+            freecam.actuators["rotright"].dRot = [0, 0, -camrot2]
+            cont.activate(freecam.actuators["rotright"])
+        else:
+            cont.deactivate(freecam.actuators["rotright"]) 
+
+#*********************************************                
+            
+        if lUD > -0.080 and lUD < -0.030:
+            freecam.actuators["up"].dLoc = [ 0, 0, -camspeed1]
+            cont.activate(freecam.actuators["up"])
+            #print(lUD)
+        else:
+            cont.deactivate(freecam.actuators["up"])    
+#            #down    
+        if lUD < .080 and lUD > .03:
+            freecam.actuators["down"].dLoc = [ 0, 0, camspeed1]                
+            cont.activate(freecam.actuators["down"])
+        else:
+            cont.deactivate(freecam.actuators["down"])                    
+#            #left
+        if lLR > -0.080 and lLR < -0.030:
+            freecam.actuators["left"].dLoc = [-camspeed1, 0, 0]                
+            cont.activate(freecam.actuators["left"])
+        else:
+            cont.deactivate(freecam.actuators["left"])                    
+#            #right
+        if lLR < .080 and lLR > .03:       
+            freecam.actuators["right"].dLoc = [camspeed1, 0, 0]
+            cont.activate(freecam.actuators["right"])
+        else:
+            cont.deactivate(freecam.actuators["right"])  
+        #up
+        if rUD > -0.080 and rUD < -0.030:
+            freecam.actuators["rotup"].dRot = [camrot1, 0, 0]                
+            cont.activate(freecam.actuators["rotup"])
+        else:
+            cont.deactivate(freecam.actuators["rotup"])    
+#            #down    
+        if rUD < .080 and rUD > .03:
+            freecam.actuators["rotdown"].dRot = [-camrot1, 0, 0]                
+            cont.activate(freecam.actuators["rotdown"])
+        else:
+            cont.deactivate(freecam.actuators["rotdown"])                    
+#            #left
+        if rLR > -0.080 and rLR < -0.030:
+            freecam.actuators["rotleft"].dRot = [0, 0, camrot1]
+            cont.activate(freecam.actuators["rotleft"])
+        else:
+            cont.deactivate(freecam.actuators["rotleft"])                    
+#            #right
+        if rLR < .080 and rLR > .03:         
+            freecam.actuators["rotright"].dRot = [0, 0, -camrot1]
+            cont.activate(freecam.actuators["rotright"])
+        else:
+            cont.deactivate(freecam.actuators["rotright"])        
+########################################                 
+    if own['camnum'] == 0:
+        cam = camList["Camera.003"]
+        scene.active_camera = cam          
+    valueIndex = own['valueIndex']
+    n = (valueIndex / recording_cutoff) * 1000
+    n = int(round(n))
+    #n = 10
+    #print("n: ", n, "--", valueIndex, recording_cutoff)
+    #dict = logic.globalDict #Get the global dictionary
+    dict['playhead'] = n 
+      
+    own['last_back_but'] = own['back_but']           
+    own['back_but'] = back_on
+    own['last_a_but'] = own['a_but']           
+    own['a_but'] = a_on
+    own['last_ltsBut'] = ltsBut
+    own['last_rtsBut'] = rtsBut
+    own['last_playback'] = own['playback']

Startup.py

@@ -0,0 +1,100 @@
+import bge
+import GameLogic
+from bge import logic, render
+
+def main():
+    cont = GameLogic.getCurrentController() 
+    #cont = bge.logic.getCurrentController()
+    own = cont.owner
+    #bge.logic.addScene('Main')
+    #scenes = bge.logic.getSceneList()
+    #print(scenes)
+#-------
+    mainDir = GameLogic.expandPath("//")
+    fileName = mainDir + "Settings.dat" 
+    with open(fileName) as reading:
+            #data = [line.split()[0] for line in reading]
+            data = reading.readlines()
+            #print lines[25]
+            #print lines[29]
+            reading.close() 
+    resx = int(data[7])
+    resy = int(data[8]) 
+
+    #trick_string = dict.get('trick_string')                
+#    
+#    fullscreen = bge.render.getFullScreen()
+#    print("fullscreen = ", fullscreen)
+#    #if fullscreen != True:
+#        #bge.render.setFullScreen(True) 
+#    width = render.getWindowWidth()
+#    if width != resx:    
+#        bge.render.setWindowSize(resx, resy) 
+#---------
+    #bge.render.showFramerate
+    #bge.render.showProfile          
+    #dict = bge.logic.globalDict #Get the global dictionary
+    #print(dict)
+    #resx = dict['resx']
+    #resy = dict['resy']
+    #main_scene = [scene for scene in scenes if scene.name=="main"][0]
+#    
+#    for scene in scenes :
+#        if scene.name == 'Hud':
+#            player = scene.objects['player']
+#    print(scene.name)
+
+    #mains = main_scene.objects['Empty']
+    #resx = mains["resx"]
+    #resy = mains["resy"]
+    #print("read res: ", resx, resy)
+#    if not 'render_settings' in own:
+#        print("disable mips")
+#        render.setMipmapping(2)
+#    actu = cont.actuators['myActuator']
+#    cont.deactivate(actu)
+
+    dict = bge.logic.globalDict
+    
+    dict['kb_a'] = 0
+    dict['kb_d'] = 0
+    dict['kb_w'] = 0
+    dict['kb_s'] = 0
+    dict['kb_q'] = 0
+    dict['kb_e'] = 0
+    dict['kb_z'] = 0
+    dict['kb_c'] = 0 
+    dict['kb_en'] = 0    
+    dict['kb_la'] = 0
+    dict['kb_ra'] = 0
+    dict['kb_ua'] = 0
+    dict['kb_da'] = 0    
+    
+    dict['aBut'] = 0.0
+    dict['bBut'] = 0.0
+    dict['xBut'] = 0.0
+    dict['yBut'] = 0.0
+    dict['lBump'] = 0.0
+    dict['rBump'] = 0.0
+    dict['bkBut'] = 0.0
+    dict['stBut'] = 0.0
+    dict['xbBut'] = 0.0
+    dict['ltsBut'] = 0.0
+    dict['rtsBut'] = 0.0
+    dict['ldPad'] = 0.0
+    dict['rdPad'] = 0.0
+    dict['udPad'] = 0.0
+    dict['ddPad'] = 0.0
+    dict['rUD'] = 0.0
+    dict['lUD'] = 0.0
+    dict['rLR'] = 0.0
+    dict['lLR'] = 0.0
+    dict['rmUD'] = 0.0
+    dict['lmUD'] = 0.0
+    dict['rmLR'] = 0.0
+    dict['lmLR'] = 0.0
+    dict['mTrig'] = 0.0 
+    dict['lTrig'] = 0.0
+    dict['rTrig'] = 0.0 
+
+main()

controller2.py

@@ -37,8 +37,8 @@ if init:
     if not GameLogic.DictObjects.has_key(name):
         GameLogic.DictObjects[name]=cont
     own.init=0
-reduction = 400000
-axisTh = 0.03 
+#reduction = 400000
+#axisTh = 0.03 
 
 #initialize quadrant variables
 q1on = 0
@@ -200,75 +200,98 @@ LAND_LAYER = 100
 LAND_END = 20
 
 #Sensor logic bricks connected to the python Controller  
-aXis = cont.sensors["sControla"]
-bUtt = cont.sensors["sControlb"]
+#aXis = cont.sensors["sControla"]
+#bUtt = cont.sensors["sControlb"]
 
-onW = onWindows()
+#onW = onWindows()
 
-# windows stuff
-lar_lts = 0
-uad_lts = 1
-lar_rts = 2 if onW else 2
-uad_rts = 3 if onW else 3
-lt = 4 if onW else 4
-rt = 5 if onW else 5
+## windows stuff
+#lar_lts = 0
+#uad_lts = 1
+#lar_rts = 2 if onW else 2
+#uad_rts = 3 if onW else 3
+#lt = 4 if onW else 4
+#rt = 5 if onW else 5
 
 # These are the numerical values associated with the buttons on the Xbox Controller 
 # Called with - SensorName.getButtonStatus(buttonnumber) - 
 # A joystick sensor logic brick (with the 'Button' Event Type; 'All Events' selected; and 'Tap' enabled) must be connected to the Python Controller logic brick to call these buttons 
 
-a_but = 0 if onW else 0
-b_but = 1 if onW else 1
-x_but = 2 if onW else 2
-y_but = 3 if onW else 3
-l_bump = 9 if onW else 9
-r_bump = 10 if onW else 10
-bk_but = 4 if onW else 4
-st_but = 6 if onW else 6
-xb_but = 5 if onW else 5
-lts_pr = 7 if onW else 7
-rts_pr = 8 if onW else 8
-l_dp = 13 if onW else 13
-r_dp = 14 if onW else 14
-u_dp = 11 if onW else 11
-d_dp = 12 if onW else 12
+#a_but = 0 if onW else 0
+#b_but = 1 if onW else 1
+#x_but = 2 if onW else 2
+#y_but = 3 if onW else 3
+#l_bump = 9 if onW else 9
+#r_bump = 10 if onW else 10
+#bk_but = 4 if onW else 4
+#st_but = 6 if onW else 6
+#xb_but = 5 if onW else 5
+#lts_pr = 7 if onW else 7
+#rts_pr = 8 if onW else 8
+#l_dp = 13 if onW else 13
+#r_dp = 14 if onW else 14
+#u_dp = 11 if onW else 11
+#d_dp = 12 if onW else 12
+
+#lLR = aXis.axisValues[lar_lts] / reduction
+#lUD = aXis.axisValues[uad_lts] / reduction
+#rLR = aXis.axisValues[lar_rts] / reduction
+#rUD = aXis.axisValues[uad_rts] / reduction
+#lTrig = aXis.axisValues[lt] / reduction
+#rTrig = aXis.axisValues[rt] / reduction
+#aBut = bUtt.getButtonStatus(a_but)
+#bBut = bUtt.getButtonStatus(b_but)
+#xBut = bUtt.getButtonStatus(x_but)
+#yBut = bUtt.getButtonStatus(y_but)
+#lBump = bUtt.getButtonStatus(l_bump)
+#rBump = bUtt.getButtonStatus(r_bump)
+#bkBut = bUtt.getButtonStatus(bk_but)
+#stBut = bUtt.getButtonStatus(st_but)
+#xbBut = bUtt.getButtonStatus(xb_but)
+#ltsBut = bUtt.getButtonStatus(lts_pr)
+#rtsBut = bUtt.getButtonStatus(rts_pr)
+#ldPad = bUtt.getButtonStatus(l_dp)
+#rdPad = bUtt.getButtonStatus(r_dp)
+#udPad = bUtt.getButtonStatus(u_dp)
+#ddPad = bUtt.getButtonStatus(d_dp)
+
+lLR = dict['lLR']
+lUD = dict['lUD']
+rLR = dict['rLR']
+rUD = dict['rUD']
+lTrig = dict['lTrig']
+rTrig = dict['rTrig']
+aBut = dict['aBut']
+bBut = dict['bBut']
+xBut = dict['xBut']
+yBut = dict['yBut']
+lBump = dict['lBump']
+rBump = dict['rBump']
+bkBut = dict['bkBut']
+stBut = dict['stBut']
+xbBut = dict['xbBut']
+ltsBut = dict['ltsBut']
+rtsBut = dict['rtsBut']
+ldPad = dict['ldPad']
+rdPad = dict['rdPad']
+udPad = dict['udPad']
+ddPad = dict['ddPad']
 
-lLR = aXis.axisValues[lar_lts] / reduction
-lUD = aXis.axisValues[uad_lts] / reduction
-rLR = aXis.axisValues[lar_rts] / reduction
-rUD = aXis.axisValues[uad_rts] / reduction
-lTrig = aXis.axisValues[lt] / reduction
-rTrig = aXis.axisValues[rt] / reduction
-aBut = bUtt.getButtonStatus(a_but)
-bBut = bUtt.getButtonStatus(b_but)
-xBut = bUtt.getButtonStatus(x_but)
-yBut = bUtt.getButtonStatus(y_but)
-lBump = bUtt.getButtonStatus(l_bump)
-rBump = bUtt.getButtonStatus(r_bump)
-bkBut = bUtt.getButtonStatus(bk_but)
-stBut = bUtt.getButtonStatus(st_but)
-xbBut = bUtt.getButtonStatus(xb_but)
-ltsBut = bUtt.getButtonStatus(lts_pr)
-rtsBut = bUtt.getButtonStatus(rts_pr)
-ldPad = bUtt.getButtonStatus(l_dp)
-rdPad = bUtt.getButtonStatus(r_dp)
-udPad = bUtt.getButtonStatus(u_dp)
-ddPad = bUtt.getButtonStatus(d_dp)
 
 ## -End- ##
-list = bUtt.getButtonActiveList()
+#list = bUtt.getButtonActiveList()
 #print(list)
 
 #no input
-def cutOff():
-    
- if (abs(lLR) < axisTh 
-     and abs(lUD) < axisTh 
-     and abs(rLR) < axisTh 
-     and abs(rUD) < axisTh
-     and aBut == False):
-         
-  return True
+#def cutOff():
+#    
+# if (abs(lLR) < axisTh 
+#     and abs(lUD) < axisTh 
+#     and abs(rLR) < axisTh 
+#     and abs(rUD) < axisTh
+#     and aBut == False):
+#         
+#  return True
 
 #fliptricks after manuals
 if (frame - own['last_manual_frame']) < 25:
@@ -3446,10 +3469,6 @@ def footplant():
     lF_air_frame = own['lF_air_frame']
     frames_since_ground = framenum - lF_air_frame
     frames_since_grind = framenum - own['last_grind_frame']
-    #print(frames_since_ground, "fsg")
-    #print(grindHit, r_ground.triggered)
-    #print(own['footplant_on'], own['last_footplant'])
-    #if LAST_GRIND == False and grindHit == True and aBut == True and frames_since_ground < 40 and touched:
     if grindHit == True and aBut == True:
         print("first invert check")
         own.linearVelocity.x = 0
@@ -3466,72 +3485,43 @@ def footplant():
         if skater.isPlayingAction(2925) == False:
             if STANCE == 0:
                 own['requestAction'] = 'reg_fp_rback'
-                print("requesting footplant0")               
+                #print("requesting footplant0")               
             if STANCE == 1:
                 own['requestAction'] = 'fak_fp_rback'
-                print("requesting footplant1")
+                #print("requesting footplant1")
            
 def invert():    
-    if LAST_GRIND == False and grindHit == True and own['grindpos'] == 'reg_board':
+    if grindHit == True and own['grindpos'] == 'reg_board':
+    #if LAST_GRIND == False and grindHit == True and own['grindpos'] == 'reg_board':    
         if lBump == 1:
             #print("invert")
         #if coping_on ==1 and lBump == 1:
-            print("invert")   
+            #print("invert")   
             own['invert_on'] = 1
-            own.setLinearVelocity([0,0,0],0)
-    if own["coping"] == 1 and invert_on == 1:
+            #invert_on = 1
+            own.linearVelocity.x = 0
+            own.linearVelocity.y = 0
+    if own["coping"] == 1 and own['invert_on'] == 1:
         if own['invert_on'] == 1 and own['last_invert'] == False:
             #killall()
             cont.activate(own.actuators['invertOn_sound'])
             if STANCE == False:
                 own['invert_type'] = "reg_back_invert_in"
-            #     skater.playAction("reg_back_invert_in", 10,30, layer=303, play_mode=0, speed=1) 
-            #     deck.playAction("a_reg_back_invert_in", 10,30, layer=303, play_mode=0, speed=1)
-            #     trucks.playAction("a_reg_back_invert_in", 10,30, layer=303, play_mode=0, speed=1) 
             if STANCE == True:
-                own['invert_type'] = "fak_fr_invert"
-            #     skater.playAction("fak_fr_invert", 10,30, layer=303, play_mode=0, speed=1) 
-            #     deck.playAction("a_fak_fr_invert", 10,30, layer=303, play_mode=0, speed=1)
-            #     trucks.playAction("a_fak_fr_invert", 10,30, layer=303, play_mode=0, speed=1)                           
-    if invert_on == 0 and own['last_invert'] == True:
+                own['invert_type'] = "fak_fr_invert"                         
+    if own['invert_on'] == 0 and own['last_invert'] == True:
         #print("kill invert")
         own['last_invert_frame'] = frame
         cont.activate(own.actuators['invertOff_Sound'])
-        
-        # killact(300)
-        # killact(301)
-        # killact(302)    
-        # killact(303)
-        # killact(304)
-        # killact(305) 
-        # killact(700)
-        # killact(700)
-        # killact(700)
-        # killact(290)
-        # killact(291)
-        # killact(292)
-        # if own['invert_type'] == "reg_back_invert_in":
-        #     skater.playAction("reg_back_invert_in", 20,0, layer=306, play_mode=0, speed=1) 
-        #     deck.playAction("a_reg_back_invert_in", 20,0, layer=306, play_mode=0, speed=1)
-        #     trucks.playAction("a_reg_back_invert_in", 20,0, layer=306, play_mode=0, speed=1)
-        # if own['invert_type'] == "fak_fr_invert":    
-        #     skater.playAction("fak_fr_invert", 20,0, layer=306, play_mode=0, speed=1) 
-        #     deck.playAction("a_fak_fr_invert", 20,0, layer=306, play_mode=0, speed=1)
-        #     trucks.playAction("a_fak_fr_invert", 20,0, layer=306, play_mode=0, speed=1)             
-    if invert_on == 1:
+ 
+    if own['invert_on'] == 1:
         if own['invert_type'] == "reg_back_invert_in":
             own['requestAction'] = 'reg_back_invert'
-            #skater.playAction("reg_back_invert_in", 30,30, layer=290, play_mode=1, speed=1) 
-            #deck.playAction("a_reg_back_invert_in", 30,30, layer=290, play_mode=1, speed=1)
-            #trucks.playAction("a_reg_back_invert_in", 30,30, layer=290, play_mode=1, speed=1)
-            
+  
         if own['invert_type'] == "fak_fr_invert":
             own['requestAction'] = 'fak_fr_invert'
-                #skater.playAction("fak_fr_invert", 30,30, layer=290, play_mode=1, speed=1) 
-                #deck.playAction("a_fak_fr_invert", 30,30, layer=290, play_mode=1, speed=1)
-                #trucks.playAction("a_fak_fr_invert", 30,30, layer=290, play_mode=1, speed=1)
     lif = own['last_invert_frame'] 
-    if frame - lif > 3 and invert_on == 0:
+    if frame - lif > 3 and own['invert_on'] == 0:
         own['invert_type'] = None
         
     if grindHit == False:

grindV2.py

@@ -537,7 +537,9 @@ def main():
         #own.alignAxisToVect(vect, 0, 0)
             own.worldPosition = [nearestObject.worldPosition.x, nearestObject.worldPosition.y, nearestObject.worldPosition.z +.1]
             #own.setLinearVelocity([0, 0.0, 0], 1)                    
-        
+            own.linearVelocity.x = 0
+            own.linearVelocity.y = 0
+            print("setting invertpos")
                
             
     
@@ -559,7 +561,7 @@ def main():
         
         if invert_on:
             invertpos(detectedObjects)
-            print('invertOn')
+            #print('invertOn')
 
         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:

inputs.py

@@ -0,0 +1,209 @@
+################################################
+#inputs.py                                     #
+#inputs to global dict                         #
+#shuvit.org                                    #
+################################################
+
+import bge
+from bge import events
+from bge import logic as G
+
+def main():
+#####
+    #init
+    cont = bge.logic.getCurrentController()
+    scene = bge.logic.getCurrentScene()
+    own = cont.owner
+    dict = bge.logic.globalDict #Get the global dictionary
+    aXis = cont.sensors['Joystick.001']
+    bUtt = cont.sensors['Joystick'] 
+    reduction = 400000
+    axisTh = 0.03    
+    
+#hard controller mappings    
+    lar_lts = 0
+    uad_lts = 1
+    lar_rts = 2 
+    uad_rts = 3 
+    lt = 4 
+    rt = 5  
+    a_but = 0 
+    b_but = 1 
+    x_but = 2 
+    y_but = 3 
+    l_bump = 9 
+    r_bump = 10 
+    bk_but = 4 
+    st_but = 6 
+    xb_but = 5 
+    lts_pr = 7 
+    rts_pr = 8 
+    l_dp = 13 
+    r_dp = 14 
+    u_dp = 11 
+    d_dp = 12 
+
+    reduction = 400000
+    axisTh = 0.03    
+
+#get controller axis value 0-100    
+    lLR = aXis.axisValues[lar_lts] / reduction 
+    lUD = aXis.axisValues[uad_lts] / reduction 
+    rLR = aXis.axisValues[lar_rts] / reduction 
+    rUD = aXis.axisValues[uad_rts] / reduction 
+    lTrig = aXis.axisValues[lt] / reduction 
+    rTrig = aXis.axisValues[rt] / reduction 
+
+    aBut = bUtt.getButtonStatus(a_but)
+    bBut = bUtt.getButtonStatus(b_but)
+    xBut = bUtt.getButtonStatus(x_but)
+    yBut = bUtt.getButtonStatus(y_but)
+    lBump = bUtt.getButtonStatus(l_bump)
+    rBump = bUtt.getButtonStatus(r_bump)
+    bkBut = bUtt.getButtonStatus(bk_but)
+    stBut = bUtt.getButtonStatus(st_but)
+    xbBut = bUtt.getButtonStatus(xb_but)
+    ltsBut = bUtt.getButtonStatus(lts_pr)
+    rtsBut = bUtt.getButtonStatus(rts_pr)
+    ldPad = bUtt.getButtonStatus(l_dp)
+    rdPad = bUtt.getButtonStatus(r_dp)
+    udPad = bUtt.getButtonStatus(u_dp)
+    ddPad = bUtt.getButtonStatus(d_dp)
+
+    
+    #create modified axis values
+    if lLR < -20:
+        lmLR = round((lLR + 20) / 80 * 100, 0) 
+    elif lLR > 20:
+        lmLR = round((lLR - 20) / 80 * 100, 0)
+    else: lmLR = 0  
+          
+    if lUD > 20:
+        lmUD = round((lUD - 20) / 80 * 100, 0)
+    elif lUD < -20:
+        lmUD = round((lUD + 20) / 80 * 100, 0)
+    else: lmUD = 0 
+
+    if rLR < -20:
+        rmLR = round((rLR + 20) / 80 * 100, 0)
+    elif rLR > 20:
+        rmLR = round((rLR - 20) / 80 * 100, 0)
+    else: rmLR = 0         
+    
+    if rUD > 20:
+        rmUD = round((rUD - 20) / 80 * 100, 0)
+    elif rUD < -20:
+        rmUD = round((rUD + 20) / 80 * 100, 0)
+    else: rmUD = 0 
+  
+    if lTrig > 3:
+        mTrig = lTrig * -1
+    elif rTrig > 3:
+        mTrig = rTrig    
+    else: mTrig = 0
+    #    
+
+    keyboard = G.keyboard.events
+    # KEY BINDINGS
+    kb_a = events.AKEY 
+    kb_d = events.DKEY 
+    kb_w = events.WKEY
+    kb_s = events.SKEY
+    kb_q = events.QKEY
+    kb_e = events.EKEY
+    kb_z = events.ZKEY
+    kb_c = events.CKEY      
+    kb_en = events.ENTERKEY   
+    kb_la = events.LEFTARROWKEY
+    kb_ra = events.RIGHTARROWKEY
+    kb_ua = events.UPARROWKEY
+    kb_da = events.DOWNARROWKEY
+    #if keyboard[kb_a]:
+    #print(keyboard[kb_a])
+    
+    dict['last_kb_a'] = dict['kb_a']
+    dict['last_kb_d'] = dict['kb_d']
+    dict['last_kb_w'] = dict['kb_w']
+    dict['last_kb_s'] = dict['kb_s']
+    dict['last_kb_q'] = dict['kb_q']
+    dict['last_kb_e'] = dict['kb_e']
+    dict['last_kb_z'] = dict['kb_z']
+    dict['last_kb_c'] = dict['kb_c']  
+    dict['last_kb_en'] = dict['kb_en']  
+    dict['last_kb_la'] = dict['kb_la']
+    dict['last_kb_ra'] = dict['kb_ra']
+    dict['last_kb_ua'] = dict['kb_ua']
+    dict['last_kb_da'] = dict['kb_da']    
+    
+    dict['kb_a'] = keyboard[kb_a]
+    dict['kb_d'] = keyboard[kb_d]
+    dict['kb_w'] = keyboard[kb_w]
+    dict['kb_s'] = keyboard[kb_s]
+    dict['kb_q'] = keyboard[kb_q]
+    dict['kb_e'] = keyboard[kb_e]
+    dict['kb_z'] = keyboard[kb_z]
+    dict['kb_c'] = keyboard[kb_c]    
+    dict['kb_en'] = keyboard[kb_en]
+    dict['kb_la'] = keyboard[kb_la]
+    dict['kb_ra'] = keyboard[kb_ra]
+    dict['kb_ua'] = keyboard[kb_ua]
+    dict['kb_da'] = keyboard[kb_da]        
+    
+    
+    dict['last_aBut'] = dict['aBut']
+    dict['last_bBut'] = dict['bBut']
+    dict['last_xBut'] = dict['xBut']
+    dict['last_yBut'] = dict['yBut']
+    dict['last_lBump'] = dict['lBump']
+    dict['last_rBump'] = dict['rBump']
+    dict['last_bkBut'] = dict['bkBut']
+    dict['last_stBut'] = dict['stBut']
+    dict['last_xbBut'] = dict['xbBut']
+    dict['last_ltsBut'] = dict['ltsBut']
+    dict['last_rtsBut'] = dict['rtsBut']
+    dict['last_ldPad'] = dict['ldPad']
+    dict['last_rdPad'] = dict['rdPad']
+    dict['last_udPad'] = dict['udPad']
+    dict['last_ddPad'] = dict['ddPad']
+    dict['last_rUD'] = dict['rUD']
+    dict['last_lUD'] = dict['lUD']
+    dict['last_rLR'] = dict['rLR']
+    dict['last_lLR'] = dict['lLR']
+    dict['last_rmUD'] = dict['rmUD']
+    dict['last_lmUD'] = dict['lmUD']
+    dict['last_rmLR'] = dict['rmLR']
+    dict['last_lmLR'] = dict['lmLR']
+    dict['last_mTrig'] = dict['mTrig'] 
+    dict['last_rTrig'] = dict['rTrig'] 
+    dict['last_lTrig'] = dict['lTrig']    
+
+    dict['aBut'] = aBut
+    dict['bBut'] = bBut
+    dict['xBut'] = xBut
+    dict['yBut'] = yBut
+    dict['lBump'] = lBump
+    dict['rBump'] = rBump
+    dict['bkBut'] = bkBut
+    dict['stBut'] = stBut
+    dict['xbBut'] = xbBut
+    dict['ltsBut'] = ltsBut
+    dict['rtsBut'] = rtsBut
+    dict['ldPad'] = ldPad
+    dict['rdPad'] = rdPad
+    dict['udPad'] = udPad
+    dict['ddPad'] = ddPad
+    dict['rUD'] = rUD
+    dict['lUD'] = lUD
+    dict['rLR'] = rLR
+    dict['lLR'] = lLR
+    dict['rmUD'] = rmUD
+    dict['lmUD'] = lmUD
+    dict['rmLR'] = rmLR
+    dict['lmLR'] = lmLR
+    dict['mTrig'] = mTrig
+    dict['rTrig'] = rTrig
+    dict['lTrig'] = lTrig
+
+
+main()
+

pause.py

@@ -0,0 +1,388 @@
+import bge
+cont = bge.logic.getCurrentController()
+own = cont.owner
+
+
+os = 'Windows'
+from sys import platform
+if platform != "win32":
+ os = 'Linux'
+def onWindows():
+ return os == 'Windows'
+
+reduction = 400000
+axisTh = 0.03 
+
+#Sensor logic bricks connected to the python Controller  
+aXis = cont.sensors["sControla"]
+bUtt = cont.sensors["sControlb"]
+
+onW = onWindows()
+
+# windows stuff
+lar_lts = 0
+uad_lts = 1
+lt = 4 if onW else 2
+lar_rts = 2 if onW else 3
+uad_rts = 3 if onW else 4
+rt = 5
+
+# These are the numerical values associated with the buttons on the Xbox Controller 
+# Called with - SensorName.getButtonStatus(buttonnumber) - 
+# A joystick sensor logic brick (with the 'Button' Event Type; 'All Events' selected; and 'Tap' enabled) must be connected to the Python Controller logic brick to call these buttons 
+
+a_but = 0 if onW else 0
+b_but = 1 if onW else 1
+x_but = 2 if onW else 2
+y_but = 3 if onW else 3
+l_bump = 9 if onW else 4
+r_bump = 10 if onW else 5
+bk_but = 4 if onW else 6
+st_but = 6 if onW else 7
+xb_but = 5 if onW else 8
+lts_pr = 7 if onW else 9
+rts_pr = 8 if onW else 10
+l_dp = 13 if onW else 11
+r_dp = 14 if onW else 12
+u_dp = 11 if onW else 13
+d_dp = 12 if onW else 14
+
+lLR = aXis.axisValues[lar_lts] / reduction
+lUD = aXis.axisValues[uad_lts] / reduction
+rLR = aXis.axisValues[lar_rts] / reduction
+rUD = aXis.axisValues[uad_rts] / reduction
+lTrig = aXis.axisValues[lt] / reduction
+rTrig = aXis.axisValues[rt] / reduction
+aBut = bUtt.getButtonStatus(a_but)
+bBut = bUtt.getButtonStatus(b_but)
+xBut = bUtt.getButtonStatus(x_but)
+yBut = bUtt.getButtonStatus(y_but)
+lBump = bUtt.getButtonStatus(l_bump)
+rBump = bUtt.getButtonStatus(r_bump)
+bkBut = bUtt.getButtonStatus(bk_but)
+stBut = bUtt.getButtonStatus(st_but)
+xbBut = bUtt.getButtonStatus(xb_but)
+ltsBut = bUtt.getButtonStatus(lts_pr)
+rtsBut = bUtt.getButtonStatus(rts_pr)
+ldPad = bUtt.getButtonStatus(l_dp)
+rdPad = bUtt.getButtonStatus(r_dp)
+udPad = bUtt.getButtonStatus(u_dp)
+ddPad = bUtt.getButtonStatus(d_dp)
+#print(lUD)
+axis_sens = .06
+#print(aBut)
+lasta = own["lasta"]
+
+if lUD > axis_sens: down = 1
+else: down = 0    
+if lUD < -axis_sens: 
+    up = 1 
+    #print("up")
+else: up = 0    
+#print(down, up)
+if lLR > axis_sens: right = 1
+else: right = 0 
+if lLR < -axis_sens: left = 1
+else: left = 0 
+
+fileName = "Settings.dat"
+scenes = bge.logic.getSceneList()
+#print(scenes)
+main_scene = [scene for scene in scenes if scene.name=="main"][0]
+main_empty = main_scene.objects['Empty']
+
+def main():
+
+    cont = bge.logic.getCurrentController()
+    own = cont.owner
+    #down = cont.sensors["down"]
+    #up = cont.sensors["up"]
+    #bBut = cont.sensors["bBut"]
+    #aBut = cont.sensors["aBut"]
+    pstate = own["pstate"]
+    scene = bge.logic.getCurrentScene()
+    resume = scene.objects["resume"]
+    settings = scene.objects["settings"]
+    level = scene.objects["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
+    lastup = own["lastup"]
+    lastdown = own["lastdown"]
+    lastleft = own["lastleft"]
+    lastright = own["lastright"]    
+    lastpstate = own["lastpstate"]
+    playspeed = 2
+    #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'])
+        
+#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 = "Waiting Room"                           
+        if active_level_select == 8:
+            level_text.text = "8 (n/a)"                                                                      
+        own["active_level_select"] = active_level_select 
+#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'])
+            #Settings.loadlevel() 
+        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']) 
+            #Settings.loadlevel()
+        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']) 
+            #Settings.loadlevel()
+        else: cont.deactivate(own.actuators['restart'])
+#level3        
+        if aBut == False and active_level_select == 3 and lasta == 1:
+            level_text.text = ""
+            level = "level3"
+            main_empty["level"] = "city2"
+            own["level"] = level
+            Settings.writeSettings()
+            Settings.readSettings()
+            cont.activate(own.actuators['restart']) 
+            #Settings.loadlevel()
+        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']) 
+            #Settings.loadlevel()
+        else: cont.deactivate(own.actuators['restart']) 
+#training        
+        if aBut == False and active_level_select == 5 and lasta == 1:
+            level_text.text = ""
+            level = "level3"
+            main_empty["level"] = "spine"
+            own["level"] = level
+            Settings.writeSettings()
+            Settings.readSettings()
+            cont.activate(own.actuators['restart']) 
+            #Settings.loadlevel()
+        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']) 
+            #Settings.loadlevel()
+        else: cont.deactivate(own.actuators['restart']) 
+        if aBut == False and active_level_select == 7 and lasta == 1:
+            level_text.text = ""
+            level = "store"
+            main_empty["level"] = "store"
+            own["level"] = level
+            Settings.writeSettings()
+            Settings.readSettings()
+            cont.activate(own.actuators['restart']) 
+            #Settings.loadlevel()
+        else: cont.deactivate(own.actuators['restart']) 
+        if aBut == False and active_level_select == 8 and lasta == 1:
+            level_text.text = ""
+            level = "level3"
+            main_empty["level"] = "spine"
+            own["level"] = level
+            Settings.writeSettings()
+            Settings.readSettings()
+            cont.activate(own.actuators['restart']) 
+            #Settings.loadlevel()
+        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)                
+
+
+    #find the scene and object
+    scenes = bge.logic.getSceneList()
+    for scene in scenes :
+        #if scene.name == 'lot' or scene.name == 'train' or scene.name == 'mini_scene' or scene.name == 'city' or scene.name == 'city2' or scene.name == 'spine':
+        #if scene.name == main_empty["level"]: 
+        if scene.name == 'lot':    
+            #print("*****stop sounds")
+            cc = scene.objects['control_cube.002']
+            cc.actuators["sroll"].volume = .0001
+            #cc.deactivate(own.actuators["sroll"])
+            cc.actuators["sroll"].stopSound()            
+
+
+ 
+    #print(pstate) 
+    own["lastup"] = up
+    own["lastdown"] = down 
+    own["lastleft"] = left
+    own["lastright"] = right 
+    own["lasta"] = aBut 
+    own["lastpstate"] = own["pstate"]
+main()

walk.py

@@ -1,7 +1,7 @@
-os = 'Windows'
-from sys import platform
-if platform != "win32":
- os = 'Linux'
+#os = 'Windows'
+#from sys import platform
+#if platform != "win32":
+ #os = 'Linux'
 def onWindows():
  return os == 'Windows'
 import bge
@@ -14,8 +14,8 @@ import random
 scene = bge.logic.getCurrentScene()
 objList = scene.objects
 
-reduction = 400000
-axisTh = 0.03 
+#reduction = 400000
+#axisTh = 0.03 
 
 ############
 ##vibration#
@@ -51,12 +51,13 @@ stance = own['stance']
 STANCE = own['stance']
 r_ground = cont.sensors["r_Ground"]
 #Sensor logic bricks connected to the python Controller  
-aXis = cont.sensors["sControla.001"]
-bUtt = cont.sensors["sControlb.001"]
+#aXis = cont.sensors["sControla.001"]
+#bUtt = cont.sensors["sControlb.001"]
 linvel = own.getLinearVelocity(True)
 lasta = own['lasta']
 lastx = own['lastx']
 last_sit = own['sit']
+dict = bge.logic.globalDict
 
 try:
     own['walk_timer'] = own['walk_timer'] +1
@@ -66,53 +67,53 @@ except:
 truckon = 30
 deckon = 30
 
-onW = onWindows()
+#onW = onWindows()
 
 # windows stuff
-lar_lts = 0
-uad_lts = 1
-lt = 4 if onW else 2
-lar_rts = 2 if onW else 3
-uad_rts = 3 if onW else 4
-rt = 5
+#lar_lts = 0
+#uad_lts = 1
+#lt = 4 if onW else 2
+#lar_rts = 2 if onW else 3
+#uad_rts = 3 if onW else 4
+#rt = 5
 
-a_but = 0 if onW else 0
-b_but = 1 if onW else 1
-x_but = 2 if onW else 2
-y_but = 3 if onW else 3
-l_bump = 9 if onW else 4
-r_bump = 10 if onW else 5
-bk_but = 4 if onW else 6
-st_but = 6 if onW else 7
-xb_but = 5 if onW else 8
-lts_pr = 7 if onW else 9
-rts_pr = 8 if onW else 10
-l_dp = 13 if onW else 11
-r_dp = 14 if onW else 12
-u_dp = 11 if onW else 13
-d_dp = 12 if onW else 14
+#a_but = 0 if onW else 0
+#b_but = 1 if onW else 1
+#x_but = 2 if onW else 2
+#y_but = 3 if onW else 3
+#l_bump = 9 if onW else 4
+#r_bump = 10 if onW else 5
+#bk_but = 4 if onW else 6
+#st_but = 6 if onW else 7
+#xb_but = 5 if onW else 8
+#lts_pr = 7 if onW else 9
+#rts_pr = 8 if onW else 10
+#l_dp = 13 if onW else 11
+#r_dp = 14 if onW else 12
+#u_dp = 11 if onW else 13
+#d_dp = 12 if onW else 14
 
-lLR = aXis.axisValues[lar_lts] / reduction
-lUD = aXis.axisValues[uad_lts] / reduction
-rLR = aXis.axisValues[lar_rts] / reduction
-rUD = aXis.axisValues[uad_rts] / reduction
-lTrig = aXis.axisValues[lt] / reduction
-rTrig = aXis.axisValues[rt] / reduction
-aBut = bUtt.getButtonStatus(a_but)
-bBut = bUtt.getButtonStatus(b_but)
-xBut = bUtt.getButtonStatus(x_but)
-yBut = bUtt.getButtonStatus(y_but)
-lBump = bUtt.getButtonStatus(l_bump)
-rBump = bUtt.getButtonStatus(r_bump)
-bkBut = bUtt.getButtonStatus(bk_but)
-stBut = bUtt.getButtonStatus(st_but)
-xbBut = bUtt.getButtonStatus(xb_but)
-ltsBut = bUtt.getButtonStatus(lts_pr)
-rtsBut = bUtt.getButtonStatus(rts_pr)
-ldPad = bUtt.getButtonStatus(l_dp)
-rdPad = bUtt.getButtonStatus(r_dp)
-udPad = bUtt.getButtonStatus(u_dp)
-ddPad = bUtt.getButtonStatus(d_dp)
+lLR = dict['lLR']
+lUD = dict['lUD']
+rLR = dict['rLR']
+rUD = dict['rUD']
+lTrig = dict['lTrig']
+rTrig = dict['rTrig']
+aBut = dict['aBut']
+bBut = dict['bBut']
+xBut = dict['xBut']
+yBut = dict['yBut']
+lBump = dict['lBump']
+rBump = dict['rBump']
+bkBut = dict['bkBut']
+stBut = dict['stBut']
+xbBut = dict['xbBut']
+ltsBut = dict['ltsBut']
+rtsBut = dict['rtsBut']
+ldPad = dict['ldPad']
+rdPad = dict['rdPad']
+udPad = dict['udPad']
+ddPad = dict['ddPad']
 
 #user
 sens = .04
@@ -120,15 +121,15 @@ fliplay = 30
 dropinCol = own.sensors['dropinCol']
 
 #no input
-def cutOff():
-    
- if (abs(lLR) < axisTh 
-     and abs(lUD) < axisTh 
-     and abs(rLR) < axisTh 
-     and abs(rUD) < axisTh
-     and aBut == False):
-         
-  return True
+#def cutOff():
+#    
+# if (abs(lLR) < axisTh 
+#     and abs(lUD) < axisTh 
+#     and abs(rLR) < axisTh 
+#     and abs(rUD) < axisTh
+#     and aBut == False):
+#         
+#  return True
 skater = scene.objects["Char4"]
 deck = scene.objects["deck"]
 trucks = scene.objects["trucks"]