moving scripts folder

scripts/DList.py

+""" A node is a container which encapsulates any type of data.
+    The node object also has a reference to the NODE preceding and following
+    said object."""
+class Node(object):
+ 
+    def __init__(self, data, prev, next):
+        self.data = data
+        self.prev = prev
+        self.next = next
+        
+    def getNext(self):
+        if self.next is not None:
+            return self.next
+        print('There\'s nothing next, trying prev')
+        if self.prev is not None:
+            return self.prev
+        print('There\s nothing before either, just this one')
+        return self
+        
+    def getPrev(self):
+        if self.prev is not None:
+            return self.prev
+        print('There\'s nothing before, trying next')
+        if self.next is not None:
+            return self.next
+        print('There\'s nothing next either, just this one')
+        return self
+        
+    def getData(self):
+        return self.data
+ 
+""" A doubly-linked list implementation 
+    NOTE: the getters and setters return a reference to a Node object,
+    inside which is the data you're probably looking for. If you want to
+    access data, remember; after you call a get or find, use .data"""
+class DoubleList(object):
+ 
+    head = None
+    tail = None
+    length = 0;
+ 
+    """ Add a node to the list """
+    def append(self, data):
+        new_node = Node(data, None, None)
+        if self.head is None:
+            self.head = self.tail = new_node
+        else:
+            new_node.prev = self.tail
+            new_node.next = None
+            self.tail.next = new_node
+            self.tail = new_node
+        self.length = self.length + 1
+ 
+    """ Find a node in the list, then remove it """
+    def remove(self, node):
+        current_node = self.head
+ 
+        while current_node is not None:
+            if current_node == node:
+                # if it's not the first element
+                if current_node.prev is not None:
+                    current_node.prev.next = current_node.next
+                    current_node.next.prev = current_node.prev
+                # if its the last element
+                elif current_node.next is None:
+                    self.tail = current_node.prev
+                    self.tail.prev = current_node.prev.prev
+                    self.tail.next = None
+                else:
+                    # otherwise we have no prev (it's None), head is the next one, and prev becomes None
+                    self.head = current_node.next
+                    current_node.next.prev = None
+ 
+            current_node = current_node.next
+        self.length = self.length - 1
+    
+    def show(self):
+        print("Show list data:")
+        current_node = self.head
+        while current_node is not None:
+            print(current_node.data)
+            current_node = current_node.next
+        print("*"*50)
+        
+    """ Find a node in the list by value comparison """
+    def findNode(self, node_value):
+        current_node = self.head
+        
+        while current_node is not None:
+            if current_node.data == node_value:
+                return current_node
+            current_node = current_node.next
+    
+    """ Get a node by index position """
+    def get(self, index):
+        if index > self.length:
+            return none
+        elif index == 1:
+            return self.head
+        elif index == self.length:
+            return self.tail
+        else:
+            current_node = self.head
+            pos = 1
+            while pos < index:
+                current_node = current_node.next
+                pos = pos + 1
+            return current_node
+    
+    """ Checks if a node is in this list """
+    def contains(self, node):
+        current_node = self.head
+        while current_node is not None:
+            if current_node == node:
+                return true
+            current_node = current_node.next
+        return false
+        
+    """ Get the length of this list """
+    def getLength(self):
+        return self.length
+        
+    """ Get the head of this list """
+    def getHead(self):  # get head (;
+        return self.head
+        
+    """ Get the tail of this list """
+    def getTail(self):
+        return self.tail

scripts/Manager.py

+def main():
+
+    #"""
+    #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']    
+            
+        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)
+
+        #if cont.sensors[record_sensor].positive:
+        if own["playback"] != True:    
+            Record.main(recording_cutoff, cube)
+            
+        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
+            cube['grindcement_vol'] = 0
+            cube['grindcement_pitch'] = 0
+            cube['grindrail_vol'] = 0
+            cube['grindrail_pitch'] = 0 
+            cube['sroll_vol'] = 0
+            cube['sroll_pitch'] = 0             
+            
+
+        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 and pause_state == 0:
+                #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 dict['rtsBut'] == False and dict['last_rtsBut'] == True and own['playback'] == 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 and pause_state == 0:
+            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
+#            perc = (lUD * 100 * (10 / 80)) *2
+#            perc = round(perc,2)
+#            print(perc)
+#            perc = .025 * perc
+#            newUD = (lUD * .1) * 5
+#            if lUD > .0005 or lUD < -.0005:
+#                camspeed1 = abs(perc)
+#                camspeed2 = abs(perc)
+            #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']
+        dict['playback'] = own['playback']

scripts/MusicPlayer.py

+import bge
+import os
+import aud
+import random
+import glob
+from DList import DoubleList
+from collections import OrderedDict
+from tinytag import TinyTag
+
+""" This is the Music Player as a component """
+class MusicPlayer(bge.types.KX_PythonComponent):
+
+    args = OrderedDict([])    
+
+    def start(self, args):
+        # dictionary
+        self.dictionary = bge.logic.globalDict
+        
+        # get mp3 files from the disk and create a list
+        self.directory = bge.logic.expandPath('//Music')
+        file_name = self.directory + '\\*.mp3'
+        file_list =  glob.glob(file_name)
+        
+        # use the mp3 list to make a playlist of nodes
+        self.playlist = DoubleList()
+        for name in file_list:
+            self.playlist.append(name)
+        
+        # previously played list of nodes
+        self.alreadyPlayed = DoubleList()
+        
+        # get a random song from the playlist, 
+        # remove it from the playlist
+        # add it to the alreadyPlayed list
+        # NOTICE: currentNode is a reference to a NODE in a list, if you want to play the song inside the node, use .data
+        self.currentNode = self.playlist.get(random.randint(0, self.playlist.getLength()))
+        self.nowPlaying = self.currentNode.getData()
+        self.playlist.remove(self.currentNode)
+        self.alreadyPlayed.append(self.nowPlaying)
+        print("Now Playing: " + self.nowPlaying)
+        self.setTag()
+        self.isPlaying = False
+
+        # create audio devices
+        self.device = aud.device()
+        self.factory = aud.Factory(self.nowPlaying)
+        self.handle = None        
+    
+    """ Update is called once every frame, and this is where
+        any input handling should go
+        
+        Controller Buttons: 
+        Y-Button - Play/Pause
+        LB       - Previous Track
+        RB       - Next Track
+        
+        TODO: Keyboard Buttons if these aren't alright
+        P        - Play/Pause
+        Pad Plus - Next Track
+        Pad Minus- Prev Track
+    """
+    def update(self):
+        keyboard = bge.logic.keyboard.events
+        up_dict = bge.logic.globalDict
+        #print(dictionary)
+        pKey = keyboard[bge.events.PKEY]
+        pPlus = keyboard[bge.events.PADPLUSKEY]
+        pMinus = keyboard[bge.events.PADMINUS]
+        lb = up_dict['lBump']
+        last_lb = up_dict['last_lBump']
+        rb = up_dict['rBump']
+        last_rb = up_dict['last_rBump']
+        y = up_dict['yBut']
+        last_y = up_dict['last_yBut']
+        JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
+        
+
+        #Run player on startup
+        if up_dict['music_start'] == True:
+            if self.isPlaying:
+                self.stopMusic()
+            else:
+                self.playMusic()                 
+            up_dict['music_start'] = False               
+
+        # Music controls only during pause/replay
+        if (up_dict['npause'] == True or up_dict['playback'] == True) or up_dict['music_start'] == True:
+            #stop/play
+            if (y == False and last_y == True) or pKey == JUST_ACTIVATED:
+                if self.isPlaying:
+                    self.stopMusic()
+                    up_dict['music_player'] = 0
+                else:
+                    self.playMusic()
+                    up_dict['music_player'] = 1
+            # Prev/Next
+            if self.isPlaying and self.handle.status:
+                if pMinus == JUST_ACTIVATED or (lb == False and last_lb == True):
+                    self.prevSong()
+                
+                if pPlus == JUST_ACTIVATED or (rb == False and last_rb == True):
+                    self.nextSong()
+        # if song ends, play next song
+        if self.isPlaying and not self.handle.status:
+            self.nextSong()
+
+    """ get info about song using TinyTag, then print to console """
+    def setTag(self):                
+        self.currTrackPath = os.path.join(self.directory, self.nowPlaying)
+        tag = TinyTag.get(self.currTrackPath)
+        self.currArtist = tag.artist
+        self.currTrackTitle = tag.title
+        self.dictionary['mu_artist'] = self.currArtist
+        self.dictionary['mu_title'] = self.currTrackTitle
+                
+        print('Artist: %s' % self.currArtist, 
+                ' Track: %s' % self.currTrackTitle)
+
+    def playMusic(self):
+        print('Play Music')
+        self.setTag()
+        self.handle = self.device.play(self.factory)
+        self.isPlaying = True
+        
+    def stopMusic(self):
+        print('Stop Music')
+        self.handle.stop()
+        self.isPlaying = False
+        
+    def nextSong(self):
+        print('Next Song')
+        # stop the current song
+        self.handle.stop()
+        
+        # get a song from the playlist
+        self.currentNode = self.playlist.get(random.randint(0, self.playlist.getLength()))
+        self.nowPlaying = self.currentNode.getData()
+        self.playlist.remove(self.currentNode)
+                
+        # add the song to the already played list
+        self.alreadyPlayed.append(self.nowPlaying)  
+        
+        # start the song
+        self.factory = aud.Factory(self.nowPlaying)
+        self.handle = self.device.play(self.factory)
+        self.setTag()
+        
+        # If playlist is empty, re-fill it
+        if self.playlist.getLength() == 0:
+            file_name = self.directory + '\\*.mp3'
+            file_list =  glob.glob(file_name)
+            for name in file_list:
+                self.playlist.append(name)
+        
+    """ Note on first call of this method, the current node will be equal to the tail of the already played list, 
+        however, it will be a node from a different list. We need to set current node equal to the tail node
+        of the already played list so that we can iterate through that list, instead of the other list """
+    def prevSong(self):
+        print('Prev Song')
+        # stop the current song
+        self.handle.stop()        
+        
+        if self.currentNode.getData() == self.alreadyPlayed.getTail().getData():
+            self.currentNode = self.alreadyPlayed.getTail()
+            
+        self.currentNode = self.currentNode.getPrev()
+        self.nowPlaying = self.currentNode.getData()
+        
+        # start the song
+        self.factory = aud.Factory(self.nowPlaying)
+        self.handle = self.device.play(self.factory)
+        self.setTag()

scripts/README.md

+# shuvit
+Open source skateboarding game made with UPBGE / Blender.

scripts/Record.py

+#record
+from bge import logic
+from mathutils import Vector
+from SortData import *
+
+cont = logic.getCurrentController()
+own = cont.owner
+scene = logic.getCurrentScene()
+cube = scene.objects["control_cube.002"]
+#obj = scene.objects["control_cube.002"]
+#sound_empty = scene.objects['replay_sound_empty']
+path = logic.expandPath(own["filePath"])
+
+PAF = 0
+DAF = 0
+
+deck = scene.objects["deck"]
+trucks = scene.objects["trucks"]
+
+throw_deck_empty = scene.objects["throw_deck_empty"]
+wheel1 = scene.objects["rollen.000"]
+wheel2 = scene.objects["rollen.001"]
+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"]
+wheel1act = wheel1.actuators["Visibility"]
+wheel2act = wheel2.actuators["Visibility"]
+wheel3act = wheel3.actuators["Visibility"]
+wheel4act = wheel4.actuators["Visibility"]
+
+class getData:
+
+
+
+    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): 
+        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.addOrientation(obj, orientation, 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   
+        writeData.addVisibility(obj, str(visible), cut)
+    
+    def saveSkaterAnim(obj, cut):
+        import bge
+        scene = bge.logic.getCurrentScene()
+        skater = scene.objects["Char4"]
+        deck = scene.objects["deck"]
+        trucks = scene.objects["trucks"]
+        playing_layer = 0
+        for x in range(7):
+            l1 = skater.isPlayingAction(x)
+            if l1 == True:
+                playing_layer = x
+                #print(x)
+        playing_action = skater.getActionName(playing_layer)
+        playing_action_frame = skater.getActionFrame(playing_layer)
+        PAF = playing_action_frame
+        own['PAF'] = PAF
+       #print(playing_action, playing_action_frame)        
+        writeData.addSkaterAnim(obj, str(playing_action), cut)
+        
+    def saveSkaterAnimF(obj, cut):
+        PAF = own['PAF']
+        writeData.addSkaterAnimF(obj, str(PAF), cut)   
+        
+    def saveDeckAnim(obj, cut):
+        import bge
+        scene = bge.logic.getCurrentScene()
+        skater = scene.objects["Char4"]
+        deck = scene.objects["deck"]
+        trucks = scene.objects["trucks"]
+        wheel1 = scene.objects["rollen.000"]
+        wheel2 = scene.objects["rollen.001"]
+        wheel3 = scene.objects["rollen.002"]
+        wheel4 = scene.objects["rollen.003"]        
+        playing_layer = 0
+        for x in range(7):
+            l1 = deck.isPlayingAction(x)
+            if l1 == True:
+                playing_layer = x
+                #print(x)
+        playing_action = deck.getActionName(playing_layer)
+        playing_action_frame = deck.getActionFrame(playing_layer)
+        DAF = playing_action_frame
+        own['DAF'] = DAF
+       #print(playing_action, playing_action_frame)        
+        writeData.addDeckAnim(obj, str(playing_action), cut)
+        
+    def saveDeckAnimF(obj, cut):
+        DAF = own['DAF']
+        writeData.addDeckAnimF(obj, str(DAF), cut)
+
+    def saveSrollVol(obj, cut):
+        num = cube['sroll_vol']
+        writeData.addSrollVol(obj, str(num), cut) 
+    def saveSrollPitch(obj, cut):
+        num = cube['sroll_pitch']
+        writeData.addSrollPitch(obj, str(num), cut) 
+    
+    def saveSgrind_cementVol(obj, cut):
+        num = cube['grindcement_vol']
+        writeData.addSgrind_cementVol(obj, str(num), cut) 
+    def saveSgrind_cementPitch(obj, cut):
+        num = cube['grindcement_pitch']
+        writeData.addSgrind_cementPitch(obj, str(num), cut) 
+    def saveSgrind_railVol(obj, cut):
+        num = cube['grindrail_vol']
+        writeData.addSgrind_railVol(obj, str(num), cut) 
+    def saveSgrind_railPitch(obj, cut):
+        num = cube['grindrail_pitch']
+        writeData.addSgrind_railPitch(obj, str(num), cut)
+    def saveSpopsound(obj, cut):
+        num = cube['pop_sound']
+        writeData.addSpopsound(obj, str(num), cut) 
+    def saveSlandsound(obj, cut):
+        num = cube['land_sound']
+        writeData.addSlandsound(obj, str(num), cut) 
+    def saveSdeckvis(obj, cut):
+        num = cube['deckvis']
+        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():
+    
+    #Function for loading the data from
+    #the disk and setting it.
+    
+    objIndex = own["objIndex"]
+    own["valueIndex"] = objIndex + 1
+    valueIndex = own["valueIndex"]
+    playbackSpeed = own["playbackSpeed"]
+    loadedPosition = own["loadedPosition"]
+    loadedOrientation = own["loadedOrientation"]
+    loadedScale = own["loadedScale"]
+    loadedColor = own["loadedColor"]
+    loadedVisibility = own["loadedVisibility"]
+    loadedSkaterAnim = own["loadedSkaterAnim"]
+    loadedSkaterAnimf = own["loadedSkaterAnimF"]
+    loadedDeckAnim = own["loadedDeckAnim"]
+    loadedDeckAnimf = own["loadedDeckAnimF"]
+    loadedSrollVol = own["loadedSrollVol"]
+    loadedSrollPitch = own["loadedSrollPitch"]
+    loadedSgrind_cementlVol = own["loadedSgrind_cementVol"]
+    loadedSgrind_cementPitch = own["loadedSgrind_cementPitch"]
+    loadedSgrind_railVol = own["loadedSgrind_railVol"]
+    loadedSgrind_railPitch = own["loadedSgrind_railPitch"] 
+    loadedSpopsound = own["loadedSpopsound"]            
+    loadedSlandsound = own["loadedSlandsound"] 
+    loadedSdeckvis = own["loadedSdeckvis"]  
+    loadedtdPosition = own["loadedtdPosition"]
+    loadedtdOrientation = own["loadedtdOrientation"]      
+    loadedSrevertsound = own["loadedSrevertsound"] 
+    
+    skater = scene.objects["Char4"]
+    deck = scene.objects["deck"]
+    trucks = scene.objects["trucks"]
+    
+    num = 1
+    obj = scene.objects['control_cube.002']
+    if num == 1:    
+    #for obj in scene.objects:        
+        if not "recorder" in obj:
+            obj.state = 100
+            obj.suspendDynamics()
+                     
+    readData.loadAll()    #Load the file!!!
+    
+    #-----Position-----#
+    own["lengthPos"] = readData.getLengthPos()
+    lengthPos = own["lengthPos"] 
+    
+    if lengthPos:
+        
+        if objIndex > lengthPos-1:
+            own["objIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthPos-2
+
+        name, position = readData.returnPosition(objIndex, valueIndex)
+        
+        if name in scene.objects:
+            try:
+                scene.objects[name].worldPosition = position
+                scene.objects['replay_sound_empty'].worldPosition = position
+                #print("replay_sound_empty changing position")
+            except:
+                pass
+    #-----Orientation-----#
+    own["lengthOri"] = readData.getLengthOri()   
+    lengthOri = own["lengthOri"]
+    
+    #if lengthPos:
+    if lengthOri:
+  
+        if valueIndex > lengthOri-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthOri-2
+
+        name, orientation = readData.returnOrientation(objIndex, valueIndex)
+        
+        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:
+                scene.objects[name].localOrientation = oXYZ.to_matrix()
+            except:
+                pass
+    #-----Scale-----#
+    own["lengthSca"] = readData.getLengthSca()
+    lengthSca = own["lengthSca"]
+    
+    if lengthSca:
+    
+        if valueIndex > lengthSca-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthSca-2
+       
+        name, scale = readData.returnScale(objIndex, valueIndex)
+        
+        if name in scene.objects:
+            try:
+                scene.objects[name].localScale = scale
+            except:
+                pass
+    #-----Color-----#
+    own["lengthCol"] = readData.getLengthCol()   
+    lengthCol = own["lengthCol"]
+    
+    if lengthCol:
+
+        if valueIndex > lengthCol-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthCol-2
+
+        name, color = readData.returnColor(objIndex, valueIndex)
+        
+        if name in scene.objects:
+            try:
+                scene.objects[name].color = color
+            except:
+                pass
+    #-----Visibility-----#
+    own["lengthVis"] = readData.getLengthVis()
+    lengthVis = own["lengthVis"]
+    
+    if lengthVis:
+
+        if valueIndex > lengthVis-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthVis-2
+
+        name, visible = readData.returnVisibility(objIndex, valueIndex)
+        
+        if name in scene.objects:
+            try:
+                scene.objects[name].visible = int(visible)
+            except:
+                pass
+    #-----Skater Animation Name-----#
+    own["lengthSkaterAnim"] = readData.getLengthSkaterAnim()
+    lengthSkaterAnim = own["lengthSkaterAnim"]
+    #print("lengthskateranim", lengthSkaterAnim)
+    if lengthSkaterAnim:
+
+        if valueIndex > lengthSkaterAnim-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthSkaterAnim-2
+
+        name, skateranim = readData.returnSkaterAnim(objIndex, valueIndex)
+        name, PAF = readData.returnSkaterAnimF(objIndex, valueIndex)
+        #print(PAF)
+        PAF = float(PAF)
+        if name in scene.objects:
+            #print("name in")
+            try:
+                skater.stopAction(0)
+                skater.stopAction(1)
+                skater.stopAction(2)
+                skater.stopAction(3)
+                skater.stopAction(9999)
+                if skater != '':
+                    skater.playAction(skateranim, PAF,PAF, layer=9999, play_mode=1, speed=1)
+                #print("Playing: ", skateranim, PAF)
+            except:
+                print("something is wrong")
+                #pass  
+                
+                
+    #-----Deck Animation Name-----#
+    own["lengthDeckAnim"] = readData.getLengthDeckAnim()
+    lengthDeckAnim = own["lengthDeckAnim"]
+    #print("lengthDeckanim", lengthDeckAnim)
+    if lengthDeckAnim:
+
+        if valueIndex > lengthDeckAnim-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthDeckAnim-2
+
+        name, deckanim = readData.returnDeckAnim(objIndex, valueIndex)
+        name, DAF = readData.returnDeckAnimF(objIndex, valueIndex)
+        #print(DAF)
+        DAF = float(DAF)
+        if name in scene.objects:
+            #print("name in")
+            try:
+                deck.stopAction(0)
+                deck.stopAction(1)
+                deck.stopAction(2)
+                deck.stopAction(3)
+                deck.stopAction(9999)
+                #print(deckanim)
+                if deckanim != '':
+                    turnList = ['a_reg_right', 'a_reg_left', 'a_fak_right', 'a_fak_left']
+                    #print(deckanim)
+                    if deckanim not in turnList:
+                        deck.playAction(deckanim, DAF,DAF, layer=9999, play_mode=1, speed=1)
+                        trucks.playAction(deckanim, DAF,DAF, layer=9999, play_mode=1, speed=1)
+                    else:
+                        print('play a_reg')  
+                        deck.playAction(deckanim, DAF,DAF, layer=9999, play_mode=1, speed=1)
+                        trucks.playAction('a_reg', DAF,DAF, layer=9999, play_mode=1, speed=1)                          
+                #print("Playing: ", deckanim, PAF)
+            except:
+                print("deck something is wrong")
+                #pass  
+
+#
+    #-----sroll-----#
+    own["lengthSrollVol"] = readData.getLengthSrollVol()
+    lengthSrollVol = own["lengthSrollVol"]
+    if lengthSrollVol:
+        if valueIndex > lengthSrollVol-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthSrollVol-2
+        name, srollVol = readData.returnSrollVol(objIndex, valueIndex)
+        name, srollPitch = readData.returnSrollPitch(objIndex, valueIndex)    
+        if name in scene.objects:
+            try:
+                cube = scene.objects["control_cube.002"]
+                srollVol = round(srollVol, 2)
+                act = cube.actuators["sroll"]
+                if srollVol < .12:
+                    act.volume = srollVol
+                    act.pitch = srollPitch
+                act.startSound()
+            except:
+                pass
+###            
+#
+    #-----grind cement-----#
+    own["lengthSgrind_cementVol"] = readData.getLengthSgrind_cementVol()
+    lengthSgrind_cementVol = own["lengthSgrind_cementVol"]
+    if lengthSgrind_cementVol:
+        if valueIndex > lengthSgrind_cementVol-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthSgrind_cementVol-2
+        name, sgrind_cementVol = readData.returnSgrind_cementVol(objIndex, valueIndex)
+        name, sgrind_cementPitch = readData.returnSgrind_cementPitch(objIndex, valueIndex)    
+        if name in scene.objects:
+            try:
+                cube = scene.objects["control_cube.002"]
+                sgrind_cementVol = round(sgrind_cementVol, 2)
+                act = cube.actuators["grind_cement"]
+                if sgrind_cementVol < .2:
+                    act.volume = sgrind_cementVol
+                    act.pitch = sgrind_cementPitch
+                act.startSound()
+                
+            except:
+                pass
+###    
+#
+    #-----grind rail-----#
+    own["lengthSgrind_railVol"] = readData.getLengthSgrind_railVol()
+    lengthSgrind_railVol = own["lengthSgrind_railVol"]
+    if lengthSgrind_railVol:
+        if valueIndex > lengthSgrind_railVol-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthSgrind_railVol-2
+        name, sgrind_railVol = readData.returnSgrind_railVol(objIndex, valueIndex)
+        name, sgrind_railPitch = readData.returnSgrind_railPitch(objIndex, valueIndex)    
+        if name in scene.objects:
+            try:
+                cube = scene.objects["control_cube.002"]
+                sgrind_railVol = round(sgrind_railVol, 2)
+                act = cube.actuators["grind_rail"]
+                if sgrind_railVol < .2:
+                    act.volume = sgrind_railVol
+                    act.pitch = sgrind_railPitch
+                act.startSound()
+                #print("grindsound = ", sgrind_railVol, sgrind_railPitch)
+            except:
+                pass
+###  
+#
+    #-----pop sound-----#
+    own["lengthSpopsound"] = readData.getLengthSpopsound()
+    lengthSpopsound = own["lengthSpopsound"]
+    if lengthSpopsound:
+        if valueIndex > lengthSpopsound-1:
+            own["valueIndex"] = 0
+        if objIndex < 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:
+                print("sound passed")
+                pass
+###
+#
+    #-----land sound-----#
+    own["lengthSlandsound"] = readData.getLengthSlandsound()
+    lengthSlandsound = own["lengthSlandsound"]
+    if lengthSlandsound:
+        if valueIndex > lengthSlandsound-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthSlandsound-2
+        name, slandsound = readData.returnSlandsound(objIndex, valueIndex)   
+        if name in scene.objects:
+            try:
+                cube = scene.objects["control_cube.002"]
+                slandsound = round(slandsound, 2)
+                act = cube.actuators["land"]
+                if slandsound == 1:
+                    act.volume = .6
+                    act.startSound()
+                #print("grindsound = ", slandsound, sgrind_railPitch)
+            except:
+                pass
+###  
+###
+#
+    #-----land sound-----#
+    own["lengthSdeckvis"] = readData.getLengthSdeckvis()
+    lengthSdeckvis = own["lengthSdeckvis"]
+    if lengthSdeckvis:
+        if valueIndex > lengthSdeckvis-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthSdeckvis-2
+        name, sdeckvis = readData.returnSdeckvis(objIndex, valueIndex)   
+        
+        
+        if name in scene.objects:
+            try:
+                cube = scene.objects["control_cube.002"]
+                if sdeckvis == 1:
+                    #print('setting deck visible')
+                    deckact.visibility = True
+                    trucksact.visibility = True
+                    wheel1act.visibility = True
+                    wheel2act.visibility = True
+                    wheel3act.visibility = True
+                    wheel4act.visibility = True   
+                    cont.activate(deck.actuators['Visibility'])
+                    cont.activate(trucks.actuators['Visibility'])
+                    cont.activate(wheel1.actuators['Visibility'])
+                    cont.activate(wheel2.actuators['Visibility'])
+                    cont.activate(wheel3.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')
+                    deckact.visibility = False
+                    trucksact.visibility = False
+                    wheel1act.visibility = False
+                    wheel2act.visibility = False
+                    wheel3act.visibility = False
+                    wheel4act.visibility = False   
+                    cont.activate(deck.actuators['Visibility'])
+                    cont.activate(trucks.actuators['Visibility'])
+                    cont.activate(wheel1.actuators['Visibility'])
+                    cont.activate(wheel2.actuators['Visibility'])
+                    cont.activate(wheel3.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
+
+                                            
+                       
+def main(recording_cutoff, cc):
+    num = 1
+    obj = scene.objects["control_cube.002"]
+    if num == 1:
+        
+    #for obj in scene.objects:
+        if "record_position" in obj:
+            getData.savePosition(obj, recording_cutoff)
+        if "record_orientation" in obj:
+            getData.saveOrientation(obj, recording_cutoff)
+        if "record_scale" in obj:
+            getData.saveScale(obj, recording_cutoff)
+        if "record_color" in obj:
+            getData.saveColor(obj, recording_cutoff)
+        if "record_state" in obj:
+            getData.saveState(obj, recording_cutoff)
+        if "record_visibility" in obj:
+            getData.saveVisibility(obj, recording_cutoff)
+        if "record_skateranim" in obj:
+            getData.saveSkaterAnim(obj, recording_cutoff)
+        if "record_skateranimf" in obj:
+            getData.saveSkaterAnimF(obj, recording_cutoff) 
+        if "record_deckanim" in obj:
+            getData.saveDeckAnim(obj, recording_cutoff)
+        if "record_deckanimf" in obj:
+            getData.saveDeckAnimF(obj, recording_cutoff)    
+        #if "record_sroll_vol" in obj:
+        getData.saveSrollVol(obj, recording_cutoff)
+        #if "record_sroll_pitch" in obj:
+        getData.saveSrollPitch(obj, recording_cutoff)
+        getData.saveSgrind_cementVol(obj, recording_cutoff)
+        getData.saveSgrind_cementPitch(obj, recording_cutoff)
+        getData.saveSgrind_railVol(obj, recording_cutoff)
+        getData.saveSgrind_railPitch(obj, recording_cutoff)
+        getData.saveSpopsound(obj, recording_cutoff)            
+        getData.saveSlandsound(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():
+    num = 1
+    obj = scene.objects["control_cube.002"]
+    if num == 1:
+    #for obj in scene.objects:
+        obj.restoreDynamics()
+        try:
+            name, state = readData.returnState(own["objIndex"], own["valueIndex"])
+            obj.state = state
+        except:
+            pass

scripts/Settings.py

+import bge
+import GameLogic
+import configobj
+from configobj import ConfigObj
+
+mainDir = GameLogic.expandPath("//")
+
+fileName = mainDir + "config.ini"
+
+config = ConfigObj(fileName, interpolation=True)
+dict = bge.logic.globalDict
+
+print('###############start game##########')
+dict['music_player'] = 1
+
+def to_dict(section, key):
+    dict = bge.logic.globalDict
+    value = config[key]
+    if isinstance(value, str):
+        if value.isdigit():
+            value = int(value)
+        else:
+            try:
+                value = float(value)
+            except:
+                pass
+    dict[key] = value  
+
+def readSettings():
+    config.walk(to_dict)     
+
+def from_dict(section, key):
+    dict = bge.logic.globalDict
+    config[key] = dict[key]
+
+def writeSettings():
+    config.walk(from_dict)  
+    config.write()    
+          
+def setres():
+    import GameLogic
+    import bge
+    scenes = bge.logic.getSceneList()
+    main_scene = [scene for scene in scenes if scene.name=="main"][0]
+    own = main_scene.objects['Empty']
+    cont = GameLogic.getCurrentController()
+    own2 = cont.owner
+    dict = bge.logic.globalDict 
+    resx = int(dict["resx"])
+    resy = int(dict["resy"])
+    fullscreen = bge.render.getFullScreen()
+    print("fullscreen = ", fullscreen)
+    if fullscreen != True:
+        if dict['fullscreen_on'] == 1:
+            bge.render.setFullScreen(True)
+    if fullscreen == True:
+        if dict['fullscreen_on'] == 0:
+            bge.render.setFullScreen(False) 
+            
+    bge.render.setWindowSize(resx, resy)         
+    print("resolution = ", resx, resy)       
+        
+def loadlevel():
+    import GameLogic
+    import bge
+    scenes = bge.logic.getSceneList()
+    main_scene = [scene for scene in scenes if scene.name=="main"][0]
+    own = main_scene.objects['Empty']
+    cont = GameLogic.getCurrentController()
+    own2 = cont.owner
+
+    dict = bge.logic.globalDict #Get the global dictionary
+    
+    if own["framerate"] == 1:    
+        bge.render.showFramerate(1)
+    if own["profile"] ==1:    
+        bge.render.showProfile(1)   
+    act = own2.actuators["level"]
+    dict = bge.logic.globalDict
+    level = dict['level']
+    print('loading level', level)
+    act.scene = level 
+    cont.activate(own2.actuators["level"]) 
+    dict['npause'] = False 
+    
+def timer():
+    import GameLogic
+    import bge    
+
+    dict = bge.logic.globalDict    
+    
+    if dict['reload_timer'] == 1:
+        scene = bge.logic.getCurrentScene()
+            
+    if dict['reload_timer'] > 0:
+       dict['reload_timer'] -= 1         

scripts/SortData.py

+#sort
+
+from bge import logic
+
+printDebug = True    #Set to True to see some basic debug info
+
+cont = logic.getCurrentController()
+own = cont.owner
+
+gameName = "shuvit"    #Set this to the name of your game!
+
+path = logic.expandPath(own["filePath"])
+
+positionList = []
+orientationList = []
+scaleList = []
+colorList = []
+stateList = []
+visibilityList = []
+skaterAnimList = []
+skaterAnimFList = []
+deckAnimList = []
+deckAnimFList = []
+srollVolList = []
+srollPitchList = []
+sgrind_cementVolList = []
+sgrind_cementPitchList = []
+sgrind_railVolList = []
+sgrind_railPitchList = []
+spopsoundList = []
+slandsoundList = []
+sdeckvisList = []
+positiontdList = []
+orientationtdList = []
+srevertsoundList = []
+
+allDataList = []
+allDataPath = path+gameName+" replay.dat"
+
+class writeData:
+
+    def addPosition(obj, pos, cut):
+        global positionList
+        positionList.append(" "+str(obj))
+        positionList.append(pos)
+        
+        if len(positionList) >= cut and cut > 0:
+            del positionList[0]
+            del positionList[0]
+        
+    def addOrientation(obj, ori, cut):
+        global orientationData
+        orientationList.append(" "+str(obj))
+        orientationList.append(ori)
+        
+        if len(orientationList) >= cut and cut > 0:
+            del orientationList[0]
+            del orientationList[0]
+        
+    def addScale(obj, sca, cut):
+        global scaleData
+        scaleList.append(" "+str(obj))
+        scaleList.append(sca)
+        
+        if len(scaleList) >= cut and cut > 0:
+            del scaleList[0]
+            del scaleList[0]
+        
+    def addColor(obj, col, cut):
+        global colorData
+        colorList.append(" "+str(obj))
+        colorList.append(col)
+        
+        if len(colorList) >= cut and cut > 0:
+            del colorList[0]
+            del colorList[0]
+        
+    def addState(obj, sta, cut):
+        global stateData
+        stateList.append(" "+str(obj))
+        stateList.append(sta)
+        
+        if len(stateList) >= cut and cut > 0:
+            del stateList[0]
+            del stateList[0]
+            
+    def addVisibility(obj, vis, cut):
+        global visibilityData
+        visibilityList.append(" "+str(obj))
+        visibilityList.append(vis)
+        if len(visibilityList) >= cut and cut > 0:
+            del visibilityList[0]
+            del visibilityList[0]
+    def addSkaterAnim(obj, anim, cut):
+        global skaterAnimData
+        skaterAnimList.append(" "+str(obj))
+        skaterAnimList.append(anim)
+        
+        if len(skaterAnimList) >= cut and cut > 0:
+            del skaterAnimList[0]
+            del skaterAnimList[0] 
+    def addSkaterAnimF(obj, animf, cut):
+        global skaterAnimFData
+        skaterAnimFList.append(" "+str(obj))
+        skaterAnimFList.append(animf)
+        
+        if len(skaterAnimFList) >= cut and cut > 0:
+            del skaterAnimFList[0]
+            del skaterAnimFList[0]  
+    def addDeckAnim(obj, anim, cut):
+        global deckAnimData
+        deckAnimList.append(" "+str(obj))
+        deckAnimList.append(anim)
+        
+        if len(deckAnimList) >= cut and cut > 0:
+            del deckAnimList[0]
+            del deckAnimList[0] 
+    def addDeckAnimF(obj, animf, cut):
+        global deckAnimFData
+        deckAnimFList.append(" "+str(obj))
+        deckAnimFList.append(animf)
+        
+        if len(deckAnimFList) >= cut and cut > 0:
+            del deckAnimFList[0]
+            del deckAnimFList[0]
+###             
+    def addSrollVol(obj, srollVol, cut):
+        global srollVolData
+        srollVolList.append(" "+str(obj))
+        srollVolList.append(srollVol)
+        if len(srollVolList) >= cut and cut > 0:
+            del srollVolList[0]
+            del srollVolList[0]
+    def addSrollPitch(obj, srollPitch, cut):
+        global srollPitchData
+        srollPitchList.append(" "+str(obj))
+        srollPitchList.append(srollPitch)
+        if len(srollPitchList) >= cut and cut > 0:
+            del srollPitchList[0]
+            del srollPitchList[0] 
+###             
+    def addSgrind_cementVol(obj, sgrind_cementVol, cut):
+        global sgrind_cementVolData
+        sgrind_cementVolList.append(" "+str(obj))
+        sgrind_cementVolList.append(sgrind_cementVol)
+        if len(sgrind_cementVolList) >= cut and cut > 0:
+            del sgrind_cementVolList[0]
+            del sgrind_cementVolList[0]
+    def addSgrind_cementPitch(obj, sgrind_cementPitch, cut):
+        global sgrind_cementPitchData
+        sgrind_cementPitchList.append(" "+str(obj))
+        sgrind_cementPitchList.append(sgrind_cementPitch)
+        if len(sgrind_cementPitchList) >= cut and cut > 0:
+            del sgrind_cementPitchList[0]
+            del sgrind_cementPitchList[0] 
+###             
+    def addSgrind_railVol(obj, sgrind_railVol, cut):
+        global sgrind_railVolData
+        sgrind_railVolList.append(" "+str(obj))
+        sgrind_railVolList.append(sgrind_railVol)
+        if len(sgrind_railVolList) >= cut and cut > 0:
+            del sgrind_railVolList[0]
+            del sgrind_railVolList[0]
+    def addSgrind_railPitch(obj, sgrind_railPitch, cut):
+        global sgrind_railPitchData
+        sgrind_railPitchList.append(" "+str(obj))
+        sgrind_railPitchList.append(sgrind_railPitch)
+        if len(sgrind_railPitchList) >= cut and cut > 0:
+            del sgrind_railPitchList[0]
+            del sgrind_railPitchList[0] 
+##
+    def addSpopsound(obj, spopsound, cut):
+        global spopsoundData
+        spopsoundList.append(" "+str(obj))
+        spopsoundList.append(spopsound)
+        if len(spopsoundList) >= cut and cut > 0:
+            del spopsoundList[0]
+            del spopsoundList[0] 
+##
+    def addSlandsound(obj, slandsound, cut):
+        global slandsoundData
+        slandsoundList.append(" "+str(obj))
+        slandsoundList.append(slandsound)
+        if len(slandsoundList) >= cut and cut > 0:
+            del slandsoundList[0]
+            del slandsoundList[0] 
+    
+    def addSdeckvis(obj, sdeckvis, cut):
+        global sdeckvisData
+        sdeckvisList.append(" "+str(obj))
+        sdeckvisList.append(sdeckvis)
+        if len(sdeckvisList) >= cut and cut > 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():
+
+        allDataList = ["game="+gameName+"\n",
+            " ".join(positionList),
+            " ".join(orientationList),
+            " ".join(scaleList),
+            " ".join(colorList),
+            " ".join(stateList),
+            " ".join(visibilityList),
+            " ".join(skaterAnimList),
+            " ".join(skaterAnimFList),
+            " ".join(deckAnimList),
+            " ".join(deckAnimFList),
+            " ".join(srollVolList),
+            " ".join(srollPitchList), 
+            " ".join(sgrind_cementVolList),
+            " ".join(sgrind_cementPitchList),
+            " ".join(sgrind_railVolList),
+            " ".join(sgrind_railPitchList),
+            " ".join(spopsoundList),
+            " ".join(slandsoundList),
+            " ".join(sdeckvisList),
+            " ".join(positiontdList),
+            " ".join(orientationtdList),
+            " ".join(spopsoundList)]    
+        try:
+            with open(allDataPath,'w') as all:
+                all.write("|".join(allDataList))
+                all.close()
+                if printDebug:
+                    print("State recording saved successfuly to "+allDataPath)
+        except IOError:
+            if printDebug:
+                print(allDataPath+"cannot be opened for writing")
+
+class readData:
+                                   
+    def loadAll():
+        
+        global allDataList
+        global positionList
+        global orientationList
+        global scaleList
+        global colorList
+        global stateList
+        global visibilityList
+        global skaterAnimList
+        global skaterAnimFList
+        global deckAnimList
+        global deckAnimFList 
+        global srollVolList
+        global srollPitchList 
+        global sgrind_cementVolList
+        global sgrind_cementPitchList 
+        global sgrind_railVolList
+        global sgrind_railPitchList
+        global spopsoundList
+        global slandsoundList 
+        global sdeckvisList     
+        global positiontdList
+        global orientationtdList 
+        global srevertsoundList                                          
+            
+        if not allDataList:
+            try:
+                with open(allDataPath) as all:
+                    data = all.read()
+                    all.close()
+
+                    allDataList = data.split("|",6)
+
+                    loadedGameName = str(allDataList[0].split("=",1)[1]).strip()
+                    try:
+                        if loadedGameName == gameName:
+
+                            positionList = allDataList[1].split()
+                            print('1')
+                            orientationList = allDataList[2].split()
+                            print('2')
+                            scaleList = allDataList[3].split()
+                            print('3')
+                            colorList = allDataList[4].split()
+                            print('4')
+                            stateList = allDataList[5].split()
+                            print('5')
+                            visibilityList = allDataList[6].split()
+                            print('6')
+                            skaterAnimList = allDataList[7].split()
+                            print('7')
+                            skaterAnimFList = allDataList[8].split()
+                            print('8')
+                            deckAnimList = allDataList[9].split()
+                            print('9')
+                            deckAnimFList = allDataList[10].split()
+                            print('1')
+                            srollVolList = allDataList[11].split()
+                            print('1')
+                            srollPitchList = allDataList[12].split()
+                            print('1')
+                            sgrind_cementVolList = allDataList[13].split()
+                            print('1')
+                            sgrind_cementPitchList = allDataList[14].split()
+                            print('1')
+                            sgrind_railVolList = allDataList[15].split() 
+                            print('1')
+                            sgrind_railPitchList = allDataList[16].split()
+                            print('1')
+                            spopsoundList = allDataList[17].split()
+                            print('1')
+                            slandsoundList = allDataList[18].split()
+                            print('1')
+                            sdeckvisList = allDataList[19].split()
+                            print('1')
+                            positiontdList = allDataList[20].split()
+                            print('1')
+                            orientationtdList = allDataList[21].split()  
+                            print('1')                          
+                            srevertsoundList = allDataList[22].split()
+                            print('1')
+                            
+                            if printDebug:
+                                print("Read file "+allDataPath)
+                    except Exception as e:
+                        print("error reading replay data", e)        
+            #except IOError:
+            except Exception as e:   
+                if printDebug:
+                    print("Error reading "+allDataPath, e)
+
+    def returnPosition(objIndex, valueIndex):
+        
+        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):
+
+        if scaleList:
+            name = scaleList[objIndex-2]
+            scale = scaleList[valueIndex-2]
+            
+            name = name.replace(" ","")
+            
+            scale = str(scale)
+            scale = scale.replace(","," ")
+            
+            sX = float(scale.split()[0])
+            sY = float(scale.split()[1])
+            sZ = float(scale.split()[2])
+            
+            scale = [sX,sY,sZ]
+
+            return(name, scale)
+
+    def returnColor(objIndex, valueIndex):
+
+        if colorList:
+            name = colorList[objIndex-2]
+            color = colorList[valueIndex-2]
+            
+            name = name.replace(" ","")
+            
+            color = str(color)
+            color = color.replace(","," ")
+            
+            cR = float(color.split()[0])
+            cG = float(color.split()[1])
+            cB = float(color.split()[2])
+            cA = float(color.split()[3])
+            
+            color = [cR,cG,cB,cA]
+
+            return(name, color)
+    
+    def returnState(objIndex, valueIndex):
+        
+        if stateList:
+            name = stateList[objIndex-2]
+            state = stateList[valueIndex-2]
+            
+            name = name.replace(" ","")
+            
+            state = str(state)
+            state = state.replace(","," ")
+            state = int(state)
+            
+            return(name, state)
+    
+    def returnVisibility(objIndex, valueIndex):
+        
+        if visibilityList:
+            name = visibilityList[objIndex-2]
+            visible = visibilityList[valueIndex-2]
+            
+            name = name.replace(" ","")
+            
+            visible = str(visible)
+            visible = visible.replace(","," ")
+            
+            return(name, visible)
+        
+    def returnSkaterAnim(objIndex, valueIndex):       
+        if skaterAnimList:
+            name = skaterAnimList[objIndex-2]
+            skaterAnim = skaterAnimList[valueIndex-2]
+            name = name.replace(" ","")           
+            skaterAnim = str(skaterAnim)
+            skaterAnim = skaterAnim.replace(","," ")           
+            return(name, skaterAnim) 
+        
+    def returnSkaterAnimF(objIndex, valueIndex):       
+        if skaterAnimFList:
+            name = skaterAnimFList[objIndex-2]
+            skaterAnimF = skaterAnimFList[valueIndex-2]
+            name = name.replace(" ","")
+            skaterAnimF = str(skaterAnimF)
+            skaterAnimF = skaterAnimF.replace(","," ")
+            return(name, skaterAnimF)  
+        
+    def returnDeckAnim(objIndex, valueIndex):    
+        if deckAnimList:
+            name = deckAnimList[objIndex-2]
+            deckAnim = deckAnimList[valueIndex-2]
+            name = name.replace(" ","")
+            deckAnim = str(deckAnim)
+            deckAnim = deckAnim.replace(","," ")
+            return(name, deckAnim) 
+        
+    def returnDeckAnimF(objIndex, valueIndex):
+        if deckAnimFList:
+            name = deckAnimFList[objIndex-2]
+            deckAnimF = deckAnimFList[valueIndex-2]
+            name = name.replace(" ","")
+            deckAnimF = str(deckAnimF)
+            deckAnimF = deckAnimF.replace(","," ")            
+            return(name, deckAnimF)
+####
+    def returnSrollVol(objIndex, valueIndex):
+        if srollVolList:
+            name = srollVolList[objIndex-2]
+            srollVol = srollVolList[valueIndex-2]
+            name = name.replace(" ","")
+            srollVol = str(srollVol)
+            srollVol = srollVol.replace(","," ")
+            srollVol = float(srollVol)
+            return(name, srollVol)
+        
+    def returnSrollPitch(objIndex, valueIndex):
+        if srollPitchList:
+            name = srollPitchList[objIndex-2]
+            srollPitch = srollPitchList[valueIndex-2]
+            name = name.replace(" ","")
+            srollPitch = str(srollPitch)
+            srollPitch = srollPitch.replace(","," ")
+            srollPitch = float(srollPitch)
+            return(name, srollPitch)                             ####
+####
+    def returnSgrind_cementVol(objIndex, valueIndex):
+        if sgrind_cementVolList:
+            name = sgrind_cementVolList[objIndex-2]
+            sgrind_cementVol = sgrind_cementVolList[valueIndex-2]
+            name = name.replace(" ","")
+            sgrind_cementVol = str(sgrind_cementVol)
+            sgrind_cementVol = sgrind_cementVol.replace(","," ")
+            sgrind_cementVol = float(sgrind_cementVol)
+            return(name, sgrind_cementVol)
+        
+    def returnSgrind_cementPitch(objIndex, valueIndex):
+        if sgrind_cementPitchList:
+            name = sgrind_cementPitchList[objIndex-2]
+            sgrind_cementPitch = sgrind_cementPitchList[valueIndex-2]
+            name = name.replace(" ","")
+            sgrind_cementPitch = str(sgrind_cementPitch)
+            sgrind_cementPitch = sgrind_cementPitch.replace(","," ")
+            sgrind_cementPitch = float(sgrind_cementPitch)
+            return(name, sgrind_cementPitch)                             ####              
+####
+    def returnSgrind_railVol(objIndex, valueIndex):
+        if sgrind_railVolList:
+            name = sgrind_railVolList[objIndex-2]
+            sgrind_railVol = sgrind_railVolList[valueIndex-2]
+            name = name.replace(" ","")
+            sgrind_railVol = str(sgrind_railVol)
+            sgrind_railVol = sgrind_railVol.replace(","," ")
+            sgrind_railVol = float(sgrind_railVol)
+            return(name, sgrind_railVol)
+        
+    def returnSgrind_railPitch(objIndex, valueIndex):
+        if sgrind_railPitchList:
+            name = sgrind_railPitchList[objIndex-2]
+            sgrind_railPitch = sgrind_railPitchList[valueIndex-2]
+            name = name.replace(" ","")
+            sgrind_railPitch = str(sgrind_railPitch)
+            sgrind_railPitch = sgrind_railPitch.replace(","," ")
+            sgrind_railPitch = float(sgrind_railPitch)
+            return(name, sgrind_railPitch)                             ####
+    def returnSpopsound(objIndex, valueIndex):
+        if spopsoundList:
+            name = spopsoundList[objIndex-2]
+            spopsound = spopsoundList[valueIndex-2]
+            name = name.replace(" ","")
+            spopsound = str(spopsound)
+            spopsound = spopsound.replace(","," ")
+            spopsound = int(spopsound)
+            return(name, spopsound)
+    def returnSlandsound(objIndex, valueIndex):
+        if slandsoundList:
+            name = slandsoundList[objIndex-2]
+            slandsound = slandsoundList[valueIndex-2]
+            name = name.replace(" ","")
+            slandsound = str(slandsound)
+            slandsound = slandsound.replace(","," ")
+            slandsound = int(slandsound)
+            return(name, slandsound) 
+    def returnSdeckvis(objIndex, valueIndex):
+        if sdeckvisList:
+            name = sdeckvisList[objIndex-2]
+            sdeckvis = sdeckvisList[valueIndex-2]
+            name = name.replace(" ","")
+            sdeckvis = str(sdeckvis)
+            sdeckvis = sdeckvis.replace(","," ")
+            sdeckvis = int(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():
+        if positionList:
+            return(len(positionList))
+
+    def getLengthOri():
+        if orientationList:
+            return(len(orientationList))
+
+    def getLengthSca():
+        if scaleList:
+            return(len(scaleList))
+
+    def getLengthCol():
+        if colorList:
+            return(len(colorList))
+    
+    def getLengthSta():
+        if stateList:
+            return(len(stateList))
+    
+    def getLengthVis():
+        if visibilityList:
+            return(len(visibilityList))
+    def getLengthSkaterAnim():
+        if skaterAnimList:
+            return(len(skaterAnimList)) 
+    def getLengthSkaterAnimF():
+        if skaterAnimFList:
+            return(len(skaterAnimFList)) 
+    def getLengthDeckAnim():
+        if deckAnimList:
+            return(len(deckAnimList)) 
+    def getLengthDeckAnimF():
+        if deckAnimFList:
+            return(len(deckAnimFList))
+    def getLengthSrollVol():
+        if srollVolList:
+            return(len(srollVolList)) 
+    def getLengthSrollPitch():
+        if srollPitchList:
+            return(len(srollPitchList)) 
+    def getLengthSgrind_cementVol():
+        if sgrind_cementVolList:
+            return(len(sgrind_cementVolList)) 
+    def getLengthSgrind_cementPitch():
+        if sgrind_cementPitchList:
+            return(len(sgrind_cementPitchList))
+    def getLengthSgrind_railVol():
+        if sgrind_railVolList:
+            return(len(sgrind_railVolList)) 
+    def getLengthSgrind_railPitch():
+        if sgrind_railPitchList:
+            return(len(sgrind_railPitchList))
+    def getLengthSpopsound():
+        if spopsoundList:
+            return(len(spopsoundList)) 
+    def getLengthSlandsound():
+        if slandsoundList:
+            return(len(slandsoundList)) 
+    def getLengthSdeckvis():
+        if 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))    
+             
+                                                                                                    

scripts/Startup.py

+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)
+
+    for i in scenes:
+        if i.name == "main":
+            main = i
+            main.world.zenithColor = [0, 0, 0, 0]
+            main.world.horizonColor = [0, 0, 0, 0] 
+
+    scene = bge.logic.getCurrentScene()
+    black = scene.objects['black']
+    shuvit_logo = scene.objects['shuvit_logo']
+    black.playAction('black_fade', 0,100, layer=1, play_mode=0)
+    shuvit_logo.playAction('logo_fade', 0,100, layer=4, play_mode=0)  
+    print('black on') 
+    dict = bge.logic.globalDict
+    dict['overlay_fadein'] = 0
+    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
+    else:    
+        dict['joy_con'] = 1
+    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['kb_lsh'] = 0
+    dict['kb_space'] = 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 
+    
+    dict['last_ltsBut'] = 0.0
+    dict['last_rtsBut'] = 0.0   
+    dict['last_ldPad'] = 0 
+    
+    #dict['shirt_color'] = [.5,1,1,1]
+    
+    dict['mu_last_track'] = ''
+    dict['mu_artist'] = ''
+    dict['mu_title'] = ''    
+    
+    dict['joy_con'] = 1
+    dict['last_joy_con'] = 1
+    dict['last_driving'] = False
+    dict['driving_reset'] = False
+    
+    dict['spawned_npc_decks'] = []
+    dict['spawned_npc_trucks'] = []    
+    dict['spawned_npcs'] = []
+    #dict['JUMPHEIGHT'] = 800
+    #dict['MAX_VEL'] = 6.7
+    dict['char_loaded'] = 0
+    dict['man_sens_l'] = .03
+    dict['man_sens_r'] = .08
+    dict['walk'] = 1
+    dict['cur_ccH_targetHeight'] = .3
+    dict['music_start'] = False  
+    dict['npause'] = False
+    dict['playback'] = False  
+    
+main()

scripts/active_camera_loc.py

+import bge
+
+
+def set(cont):
+    own = cont.owner
+
+    #own.getWorldPosition
+    scene = bge.logic.getCurrentScene()
+    cam = scene.active_camera
+    own.worldPosition = cam.worldPosition
+
+# dont call main(bge.logic.getCurrentController()), the py controller will

scripts/aiRecord.py

+#record
+from bge import logic
+from mathutils import Vector
+from aiSortData import *
+import math
+
+cont = logic.getCurrentController()
+own = cont.owner
+scene = logic.getCurrentScene()
+cube = cont.owner
+#obj = scene.objects["control_cube.002"]
+#sound_empty = scene.objects['replay_sound_empty']
+#path = logic.expandPath(own["filePath"])
+dict = logic.globalDict
+PAF = 0
+DAF = 0
+
+npc_index = own['npc_index']
+#print(dict['spawned_npc_decks'], npc_index, 'spawned deck list')
+deck = dict['spawned_npc_decks'][npc_index]
+trucks = dict['spawned_npc_trucks'][npc_index]
+#deck = scene.objects[deck]
+
+#print(own.children)
+#deck = own.children['npc_ed_deck']
+#trucks = own.children["npc_ed_trucks"]
+
+#throw_deck_empty = scene.objects["throw_deck_empty"]
+#wheel1 = trucks.children["npc_ed_rollen.000"]
+#wheel2 = trucks.children["npc_ed_rollen.001"]
+#wheel3 = trucks.children["npc_ed_rollen.002"]
+#wheel4 = trucks.children["npc_ed_rollen.003"]
+
+#try:
+#    throw_deck = scene.objects['throw_deck']
+#except:
+#    throw_deck = None    
+
+#deckact = deck.actuators["Visibility"]
+#trucksact = trucks.actuators["Visibility"]
+#wheel1act = wheel1.actuators["Visibility"]
+#wheel2act = wheel2.actuators["Visibility"]
+#wheel3act = wheel3.actuators["Visibility"]
+#wheel4act = wheel4.actuators["Visibility"]
+
+class getData:
+
+
+
+    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): 
+        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.addOrientation(obj, orientation, cut)
+                    
+                                              
+              
+def loadData(cont, own):
+    
+    npc_index = own['npc_index']
+    #print(dict['spawned_npc_decks'], npc_index, 'spawned deck list')
+    deck = dict['spawned_npc_decks'][npc_index]
+    trucks = dict['spawned_npc_trucks'][npc_index]    
+    skater = dict['spawned_npcs'][npc_index]
+    cube = own 
+    #Function for loading the data from
+    #the disk and setting it.
+    #print('load_data', own)
+    objIndex = own["objIndex"]
+    #print(own['objIndex'], 'objindex')
+    own["valueIndex"] = objIndex + 1
+    valueIndex = own["valueIndex"]
+    playbackSpeed = own["playbackSpeed"]
+    loadedPosition = own["loadedPosition"]
+    loadedOrientation = own["loadedOrientation"]
+#    print(loadedPosition)
+#    loadedScale = own["loadedScale"]
+#    loadedColor = own["loadedColor"]
+#    loadedVisibility = own["loadedVisibility"]
+    loadedSkaterAnim = own["loadedSkaterAnim"]
+    loadedSkaterAnimf = own["loadedSkaterAnimF"]
+    loadedDeckAnim = own["loadedDeckAnim"]
+    loadedDeckAnimf = own["loadedDeckAnimF"]
+#    loadedSrollVol = own["loadedSrollVol"]
+#    loadedSrollPitch = own["loadedSrollPitch"]
+#    loadedSgrind_cementlVol = own["loadedSgrind_cementVol"]
+#    loadedSgrind_cementPitch = own["loadedSgrind_cementPitch"]
+#    loadedSgrind_railVol = own["loadedSgrind_railVol"]
+#    loadedSgrind_railPitch = own["loadedSgrind_railPitch"] 
+#    loadedSpopsound = own["loadedSpopsound"]            
+#    loadedSlandsound = own["loadedSlandsound"] 
+#    loadedSdeckvis = own["loadedSdeckvis"]  
+#    loadedtdPosition = own["loadedtdPosition"]
+#    loadedtdOrientation = own["loadedtdOrientation"]      
+#    loadedSrevertsound = own["loadedSrevertsound"] 
+       
+    #skater = own.children["npc_ed_arm"]
+    #deck = own.children["deck"]
+    #trucks = own.children["trucks"]
+    
+    num = 1
+    obj = own
+
+                     
+    readData.loadAll(own)    #Load the file!!!
+    
+    #-----Position-----#
+    own["lengthPos"] = readData.getLengthPos(own)
+    lengthPos = own["lengthPos"] 
+    positionList = own['positionList']
+    if lengthPos:
+        if objIndex > lengthPos-1:
+            own["objIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthPos-2
+
+        name, position = readData.returnPosition(objIndex, valueIndex, own)
+        name2, orientation = readData.returnOrientation(objIndex, valueIndex, own)
+        try:
+            if own['rpStartLoc_set'] == False:
+                
+                
+                
+                own['rpStartLoc'] = position
+                print('setting npc_start_pos', position)
+                
+                own['npc_playback'] = False
+                own['move'] = True
+                tracker = scene.addObject('npc_tracker', own, 0)
+                own['target_object_name'] = tracker
+                tracker.worldPosition = position
+                
+                oXYZ = own.localOrientation.to_euler()
+
+                oXYZ[0] = float(orientation[0])
+                oXYZ[1] = float(orientation[1])
+                oXYZ[2] = float(orientation[2])                
+                tracker.localOrientation = oXYZ.to_matrix()
+                rot = [ 0.0, 0.0, -1.570796327]
+                #tracker.applyRotation(rot,True) 
+    
+                rotz = math.degrees(oXYZ[2])
+                rotz -= 90
+                if rotz < -180:
+                    rotz = rotz + 360
+                own['rpStartZ'] = rotz               
+                
+            else:  
+                cube.worldPosition = position
+                deck.worldPosition = position
+                trucks.worldPosition = position
+                
+            if 'data_loaded' not in own:
+                own['data_loaded'] = 1 
+                cube.worldPosition = position
+                deck.worldPosition = position
+                trucks.worldPosition = position                   
+                
+        except:
+            print('npc positioning not working')
+            #pass
+    #-----Orientation-----#
+    own["lengthOri"] = readData.getLengthOri(own)   
+    lengthOri = own["lengthOri"]
+
+    valueIndex = own['valueIndex']
+    #print(valueIndex, objIndex, 'value Index')
+    #if lengthPos:
+    if lengthOri:
+        if valueIndex > lengthOri-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthOri-2
+        name, orientation = readData.returnOrientation(objIndex, valueIndex, own)
+        oXYZ = own.localOrientation.to_euler()
+        oXYZ[0] = float(orientation[0])
+        oXYZ[1] = float(orientation[1])
+        oXYZ[2] = float(orientation[2])    
+        try:
+            if own['rpStartLoc_set'] == True:
+                own.localOrientation = oXYZ.to_matrix()
+                deck.localOrientation = oXYZ.to_matrix()
+                trucks.localOrientation = oXYZ.to_matrix()
+                rot = [ 0.0, 0.0, -1.570796327]
+                own.applyRotation(rot,True) 
+            else:
+                own['rpStartLoc_set'] = True
+        except:
+            print('npc orientation not working')
+#    #-----Scale-----#
+#    own["lengthSca"] = readData.getLengthSca()
+#    lengthSca = own["lengthSca"]
+#    
+#    if lengthSca:
+#    
+#        if valueIndex > lengthSca-1:
+#            own["valueIndex"] = 0
+#        if objIndex < 0:
+#            own["objIndex"] = lengthSca-2
+#       
+#        name, scale = readData.returnScale(objIndex, valueIndex)
+#        
+#        if name in scene.objects:
+#            try:
+#                scene.objects[name].localScale = scale
+#            except:
+#                pass
+#    #-----Color-----#
+#    own["lengthCol"] = readData.getLengthCol()   
+#    lengthCol = own["lengthCol"]
+#    
+#    if lengthCol:
+
+#        if valueIndex > lengthCol-1:
+#            own["valueIndex"] = 0
+#        if objIndex < 0:
+#            own["objIndex"] = lengthCol-2
+
+#        name, color = readData.returnColor(objIndex, valueIndex)
+#        
+#        if name in scene.objects:
+#            try:
+#                scene.objects[name].color = color
+#            except:
+#                pass
+#    #-----Visibility-----#
+#    own["lengthVis"] = readData.getLengthVis()
+#    lengthVis = own["lengthVis"]
+#    
+#    if lengthVis:
+
+#        if valueIndex > lengthVis-1:
+#            own["valueIndex"] = 0
+#        if objIndex < 0:
+#            own["objIndex"] = lengthVis-2
+
+#        name, visible = readData.returnVisibility(objIndex, valueIndex)
+#        
+#        if name in scene.objects:
+#            try:
+#                scene.objects[name].visible = int(visible)
+#            except:
+#                pass
+    #-----Skater Animation Name-----#
+    own["lengthSkaterAnim"] = readData.getLengthSkaterAnim(own)
+    lengthSkaterAnim = own["lengthSkaterAnim"]
+    #print("lengthskateranim", lengthSkaterAnim)
+    if lengthSkaterAnim:
+
+        if valueIndex > lengthSkaterAnim-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthSkaterAnim-2
+
+        name, skateranim = readData.returnSkaterAnim(objIndex, valueIndex, own)
+        name, PAF = readData.returnSkaterAnimF(objIndex, valueIndex, own)
+        PAF = round(float(PAF), 1)
+        #print(valueIndex, skateranim, PAF,  'sa')
+        PAF = float(PAF)
+        if skater in own.children:
+            #print("name in")
+            try:
+                skater.stopAction(0)
+                skater.stopAction(1)
+                skater.stopAction(2)
+                skater.stopAction(3)
+                skater.stopAction(9999)
+                if skater != '' and skateranim != 'control_cube.002':
+                    skater.playAction(skateranim, PAF,PAF, layer=2, play_mode=1, speed=1)
+                #print("Playing: ", skater, skateranim, PAF)
+            except:
+                print("something is wrong")
+                
+    #-----Deck Animation Name-----#
+    own["lengthDeckAnim"] = readData.getLengthDeckAnim(own)
+    lengthDeckAnim = own["lengthDeckAnim"]
+    #print("lengthDeckanim", lengthDeckAnim)
+    if lengthDeckAnim:
+
+        if valueIndex > lengthDeckAnim-1:
+            own["valueIndex"] = 0
+        if objIndex < 0:
+            own["objIndex"] = lengthDeckAnim-2
+
+        name, deckanim = readData.returnDeckAnim(objIndex, valueIndex, own)
+        name, DAF = readData.returnDeckAnimF(objIndex, valueIndex, own)
+        name = 'npc_ed_deck'
+
+        DAF = float(DAF)
+        if deck in own.children:
+            #print("name in")
+            try:
+                if deck != '' and deckanim != 'control_cube.002':
+                    deck.playAction(deckanim, DAF,DAF, layer=2, play_mode=1, speed=1)
+                    trucks.playAction(deckanim, DAF,DAF, layer=2, play_mode=1, speed=1)
+                #print("Playing: ", deckanim, PAF)
+                #print("Playing: ", deck, deckanim, DAF)
+            except:
+                print("deck something is wrong")
+                #pass  
+
+##
+#    #-----sroll-----#
+#    own["lengthSrollVol"] = readData.getLengthSrollVol()
+#    lengthSrollVol = own["lengthSrollVol"]
+#    if lengthSrollVol:
+#        if valueIndex > lengthSrollVol-1:
+#            own["valueIndex"] = 0
+#        if objIndex < 0:
+#            own["objIndex"] = lengthSrollVol-2
+#        name, srollVol = readData.returnSrollVol(objIndex, valueIndex)
+#        name, srollPitch = readData.returnSrollPitch(objIndex, valueIndex)    
+#        if name in scene.objects:
+#            try:
+#                cube = scene.objects["control_cube.002"]
+#                srollVol = round(srollVol, 2)
+#                act = cube.actuators["sroll"]
+#                if srollVol < .12:
+#                    act.volume = srollVol
+#                    act.pitch = srollPitch
+#                act.startSound()
+#            except:
+#                pass
+####            
+##
+#    #-----grind cement-----#
+#    own["lengthSgrind_cementVol"] = readData.getLengthSgrind_cementVol()
+#    lengthSgrind_cementVol = own["lengthSgrind_cementVol"]
+#    if lengthSgrind_cementVol:
+#        if valueIndex > lengthSgrind_cementVol-1:
+#            own["valueIndex"] = 0
+#        if objIndex < 0:
+#            own["objIndex"] = lengthSgrind_cementVol-2
+#        name, sgrind_cementVol = readData.returnSgrind_cementVol(objIndex, valueIndex)
+#        name, sgrind_cementPitch = readData.returnSgrind_cementPitch(objIndex, valueIndex)    
+#        if name in scene.objects:
+#            try:
+#                cube = scene.objects["control_cube.002"]
+#                sgrind_cementVol = round(sgrind_cementVol, 2)
+#                act = cube.actuators["grind_cement"]
+#                if sgrind_cementVol < .2:
+#                    act.volume = sgrind_cementVol
+#                    act.pitch = sgrind_cementPitch
+#                act.startSound()
+#                
+#            except:
+#                pass
+####    
+##
+#    #-----grind rail-----#
+#    own["lengthSgrind_railVol"] = readData.getLengthSgrind_railVol()
+#    lengthSgrind_railVol = own["lengthSgrind_railVol"]
+#    if lengthSgrind_railVol:
+#        if valueIndex > lengthSgrind_railVol-1:
+#            own["valueIndex"] = 0
+#        if objIndex < 0:
+#            own["objIndex"] = lengthSgrind_railVol-2
+#        name, sgrind_railVol = readData.returnSgrind_railVol(objIndex, valueIndex)
+#        name, sgrind_railPitch = readData.returnSgrind_railPitch(objIndex, valueIndex)    
+#        if name in scene.objects:
+#            try:
+#                cube = scene.objects["control_cube.002"]
+#                sgrind_railVol = round(sgrind_railVol, 2)
+#                act = cube.actuators["grind_rail"]
+#                if sgrind_railVol < .2:
+#                    act.volume = sgrind_railVol
+#                    act.pitch = sgrind_railPitch
+#                act.startSound()
+#                #print("grindsound = ", sgrind_railVol, sgrind_railPitch)
+#            except:
+#                pass
+####  
+##
+#    #-----pop sound-----#
+#    own["lengthSpopsound"] = readData.getLengthSpopsound()
+#    lengthSpopsound = own["lengthSpopsound"]
+#    if lengthSpopsound:
+#        if valueIndex > lengthSpopsound-1:
+#            own["valueIndex"] = 0
+#        if objIndex < 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:
+#                print("sound passed")
+#                pass
+####
+##
+#    #-----land sound-----#
+#    own["lengthSlandsound"] = readData.getLengthSlandsound()
+#    lengthSlandsound = own["lengthSlandsound"]
+#    if lengthSlandsound:
+#        if valueIndex > lengthSlandsound-1:
+#            own["valueIndex"] = 0
+#        if objIndex < 0:
+#            own["objIndex"] = lengthSlandsound-2
+#        name, slandsound = readData.returnSlandsound(objIndex, valueIndex)   
+#        if name in scene.objects:
+#            try:
+#                cube = scene.objects["control_cube.002"]
+#                slandsound = round(slandsound, 2)
+#                act = cube.actuators["land"]
+#                if slandsound == 1:
+#                    act.volume = .6
+#                    act.startSound()
+#                #print("grindsound = ", slandsound, sgrind_railPitch)
+#            except:
+#                pass
+####  
+####
+##
+#    #-----land sound-----#
+#    own["lengthSdeckvis"] = readData.getLengthSdeckvis()
+#    lengthSdeckvis = own["lengthSdeckvis"]
+#    if lengthSdeckvis:
+#        if valueIndex > lengthSdeckvis-1:
+#            own["valueIndex"] = 0
+#        if objIndex < 0:
+#            own["objIndex"] = lengthSdeckvis-2
+#        name, sdeckvis = readData.returnSdeckvis(objIndex, valueIndex)   
+#        
+#        
+#        if name in scene.objects:
+#            try:
+#                cube = scene.objects["control_cube.002"]
+#                if sdeckvis == 1:
+#                    #print('setting deck visible')
+#                    deckact.visibility = True
+#                    trucksact.visibility = True
+#                    wheel1act.visibility = True
+#                    wheel2act.visibility = True
+#                    wheel3act.visibility = True
+#                    wheel4act.visibility = True   
+#                    cont.activate(deck.actuators['Visibility'])
+#                    cont.activate(trucks.actuators['Visibility'])
+#                    cont.activate(wheel1.actuators['Visibility'])
+#                    cont.activate(wheel2.actuators['Visibility'])
+#                    cont.activate(wheel3.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')
+#                    deckact.visibility = False
+#                    trucksact.visibility = False
+#                    wheel1act.visibility = False
+#                    wheel2act.visibility = False
+#                    wheel3act.visibility = False
+#                    wheel4act.visibility = False   
+#                    cont.activate(deck.actuators['Visibility'])
+#                    cont.activate(trucks.actuators['Visibility'])
+#                    cont.activate(wheel1.actuators['Visibility'])
+#                    cont.activate(wheel2.actuators['Visibility'])
+#                    cont.activate(wheel3.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
+
+                                            
+                       
+def main(recording_cutoff, cc):
+    pass
+              
+            
+         
+def breakOut():
+    pass

scripts/aiSortData.py

+from bge import logic
+
+printDebug = True    #Set to True to see some basic debug info
+
+cont = logic.getCurrentController()
+own = cont.owner
+
+gameName = "shuvit"    #Set this to the name of your game!
+
+path = logic.expandPath(own["filePath"])
+
+positionList = []
+orientationList = []
+scaleList = []
+colorList = []
+stateList = []
+visibilityList = []
+skaterAnimList = []
+skaterAnimFList = []
+deckAnimList = []
+deckAnimFList = []
+srollVolList = []
+srollPitchList = []
+sgrind_cementVolList = []
+sgrind_cementPitchList = []
+sgrind_railVolList = []
+sgrind_railPitchList = []
+spopsoundList = []
+slandsoundList = []
+sdeckvisList = []
+positiontdList = []
+orientationtdList = []
+srevertsoundList = []
+
+allDataList = []
+allDataPath = path+ own['npc_replay_name']
+
+      
+
+class readData:
+                                   
+    def loadAll(own):
+#        
+#        global allDataList
+#        global positionList
+#        global orientationList
+#        global scaleList
+#        global colorList
+#        global stateList
+#        global visibilityList
+#        global skaterAnimList
+#        global skaterAnimFList
+#        global deckAnimList
+#        global deckAnimFList 
+#        global srollVolList
+#        global srollPitchList 
+#        global sgrind_cementVolList
+#        global sgrind_cementPitchList 
+#        global sgrind_railVolList
+#        global sgrind_railPitchList
+#        global spopsoundList
+#        global slandsoundList 
+#        global sdeckvisList     
+#        global positiontdList
+#        global orientationtdList 
+#        global srevertsoundList  
+
+#        own['allDataList'] = []
+#        own['positionList'] = []
+#        own['orientationList'] = []
+#        own['scaleList'] = []
+#        own['colorList'] = []
+#        own['stateList'] = []
+#        own['visibilityList'] = []
+#        own['skaterAnimList'] = []
+#        own['skaterAnimFList'] = []
+#        own['deckAnimList'] = []
+#        own['deckAnimFList'] = []
+#        own['srollVolList'] = []
+#        own['srollPitchList']  = []
+#        own['sgrind_cementVolList'] = []
+#        own['sgrind_cementPitchList']  = []
+#        own['sgrind_railVolList'] = []
+#        own['sgrind_railPitchList'] = []
+#        own['spopsoundList'] = []
+#        own['slandsoundList']  = []
+#        own['sdeckvisList'] = []
+#        own['positiontdList'] = []
+#        own['orientationtdList']  = []
+#        own['srevertsoundList']  = []
+        
+        allDataPath = path+ own['npc_replay_name']    
+        
+        #if not allDataList:
+        if own['inited'] == False:
+            #own['inited'] = True
+            try:
+                with open(allDataPath) as all:
+                    data = all.read()
+                    all.close()
+
+                    allDataList = data.split("|",22)#6)
+                    own['allDataList'] = allDataList
+                    loadedGameName = str(allDataList[0].split("=",1)[1]).strip()
+            
+                    #skaterAnimList = allDataList[7].split()
+                    #skaterAnimFList = allDataList[8].split()                    
+                    
+                    try:
+                        if loadedGameName == gameName:
+
+#                            positionList = allDataList[1].split()
+#                            orientationList = allDataList[2].split()
+#                            scaleList = allDataList[3].split()
+#                            colorList = allDataList[4].split()
+#                            stateList = allDataList[5].split()
+#                            visibilityList = allDataList[6].split()
+#                            skaterAnimList = allDataList[7].split()
+#                            skaterAnimFList = allDataList[8].split()
+#                            deckAnimList = allDataList[9].split()
+#                            deckAnimFList = allDataList[10].split()
+#                            srollVolList = allDataList[11].split()
+#                            srollPitchList = allDataList[12].split()
+#                            sgrind_cementVolList = allDataList[13].split()
+#                            sgrind_cementPitchList = allDataList[14].split()
+#                            sgrind_railVolList = allDataList[15].split() 
+#                            sgrind_railPitchList = allDataList[16].split()
+#                            spopsoundList = allDataList[17].split()
+#                            slandsoundList = allDataList[18].split()
+#                            sdeckvisList = allDataList[19].split()
+#                            positiontdList = allDataList[20].split()
+#                            orientationtdList = allDataList[21].split() 
+#                            srevertsoundList = allDataList[22].split()
+#                            
+                            own['positionList'] = allDataList[1].split()
+                            own['orientationList'] = allDataList[2].split()
+                            own['scaleList'] = allDataList[3].split()
+                            own['colorList'] = allDataList[4].split()
+                            own['stateList'] = allDataList[5].split()
+                            own['visibilityList'] = allDataList[6].split()
+                            own['skaterAnimList'] = allDataList[7].split()
+                            own['skaterAnimFList'] = allDataList[8].split()
+                            own['deckAnimList'] = allDataList[9].split()
+                            own['deckAnimFList'] = allDataList[10].split()
+                            own['srollVolList'] = allDataList[11].split()
+                            own['srollPitchList'] = allDataList[12].split()
+                            own['sgrind_cementVolList'] = allDataList[13].split()
+                            own['sgrind_cementPitchList'] = allDataList[14].split()
+                            own['sgrind_railVolList'] = allDataList[15].split() 
+                            own['sgrind_railPitchList'] = allDataList[16].split()
+                            own['spopsoundList'] = allDataList[17].split()
+                            own['slandsoundList'] = allDataList[18].split()
+                            own['sdeckvisList'] = allDataList[19].split()
+                            own['positiontdList'] = allDataList[20].split()
+                            own['orientationtdList'] = allDataList[21].split() 
+                            own['srevertsoundList'] = allDataList[22].split()             
+                            
+                            
+                            
+
+                            positionList = own['positionList'
+                            ]
+                            orientationList = own['orientationList']
+                            scaleList = own['scaleList']
+                            colorList = own['colorList']
+                            stateList = own['stateList']
+                            visibilityList = own['visibilityList']
+                            skaterAnimList = own['skaterAnimList']
+                            skaterAnimFList = own['skaterAnimFList']
+                            deckAnimList = own['deckAnimList']
+                            deckAnimFList = own['deckAnimFList']
+                            srollVolList = own['srollVolList']
+                            srollPitchList = own['srollPitchList']
+                            sgrind_cementVolList = own['sgrind_cementVolList']
+                            sgrind_cementPitchList = own['sgrind_cementPitchList']
+                            sgrind_railVolList = own['sgrind_railVolList']
+                            sgrind_railPitchList = own['sgrind_railPitchList']
+                            spopsoundList = own['spopsoundList']
+                            slandsoundList = own['slandsoundList']
+                            sdeckvisList = own['sdeckvisList']
+                            positiontdList = own['positiontdList']
+                            orientationtdList = own['orientationtdList']
+                            srevertsoundList = own['srevertsoundList']
+                                                        
+                            
+                                           
+                            
+                            if printDebug:
+                                print("Read file "+allDataPath)
+                                own['inited'] = True
+                    except:
+                        print("error reading replay data")        
+            except IOError:
+                if printDebug:
+                    print("Error reading "+allDataPath)
+
+    def returnPosition(objIndex, valueIndex, own):
+        positionList = own['positionList']
+        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(" ","")
+            #print(position)
+            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]
+            #print(name, position)
+            return(name, position)
+
+    def returnOrientation(objIndex, valueIndex, own):
+        orientationList = own['orientationList']
+        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):
+
+        if scaleList:
+            name = scaleList[objIndex-2]
+            scale = scaleList[valueIndex-2]
+            
+            name = name.replace(" ","")
+            
+            scale = str(scale)
+            scale = scale.replace(","," ")
+            
+            sX = float(scale.split()[0])
+            sY = float(scale.split()[1])
+            sZ = float(scale.split()[2])
+            
+            scale = [sX,sY,sZ]
+
+            return(name, scale)
+
+    def returnColor(objIndex, valueIndex):
+
+        if colorList:
+            name = colorList[objIndex-2]
+            color = colorList[valueIndex-2]
+            
+            name = name.replace(" ","")
+            
+            color = str(color)
+            color = color.replace(","," ")
+            
+            cR = float(color.split()[0])
+            cG = float(color.split()[1])
+            cB = float(color.split()[2])
+            cA = float(color.split()[3])
+            
+            color = [cR,cG,cB,cA]
+
+            return(name, color)
+    
+    def returnState(objIndex, valueIndex):
+        
+        if stateList:
+            name = stateList[objIndex-2]
+            state = stateList[valueIndex-2]
+            
+            name = name.replace(" ","")
+            
+            state = str(state)
+            state = state.replace(","," ")
+            state = int(state)
+            
+            return(name, state)
+    
+    def returnVisibility(objIndex, valueIndex):
+        
+        if visibilityList:
+            name = visibilityList[objIndex-2]
+            visible = visibilityList[valueIndex-2]
+            
+            name = name.replace(" ","")
+            
+            visible = str(visible)
+            visible = visible.replace(","," ")
+            
+            return(name, visible)
+        
+    def returnSkaterAnim(objIndex, valueIndex, own):  
+        #print('getting anim list') 
+        #print(objIndex-2)     
+        skaterAnimList = own['skaterAnimList']
+        #print(skaterAnimList)
+        if skaterAnimList:
+            name = skaterAnimList[objIndex-2]
+
+            skaterAnim = skaterAnimList[valueIndex-2]
+            name = name.replace(" ","")           
+            skaterAnim = str(skaterAnim)
+            skaterAnim = skaterAnim.replace(","," ") 
+            if skaterAnim == 'control_cube.002':
+                skaterAnim = skaterAnimList[valueIndex-3]
+                name = name.replace(" ","")           
+                skaterAnim = str(skaterAnim)
+                skaterAnim = skaterAnim.replace(","," ") 
+            #print(skaterAnim, (objIndex-2), (valueIndex-2)) 
+            #print(skaterAnimList)         
+            return(name, skaterAnim) 
+        
+    def returnSkaterAnimF(objIndex, valueIndex, own): 
+        skaterAnimFList =  own['skaterAnimFList']      
+        if skaterAnimFList:
+            name = skaterAnimFList[objIndex-2]
+            skaterAnimF = skaterAnimFList[valueIndex-2]
+            name = name.replace(" ","")
+            skaterAnimF = str(skaterAnimF)
+            skaterAnimF = skaterAnimF.replace(","," ")
+            #print('sOi', objIndex, 'sVi', valueIndex)
+            return(name, skaterAnimF)  
+        
+    def returnDeckAnim(objIndex, valueIndex, own): 
+        #print(objIndex-2)   
+        deckAnimList = own['deckAnimList']
+        if deckAnimList:
+            name = deckAnimList[objIndex-2]
+            deckAnim = deckAnimList[valueIndex-2]
+            name = name.replace(" ","")
+            deckAnim = str(deckAnim)
+            deckAnim = deckAnim.replace(","," ")
+            if deckAnim == 'control_cube.002':
+                deckAnim = deckAnimList[valueIndex-3]
+                name = name.replace(" ","")
+                deckAnim = str(deckAnim)
+                deckAnim = deckAnim.replace(","," ")
+            #print(deckAnim, (objIndex-2), (valueIndex-2))
+            #print('dOi', objIndex, 'dVi', valueIndex)            
+            return(name, deckAnim) 
+        
+    def returnDeckAnimF(objIndex, valueIndex, own):
+        deckAnimFList = own['deckAnimFList']
+        if deckAnimFList:
+            name = deckAnimFList[objIndex-2]
+            deckAnimF = deckAnimFList[valueIndex-2]
+            name = name.replace(" ","")
+            deckAnimF = str(deckAnimF)
+            deckAnimF = deckAnimF.replace(","," ")            
+            return(name, deckAnimF)
+###
+    def returnSrollVol(objIndex, valueIndex):
+        if srollVolList:
+            name = srollVolList[objIndex-2]
+            srollVol = srollVolList[valueIndex-2]
+            name = name.replace(" ","")
+            srollVol = str(srollVol)
+            srollVol = srollVol.replace(","," ")
+            srollVol = float(srollVol)
+            return(name, srollVol)
+        
+    def returnSrollPitch(objIndex, valueIndex):
+        if srollPitchList:
+            name = srollPitchList[objIndex-2]
+            srollPitch = srollPitchList[valueIndex-2]
+            name = name.replace(" ","")
+            srollPitch = str(srollPitch)
+            srollPitch = srollPitch.replace(","," ")
+            srollPitch = float(srollPitch)
+            return(name, srollPitch)                             ####
+###
+    def returnSgrind_cementVol(objIndex, valueIndex):
+        if sgrind_cementVolList:
+            name = sgrind_cementVolList[objIndex-2]
+            sgrind_cementVol = sgrind_cementVolList[valueIndex-2]
+            name = name.replace(" ","")
+            sgrind_cementVol = str(sgrind_cementVol)
+            sgrind_cementVol = sgrind_cementVol.replace(","," ")
+            sgrind_cementVol = float(sgrind_cementVol)
+            return(name, sgrind_cementVol)
+        
+    def returnSgrind_cementPitch(objIndex, valueIndex):
+        if sgrind_cementPitchList:
+            name = sgrind_cementPitchList[objIndex-2]
+            sgrind_cementPitch = sgrind_cementPitchList[valueIndex-2]
+            name = name.replace(" ","")
+            sgrind_cementPitch = str(sgrind_cementPitch)
+            sgrind_cementPitch = sgrind_cementPitch.replace(","," ")
+            sgrind_cementPitch = float(sgrind_cementPitch)
+            return(name, sgrind_cementPitch)                             ####              
+###
+    def returnSgrind_railVol(objIndex, valueIndex):
+        if sgrind_railVolList:
+            name = sgrind_railVolList[objIndex-2]
+            sgrind_railVol = sgrind_railVolList[valueIndex-2]
+            name = name.replace(" ","")
+            sgrind_railVol = str(sgrind_railVol)
+            sgrind_railVol = sgrind_railVol.replace(","," ")
+            sgrind_railVol = float(sgrind_railVol)
+            return(name, sgrind_railVol)
+        
+    def returnSgrind_railPitch(objIndex, valueIndex):
+        if sgrind_railPitchList:
+            name = sgrind_railPitchList[objIndex-2]
+            sgrind_railPitch = sgrind_railPitchList[valueIndex-2]
+            name = name.replace(" ","")
+            sgrind_railPitch = str(sgrind_railPitch)
+            sgrind_railPitch = sgrind_railPitch.replace(","," ")
+            sgrind_railPitch = float(sgrind_railPitch)
+            return(name, sgrind_railPitch)                             ####
+    def returnSpopsound(objIndex, valueIndex):
+        if spopsoundList:
+            name = spopsoundList[objIndex-2]
+            spopsound = spopsoundList[valueIndex-2]
+            name = name.replace(" ","")
+            spopsound = str(spopsound)
+            spopsound = spopsound.replace(","," ")
+            spopsound = int(spopsound)
+            return(name, spopsound)
+    def returnSlandsound(objIndex, valueIndex):
+        if slandsoundList:
+            name = slandsoundList[objIndex-2]
+            slandsound = slandsoundList[valueIndex-2]
+            name = name.replace(" ","")
+            slandsound = str(slandsound)
+            slandsound = slandsound.replace(","," ")
+            slandsound = int(slandsound)
+            return(name, slandsound) 
+    def returnSdeckvis(objIndex, valueIndex):
+        if sdeckvisList:
+            name = sdeckvisList[objIndex-2]
+            sdeckvis = sdeckvisList[valueIndex-2]
+            name = name.replace(" ","")
+            sdeckvis = str(sdeckvis)
+            sdeckvis = sdeckvis.replace(","," ")
+            sdeckvis = int(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(own):
+        positionList = own['positionList'] 
+        if positionList:
+            return(len(positionList))
+
+    def getLengthOri(own):
+        orientationList = own['orientationList']
+        if orientationList:
+            return(len(orientationList))
+
+    def getLengthSca():
+        if scaleList:
+            return(len(scaleList))
+
+    def getLengthCol():
+        if colorList:
+            return(len(colorList))
+    
+    def getLengthSta():
+        if stateList:
+            return(len(stateList))
+    
+    def getLengthVis():
+        if visibilityList:
+            return(len(visibilityList))
+    def getLengthSkaterAnim(own):
+        skaterAnimList = own['skaterAnimList']
+        if skaterAnimList:
+            return(len(skaterAnimList)) 
+    def getLengthSkaterAnimF(own):
+        skaterAnimFList = own['skaterAnimFList']
+        if skaterAnimFList:
+            return(len(skaterAnimFList)) 
+    def getLengthDeckAnim(own):
+        deckAnimList = own['deckAnimList']
+        if deckAnimList:
+            return(len(deckAnimList)) 
+    def getLengthDeckAnimF(own):
+        deckAnimFList = own['deckAnimFList']
+        if deckAnimFList:
+            #print(len(deckAnimFList), 'deckanimflisht')
+            return(len(deckAnimFList))
+    def getLengthSrollVol():
+        if srollVolList:
+            return(len(srollVolList)) 
+    def getLengthSrollPitch():
+        if srollPitchList:
+            return(len(srollPitchList)) 
+    def getLengthSgrind_cementVol():
+        if sgrind_cementVolList:
+            return(len(sgrind_cementVolList)) 
+    def getLengthSgrind_cementPitch():
+        if sgrind_cementPitchList:
+            return(len(sgrind_cementPitchList))
+    def getLengthSgrind_railVol():
+        if sgrind_railVolList:
+            return(len(sgrind_railVolList)) 
+    def getLengthSgrind_railPitch():
+        if sgrind_railPitchList:
+            return(len(sgrind_railPitchList))
+    def getLengthSpopsound():
+        if spopsoundList:
+            return(len(spopsoundList)) 
+    def getLengthSlandsound():
+        if slandsoundList:
+            return(len(slandsoundList)) 
+    def getLengthSdeckvis():
+        if 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))    
+             
+                                                                                                    

scripts/ai_manager.py

+def printplaying(skater,deck):
+    splaying_layers = "S: "
+    playing_layers = "D: "
+    tplaying_layers = "T: "
+    for x in range(9999):
+        if skater.isPlayingAction(x):
+        #if trucks.isPlayingAction(x):
+        #if skater.isPlayingAction(x):                        
+            splaying_layers += str(x)
+            splaying_layers += " "        
+        if deck.isPlayingAction(x):
+        #if trucks.isPlayingAction(x):
+        #if skater.isPlayingAction(x):                        
+            playing_layers += str(x)
+            playing_layers += " "
+          
+    print(splaying_layers, playing_layers)
+
+def main():
+
+    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 = 6974#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.
+
+    from bge import logic
+    import aiRecord
+    import aiSortData
+    import npcChangeAnim
+    from mathutils import Vector
+    import math
+    
+    debugg = True
+
+    cont = logic.getCurrentController()
+    own = cont.owner
+    scene = logic.getCurrentScene()
+    dict = logic.globalDict
+    own['valueIndex'] = own['valueIndex'] + 2
+    #dict['recorder_on'] = recorder_on
+    npc_index = own['npc_index']
+    skater = dict['spawned_npcs'][npc_index]
+    recorder_on = dict.get('recorder_on')
+    own['recorder_on'] = recorder_on
+    #print("recorder on: ", recorder_on) 
+    own["playback"] = True
+    recording_cutoff = own['replay_length']
+    idle_timer = own['idle_timer']
+    npc_playback = own['npc_playback']
+    
+    
+    
+    if 'data_loaded' not in own:
+        #own['data_loaded'] = 1
+        aiRecord.loadData(cont, own)
+        if debugg: print('ai_loadData')
+        
+    if npc_playback == True:
+        cube = own
+        aiRecord.loadData(cont, own)   
+        #own['move'] = False          
+        #....................
+
+        valueIndex = own['valueIndex']
+        n = (valueIndex / recording_cutoff) * 1000
+        n = int(round(n))
+        #print(own['valueIndex'])
+        if own['objIndex'] < (recording_cutoff-3):
+            own['objIndex'] = own['objIndex'] + 2
+        else:
+            own['objIndex'] = 4   
+            print('replay end')    
+            npcChangeAnim.main(cont)
+            #own['npc_replay_name'] = '30secA.dat'
+            own['inited'] = False
+            own['rotate_in'] = True
+            own['move_to'] = True
+            own['rotate_out'] = True 
+            aiRecord.loadData(cont, own)
+    else:
+        if idle_timer < 5:
+            idle_timer += 1
+            #print('idling', idle_timer)
+        else:
+            idle_timer = 0
+            own['npc_rotate'] = True                 
+            
+    if own['move'] == True:
+        speed = .15
+        target = own['rpStartLoc']
+        my_vector = Vector([target[0], target[1], target[2]])
+        length = (own.worldPosition - my_vector).length
+        obj = own['target_object_name']
+        vect = own.getVectTo(obj)   
+        if length < .1:
+            own['move'] = False
+            obj = own['target_object_name']
+    own['idle_timer'] = idle_timer   
+    
+    try:
+        obj = own['target_object_name']
+        #print(obj.worldPosition)
+    except:
+        pass    
+    
+    
+    #11111111
+    if own['rotate_in'] == False and own['move_to'] == False and own['rotate_out'] == False:
+        own['npc_playback'] = True
+        #obj = own['target_object_name']
+        #obj.endObject()
+        #print('ending target')    
+    if own['rotate_in'] == True:
+        tActu = cont.actuators['npcTracking']
+        tActu.object = own['target_object_name']
+        try:
+            own['rotate_in_timer'] = own['rotate_in_timer'] + 1
+        except:
+            own['rotate_in_timer'] = 0
+        if own['rotate_in_timer'] < 120:    
+            cont.activate(tActu)
+            skater.playAction('reg_idle1', 0,120, layer=2, play_mode=1, speed=.5)  
+        else:
+            cont.deactivate(tActu) 
+            own['rotate_in'] = False
+            own['rotate_in_timer'] = 0
+            skater.stopAction(2)
+
+    elif own['move_to'] == True:
+        target = own['rpStartLoc']
+        #print(target, 'target', own.worldPosition, '++++++')
+        my_vector = Vector([target[0], target[1], target[2]])
+        length = (own.worldPosition - my_vector).length
+        sActu = cont.actuators['npcSteering']
+        sActu.target = own['target_object_name']
+        #length = round(length, 7)
+        if length > .1:
+            #print(length, 'length < .1')
+            #pass
+            cont.activate(sActu)
+            skater.playAction('reg_nwalk', 0,35, layer=2, play_mode=1, speed=.5)
+        else:
+            cont.deactivate(sActu)
+            own['move_to'] = False
+            print(length, 'length met')
+            skater.stopAction(2)
+
+    elif own['rotate_out'] == True:    
+        #own['rpStartZ'] = 180
+        #print(own['rpStartZ'], 'start')
+        xyz = own.localOrientation.to_euler()
+        #print(xyz[2], 'non euler')
+        rotz = math.degrees(xyz[2])
+        xyz[2] = xyz[2] + 1.57
+        rotz_b = rotz + 180
+        if rotz_b > 360:
+            rotz_b -= 360
+        srotz_b = own['rpStartZ'] + 180
+        if srotz_b > 360:
+            srotz_b -= 360
+        #print (rotz_b, srotz_b, '---rotations')        
+        #print (rotz, own['rpStartZ'], '---rotations')
+        num = rotz - (own['rpStartZ'])
+        amt = .03
+        amt2 = 1
+        
+        
+        local = own.worldOrientation.inverted() * ( own['target_object_name'].worldPosition - own.worldPosition) 
+
+        if local.x >0:
+            #target is in front
+            #print('in front')
+            pass
+        else:
+            #target is behind
+            #print('behind')
+            pass
+        if local.y > 0:
+                 #object on right
+            #print('on right')
+            rot = 'right'
+        else:
+                 #object is on left 
+            #print('on left')
+            rot = 'left'       
+        
+        
+        
+        skater.playAction('reg_idle1', 0,120, layer=2, play_mode=1, speed=.5)
+        if abs(num) < amt2:
+            own['npc_playback'] = True
+            own['npc_rotate'] = False
+            print('----starting replay', num)
+            own['rotate_out'] = False
+            obj = own['target_object_name']
+            obj.endObject()
+            print('ending target') 
+            skater.stopAction(2)            
+        #elif rotz > own['rpStartZ']:
+        elif rot == 'right':    
+            own.applyRotation([0,0,amt], True)
+            own.worldPosition = own['rpStartLoc']
+        #elif rotz < own['rpStartZ']:
+        elif rot == 'left':    
+            own.applyRotation([0,0,-amt], True) 
+            own.worldPosition = own['rpStartLoc']                
+    #print(own['rotate_in'], own['move_to'], own['rotate_out'])                          
+main()

scripts/bike.py

+
+
+import bge
+from mathutils import Vector
+
+dict = bge.logic.globalDict
+scene = bge.logic.getCurrentScene()
+skater = scene.objects["Char4"]
+TURN_SENS = .04
+TURNAMT = .03
+AIR_TURMAMT = .07
+ACCEL_AMT = .06
+JUMP_AMT = 1300
+
+
+def turnL(own, gray):
+    if gray.positive:
+        own.applyRotation([0,0,TURNAMT], True)
+    else:            
+        own.applyRotation([0,0,AIR_TURMAMT], True)
+def turnR(own, gray):
+    if gray.positive:
+        own.applyRotation([0,0,-TURNAMT], True)
+    else:            
+        own.applyRotation([0,0,-AIR_TURMAMT], True)    
+def reset_timers(own, q1oncd, q2oncd, q3oncd, q4oncd, q5oncd, q6oncd, q7oncd, q8oncd):
+     q1oncd = 0
+     q2oncd = 0 
+     q3oncd = 0 
+     q4oncd = 0 
+     q5oncd = 0 
+     q6oncd = 0 
+     q7oncd = 0 
+     q8oncd = 0 
+     own["Q1oncd"] = 0
+     own["Q2oncd"] = 0
+     own["Q3oncd"] = 0
+     own["Q4oncd"] = 0
+     own["Q5oncd"] = 0
+     own["Q6oncd"] = 0
+     own["Q7oncd"] = 0
+     own["Q8oncd"] = 0
+
+
+def get_physics_action(cont, own):
+    #print(dict['lLR'])
+    action = 'None'
+    gray = cont.sensors['r_Ground']
+    
+    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']    
+    
+    q1oncd = own["Q1oncd"]
+    q2oncd = own["Q2oncd"]
+    q3oncd = own["Q3oncd"]
+    q4oncd = own["Q4oncd"]
+    q5oncd = own["Q5oncd"]
+    q6oncd = own["Q6oncd"]
+    q7oncd = own["Q7oncd"]
+    q8oncd = own["Q8oncd"]
+    q1oncdl = own["Q1oncdl"]
+    q2oncdl = own["Q2oncdl"]
+    q3oncdl = own["Q3oncdl"]
+    q4oncdl = own["Q4oncdl"]
+    q5oncdl = own["Q5oncdl"]
+    q6oncdl = own["Q6oncdl"]
+    q7oncdl = own["Q7oncdl"]
+    q8oncdl = own["Q8oncdl"]
+
+    q1on = 0
+    q2on = 0
+    q3on = 0
+    q4on = 0
+    q5on = 0
+    q6on = 0
+    q7on = 0
+    q8on = 0
+    lq1on = 0
+    lq2on = 0
+    lq3on = 0
+    lq4on = 0
+    lq5on = 0
+    lq6on = 0
+    lq7on = 0
+    lq8on = 0
+    
+    countdown = 20    
+    
+    
+    ##################
+    ###realcontrols###
+    ##################
+    #       q1
+    #    q8    q2
+    # q7          q3
+    #    q6    q4
+    #       q5
+    ##################    
+    
+    if lUD > .04 and lLR < -0.04 :
+        lq6on = 1
+        q6oncdl = countdown
+        own["Q6oncdl"] = q6oncdl
+        #print("lq6on")
+    elif q6oncdl > 0:
+        lq6on = 0
+        q6oncdl = q6oncdl - 1
+        own["Q6oncdl"] = q6oncdl
+    #lq8
+    if lUD < -.04 and lLR < -0.04 :
+        lq8on = 1
+        q8oncdl = countdown
+        own["Q8oncdl"] = q8oncdl
+        #print("lq8on")
+    elif q8oncdl > 0:
+        lq8on = 0
+        q8oncdl = q8oncdl - 1
+        own["Q8oncdl"] = q8oncdl
+    #lq2
+    if lUD < -.04 and lLR > 0.04 :
+        lq2on = 1
+        q2oncdl = countdown
+        own["Q2oncdl"] = q2oncdl
+        #print("lq2on")
+    elif q2oncdl > 0:
+        lq2on = 0
+        q2oncdl = q2oncdl - 1
+        own["Q2oncdl"] = q2oncdl
+    #q4
+    if lUD > 0.04 and lLR > 0.04 :
+        lq4on = 1
+        q4oncdl = countdown
+        own["Q4oncdl"] = q4oncdl
+        #print("lq4on")
+    elif q4oncdl > 0:
+        lq4on = 0
+        q4oncdl = q4oncdl - 1
+        own["Q4oncdl"] = q4oncdl  
+    #q5
+    if lUD > .070 and lq4on == 0 and lq6on == 0:
+        lq5on = 1
+        q5oncdl = countdown
+        own["Q5oncdl"] = q5oncdl
+        #print("lq5on")
+    elif q5oncdl > 0:
+        lq5on = 0
+        q5oncdl = q5oncdl - 1
+        own["Q5oncdl"] = q5oncdl   
+    #q1    
+    if lUD < -0.070 and lq8on !=1 and lq2on != 1:
+        lq1on = 1
+        q1oncdl = countdown
+        own["Q1oncdl"] = q1oncdl
+        #print("lq1on")              
+    elif q1oncdl > 0:
+        lq1on = 0
+        q1oncdl = q1oncdl - 1
+        own["Q1oncdl"] = q1oncdl   
+    #q7
+    if lLR < -0.070 and lq8on != 1 and lq6on != 1:
+        lq7on = 1
+        q7oncdl = countdown
+        own["Q7oncdl"] = q7oncdl
+        #print("lq7on")       
+    elif q7oncdl > 0:
+        lq7on = 0
+        q7oncdl = q7oncdl - 1
+        own["Q7oncdl"] = q7oncdl  
+    #q3    
+    if lLR > 0.070 and lq2on !=1 and lq4on != 1:
+        lq3on = 1
+        q3oncdl = countdown
+        own["Q3oncdl"] = q3oncdl
+        #print("lq3on") 
+    elif q3oncdl > 0:
+        lq3on = 0
+        q3oncdl = q3oncdl - 1
+        own["Q3oncdl"] = q3oncdl       
+         
+    ################
+    #q6
+    if rUD > .04 and rLR < -0.04 :
+        q6on = 1
+        q6oncd = countdown
+        own["Q6oncd"] = q6oncd
+        #print("q6on")
+    elif q6oncd > 0:
+        q6on = 0
+        q6oncd = q6oncd - 1
+        own["Q6oncd"] = q6oncd
+        
+    #q8
+    if rUD < -.04 and rLR < -0.04 :
+        q8on = 1
+        q8oncd = countdown
+        own["Q8oncd"] = q8oncd
+        #print("q8on")
+    elif q8oncd > 0:
+        q8on = 0
+        q8oncd = q8oncd - 1
+        own["Q8oncd"] = q8oncd
+    #q2
+    if rUD < -.04 and rLR > 0.04 :
+        q2on = 1
+        q2oncd = countdown
+        own["Q2oncd"] = q2oncd
+        #print("q2on")
+    elif q2oncd > 0:
+        q2on = 0
+        q2oncd = q2oncd - 1
+        own["Q2oncd"] = q2oncd
+        
+    #q4
+    if rUD > 0.04 and rLR > 0.04 :
+        q4on = 1
+        q4oncd = countdown
+        own["Q4oncd"] = q4oncd
+        #print("q4on")
+    elif q4oncd > 0:
+        q4on = 0
+        q4oncd = q4oncd - 1
+        own["Q4oncd"] = q4oncd
+    #q5
+    if rUD > .070 or dict['kb_space'] == 2:
+        if q4on == 0 and q6on == 0:
+            q5on = 1
+            q5oncd = countdown
+            own["Q5oncd"] = q5oncd  
+    elif q5oncd > 0:
+        q5on = 0
+        q5oncd = q5oncd - 1
+        own["Q5oncd"] = q5oncd              
+
+    #q1    
+    if rUD < -0.070:
+        if q2on == 0 and q8on == 0:
+            #print("q1on")
+            q1on = 1
+            q1oncd = countdown
+            own["Q1oncd"] = q1oncd
+    elif q1oncd > 0:
+        q1on = 0
+        q1oncd = q1oncd - 1
+        own["Q1oncd"] = q1oncd            
+
+            
+      
+    #q7
+    if rLR < -0.070:
+        if q8on == 0 and q6on == 0:
+            q7on = 1
+            q7oncd = countdown
+            own["Q7oncd"] = q7oncd
+           
+    elif q7oncd > 0:
+        q7on = 0
+        q7oncd = q7oncd - 1
+        own["Q7oncd"] = q7oncd
+    #q3    
+    if rLR > 0.070:
+        if q4on == 0 and q2on == 0:
+            q3on = 1
+            q3oncd = countdown
+            own["Q3oncd"] = q3oncd
+    elif q3oncd > 0:
+        q3on = 0
+        q3oncd = q3oncd - 1
+        own["Q3oncd"] = q3oncd
+            
+     
+    
+    if dict['aBut'] == True:
+        action = 'forward'    
+    if dict['lLR'] > TURN_SENS:
+        action = 'turnR'
+        turnR(own, gray)
+    if dict['lLR'] < -TURN_SENS:
+        #action = 'turnL'    
+        turnL(own, gray)
+    if (q5oncd > 0 and q1oncd > 0 and q5oncd < q1oncd) or (q5oncd > 0 and q8oncd > 0 and q5oncd < q8oncd) or (q5oncd > 0 and q2oncd > 0 and q5oncd < q2oncd):
+        action = 'jump'
+        reset_timers(own, q1oncd, q2oncd, q3oncd, q4oncd, q5oncd, q6oncd, q7oncd, q8oncd)           
+
+
+    return action
+
+
+
+def do_physics_action(cont, own, action):
+#    if action == 'turnR':
+#        own.applyRotation([0,0,-TURNAMT], True)
+#    if action == 'turnL':
+#        own.applyRotation([0,0,TURNAMT], True)
+    if action == 'forward':
+        own.linearVelocity.x = own.linearVelocity.x - ACCEL_AMT
+    
+    if action == 'jump':
+        own.applyForce([0,0,JUMP_AMT], False)
+        print('jump')    
+    
+    gray = cont.sensors['r_Ground']
+    if gray.positive:
+        own.alignAxisToVect(Vector(gray.hitNormal)*1, 2, .25)
+    else:
+        own.alignAxisToVect(Vector([0,0,1]),2,.005)     
+    
+    
+    
+    if gray.positive:
+        own.linearVelocity.z = own.linearVelocity.z -.05    
+        own.linearVelocity.y = 0  
+def do_anims(cont, own):
+    
+    skater = scene.objects["Char4"]
+    skater.playAction("reg_bike.001", 20,20, layer=2, play_mode=1, speed=1)
+       
+        
+def main(cont):
+    own = cont.owner
+    try:
+        bike = scene.objects['player_bike']
+        #print('biking')
+        if dict['yBut'] == True and dict['last_yBut'] == False:
+            cont.activate(cont.actuators['walk'])
+            pbike = scene.addObject('prop_bike', own, 0)
+            pbike.localScale = [4.6, 4.6, 4.6]
+            pbike.localScale = [1, 1, 1] 
+            pbike.applyRotation([0,0,1.570796], False)
+            pbike.worldPosition.y = pbike.worldPosition.y - 1.       
+            bike.endObject()
+            skater.stopAction(9)
+        
+        action = get_physics_action(cont, own)
+        do_physics_action(cont, own, action)
+        do_anims(cont,own)
+    except:
+        pass    

scripts/bpy_misc/pushpuller-addon.py

+import bpy
+ 
+class OBJECT_PT_pushpuller(bpy.types.Header):
+    bl_label = "Push Puller"
+    bl_space_type = "TEXT_EDITOR"
+    bl_region_type = "HEADER"
+    bl_context = "object"
+ 
+    def draw_header(self, context):
+        layout = self.layout
+        layout.label(text="", icon="PHYSICS")
+ 
+    def draw(self, context):
+        layout = self.layout
+        row = layout.row()
+        split = row.split(percentage=0.5)
+        col_left = split.column()
+        col_right = split.column()
+        col_right.operator("object.puller", text="Pull All")            
+        col_left.operator("object.pusher", text="Push All")
+        
+class OBJECT_OT_pusher(bpy.types.Operator):
+    bl_label = "Pusher"
+    bl_idname = "object.pusher"
+    bl_description = "Push text data block changes"
+ 
+    def execute(self, context):
+        area = bpy.context.area
+        for text in bpy.data.texts:
+            area.spaces[0].text = text
+            if text.filepath != '' and text.is_dirty:
+                bpy.ops.text.save() 
+                print("Saving: ", text.filepath)       
+        self.report({'INFO'}, "Performing push")
+        return {'FINISHED'}
+
+class OBJECT_OT_pullerer(bpy.types.Operator):
+    bl_label = "Puller"
+    bl_idname = "object.puller"
+    bl_description = "Pull text data block changes"
+ 
+    def execute(self, context):
+        area = bpy.context.area
+        self.report({'INFO'}, "Performing pull")
+        for text in bpy.data.texts:
+            area.spaces[0].text = text
+            if text.filepath != '':
+                try:
+                    bpy.ops.text.reload()
+                except:
+                    print("error reloading: ", text.filepath)    
+            if text.filepath != '' and text.is_dirty:
+                bpy.ops.text.save()
+        return {'FINISHED'}
+
+def register():
+    bpy.utils.register_module(__name__)
+ 
+def unregister():
+    bpy.utils.unregister_module(__name__)
+ 
+if __name__ == "__main__":
+    register()

scripts/camera.py

+#zskcam
+import bge
+import mathutils
+from mathutils import *
+scene = bge.logic.getCurrentScene()
+cont = bge.logic.getCurrentController()
+own = cont.owner
+def main():
+    dict = bge.logic.globalDict 
+    camempty = scene.objects['camEmpty.001']
+    controlcube = scene.objects['control_cube.002']
+    
+    camCube = scene.objects['camCube']
+    
+    dropinCol = controlcube.sensors['dropinCol']
+    LAST_GRIND = controlcube['LAST_GRIND']
+    up = cont.sensors['up']
+    ray = cont.sensors['up']
+    down = cont.sensors['down']
+    left = cont.sensors['left']
+    right = cont.sensors['right']
+    distance = 0.12
+    cam = cont.actuators["Camera"]
+    near = cont.sensors["Near"]
+    move = own.actuators["move"]
+    #match camera actuaotor
+    cam_def_height = dict['cam_height'] #-.1 #-.6
+    #cam_def_min = 1.6
+    #cam_def_max = 2.4
+    cam_def_min = dict['cam_min']
+    cam_def_max = dict['cam_max']
+    cam_height = cam.height 
+    cam_min = cam.min   
+    cam_max = cam.max
+    lasty = controlcube['lasty']
+    cam_moved = 0
+    lastCamheight = controlcube['lastCamheight']
+    raised = 0
+    walk = controlcube['walk']
+    cam.axis = 4
+    ccheight = controlcube.worldPosition[2]
+    camwpz = own.worldPosition[2]
+    zdist = camwpz - ccheight
+    
+    cam1 = scene.objects['Camera.003']
+    cam2 = scene.objects['freecam']
+    cam3 = scene.objects['followcam']
+    
+    camList = scene.cameras
+    freecam = camList["freecam"]     
+    
+    if 'init' not in own:
+        own['init'] = 1
+        own['last_move_x'] = 0
+        own['last_move_y'] = 0
+        own['last_move_z'] = 0
+        own['last_rot_x'] = 0
+        own['last_rot_y'] = 0
+        own['last_rot_z'] = 0
+        own['idlecampos_x'] = 0
+        own['speed_mult'] = 1.00 
+        controlcube['driving'] = False  
+        dict['cur_ccH_min'] = dict['cam_walk_min']
+        dict['cur_ccH_max'] = dict['cam_walk_max']
+        cam.height = dict['cam_height']
+    acam = scene.active_camera
+
+
+    
+    #if 1 == 1:
+    #if own['playback'] == False:
+    if controlcube['driving'] == False:
+        if down.triggered == True and LAST_GRIND == False and walk == 0:
+            hitPosition = down.hitPosition
+            distance = own.getDistanceTo(hitPosition)
+            cam_moved = 1       
+            if distance < .2:
+                camempty['hitdown'] = True
+                cam.height = cam_height + .3
+                cam.damping = .0 
+                #print("raise cam")
+            if zdist < -.2:
+                cam.height = lastCamheight + .01
+                cam.damping = .0
+                raised = 1    
+            if (distance > .4 and distance < .6) and zdist > -.2 and raised == 0:
+                camheight2 = cam.height - .001
+                if cam.height < .2: 
+                    cam.height = camheight2
+                    #print("slow lower")
+            if distance >= .6 and zdist > -.2 and raised == 0:
+                cam.height = cam.height - .02
+                #print("slow lower2")           
+        if down.triggered == False and LAST_GRIND == False and cam_moved == 0 and walk == 0:
+            camempty['hitdown'] = False
+            if cam_height > (cam_def_height + .06) and zdist > -.2 and raised == 0:
+                cam.height = cam_height - .02
+        if cam_height < -.6 and cam_moved == 0 and LAST_GRIND == False and zdist > -.2 and raised == 0 and walk == 0:
+            cam_height = .1  
+        if LAST_GRIND == True and walk == 0:
+            if cam.height < -.5 or zdist < -.2:
+                cam.height = cam.height + .013
+            if cam.height >= -.5 and not down.triggered:
+                pass
+        
+        if walk == 1:
+            if dropinCol.positive == True and lasty == True:
+                pass 
+            else:
+                pass   
+        controlcube['lastCamheight'] = cam.height    
+        #########
+        #cam.min = dict['cam_min']
+        #cam.max = dict['cam_max']
+        cont.activate(own.actuators['Camera'])  
+        ########
+        
+        if near.triggered == True and walk == 0:
+            #print("near")
+            if cam.min < 1:
+                cam.min = cam.min + .1
+                cam.max = cam.max + .1
+            cam.height = cam_height + .01
+            cam.damping = .001
+            cont.activate(move)
+            
+        else:
+            #print("far")
+            cont.deactivate(move)
+            if cam.min > cam_def_min:
+                cam.min = cam.min - .05
+                cam.max = cam.max - .05 
+            cam.damping = .0          
+        if cam.damping != 0 and down.triggered == False and near.triggered == False:
+            cam.damping = 0.91             
+
+        obj = cont.owner
+        cube = controlcube
+        to = cube
+        from2 = obj
+        distance = 0.0
+        property = ""
+        face = 1
+        xray = 0
+        poly = 0
+        hit = obj.rayCast( to, from2, distance, property, face, xray, poly)
+        control = "control_cube.002"
+        hitobj = hit[0]
+        hitobj = str(hitobj)
+        if hitobj != control and walk == 0:
+            cam.damping = .0 
+            if cam.height < 3:
+                cam.height = cam_height + .1
+    
+    if dict['menu_idle_timer'] > 300:
+        move_len = 2048
+        if own['idlecampos_x'] < move_len:
+            own['idlecampos_x'] += 1
+        if own['idlecampos_x'] == move_len:
+           own['idlecampos_x'] = 0     
+            
+        if own['idlecampos_x'] < (move_len / 2):
+            move = [.0001, 0, 0]
+            freecam.applyMovement( move, True)
+            freecam.applyRotation([.0001, 0, .0001],True)
+        if own['idlecampos_x'] > (move_len / 2):
+            move = [-.0001, 0, 0]
+            freecam.applyMovement( move, True)
+            freecam.applyRotation([-.0001, 0, -.0001],True)        
+        
+    if dict['npause'] == True:
+        cont.deactivate(own.actuators['Camera'])
+        controlcube['camera'] = 2
+    if controlcube['camera'] == 2 and dict['joy_con'] == 1:
+        cont.deactivate(own.actuators['Camera'])
+        scene.active_camera = freecam 
+        cont.activate(cube.actuators['freecam']) 
+        #print('activating camera', freecam)  
+#####        
+    #get value 0-100    
+        lLR = dict['lLR'] / .082 * 100
+        lUD = dict['lUD'] / .082 * 100 - 20 / 80
+        rLR = dict['rLR'] / .082 * 100 - 20 / 80
+        rUD = dict['rUD'] / .082 * 100 - 20 / 80
+        lTrig = dict['lTrig'] / .082 * 100 - 20 / 80
+        rTrig = dict['rTrig'] / .082 * 100 - 20 / 80
+#        lBump = dict['lBump']
+#        rBump = dict['rBump']
+        
+        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
+
+        #move camera
+        damping = .95
+        damping2 = 1.005
+        mult = .0005 * own['speed_mult']
+        move_x = lmUD * mult
+        move_y = lmLR * mult
+        move_z = (mTrig * -mult) / 2#4
+        
+        rot_mult = -.00015 * own['speed_mult']
+        rot_x = rmUD * rot_mult
+        rot_y = rmLR * rot_mult
+        
+        if move_x == 0 and own['last_move_x'] != 0:
+            move_x = own['last_move_x'] * damping
+        if move_y == 0 and own['last_move_y'] != 0:
+            move_y = own['last_move_y'] * damping 
+        if move_z == 0 and own['last_move_z'] != 0:
+            move_z = own['last_move_z'] * damping         
+        if rot_x == 0 and own['last_rot_x'] != 0:
+            rot_x = own['last_rot_x'] * damping
+        if rot_y == 0 and own['last_rot_y'] != 0:
+            rot_y = own['last_rot_y'] * damping         
+                             
+        move = [move_y, 0, move_x]
+        freecam.applyMovement( move, True)
+        freecam.applyMovement([0, 0, move_z], False)    
+        freecam.applyRotation([rot_x, 0, 0],True)
+        freecam.applyRotation([0, 0, rot_y],False)
+       
+        
+################    
+    #print(dict['walk'], 'walk')
+    multer = .02
+    if dict['walk'] == 1:
+        if dict['cur_ccH_targetHeight'] < dict['cam_walk_height']:
+            dist = dict['cam_walk_height'] - dict['cur_ccH_targetHeight']
+            
+            dict['cur_ccH_targetHeight'] = dict['cur_ccH_targetHeight'] + (dist * multer)
+            if dict['cur_ccH_targetHeight'] > dict['cam_walk_height']:
+                dict['cur_ccH_targetHeight'] = dict['cam_walk_height']
+                
+        cam.min = dict['cam_walk_min'] 
+        cam.max = dict['cam_walk_max']        
+        #ccH_targetHeight = .9
+    else:  
+
+        if dict['cur_ccH_targetHeight'] < dict['cch_targetHeight']:
+            dist = dict['cur_ccH_targetHeight'] - dict['cch_targetHeight']
+            dict['cur_ccH_targetHeight'] = dict['cur_ccH_targetHeight'] - (dist * multer)
+            if dict['cur_ccH_targetHeight'] > dict['cch_targetHeight'] - .001:
+                dict['cur_ccH_targetHeight'] = dict['cch_targetHeight']             
+
+        if dict['cur_ccH_targetHeight'] > dict['cch_targetHeight']:
+            dist = dict['cch_targetHeight'] - dict['cur_ccH_targetHeight'] 
+            dict['cur_ccH_targetHeight'] = dict['cur_ccH_targetHeight'] + (dist * multer)
+            if dict['cur_ccH_targetHeight'] < dict['cch_targetHeight'] + .001:
+                dict['cur_ccH_targetHeight'] = dict['cch_targetHeight']             
+        
+        
+    ccH_targetHeight = dict['cur_ccH_targetHeight']  
+    #print(dict['cur_ccH_targetHeight'])    
+    #dict['cur_ccH_targetHeight'] =            
+    #ccH_targetHeight = .3
+    ccH = camCube.worldPosition.z
+    pH = camCube.parent.worldPosition.z
+    ccheight = (round((ccH - pH), 2) - .4)
+    #print(ccheight, 'camera target height')
+    
+    localPos = camCube.localPosition.z
+    #print(localPos, 'local position')
+    if localPos != ccH_targetHeight:
+        num = ccH_targetHeight - localPos
+        camCube.localPosition.z += num
+    #if camHeightSet not in own:
+    if 1 == 1:    
+        num = ccH_targetHeight - ccheight
+    else:
+        own['camHeightSet'] = True    
+           
+    if dict['npause'] == False:
+        cont.activate(own.actuators['Camera']) 
+        controlcube['camera'] = 0    
+    
+    cur_lens = cam1.lens
+    cur_min = cam.min
+    cur_max = cam.max
+    #print(cur_lens)
+    inc = .025
+    if walk == 1:
+        #lens
+        if dict['walk_focal_length'] > cur_lens:
+            new_lens = cur_lens + inc
+        else:
+            new_lens = cur_lens - inc
+        if cur_lens  > (dict['walk_focal_length'] - .1) and cur_lens  < (dict['walk_focal_length'] + .1):
+            new_lens = dict['walk_focal_length']  
+            
+        #distance      
+        inc = .025   
+        if cur_min > (dict['cam_walk_min'] - inc):
+            new_min = cur_min - inc
+        if cur_min < (dict['cam_walk_min'] + inc):
+            new_min = cur_min + inc 
+        if cur_max > (dict['cam_walk_max'] - inc):
+            new_max = cur_min - inc
+        if cur_max < (dict['cam_walk_max'] + inc):
+            new_max = cur_min + inc           
+    else:
+        #lens
+        if dict['focal_length'] > cur_lens:
+            new_lens = cur_lens + inc
+        else:
+            new_lens = cur_lens - inc 
+        if cur_lens  > (dict['focal_length'] - .1) and cur_lens  < (dict['focal_length'] + .1):
+            new_lens = dict['focal_length'] 
+            
+        #distance  
+        inc = .025   
+        if cur_min > (dict['cam_min'] - inc):
+            new_min = cur_min - inc
+        if cur_min < (dict['cam_min'] + inc):
+            new_min = cur_min + inc 
+        if cur_max > (dict['cam_max'] - inc):
+            new_max = cur_min - inc
+        if cur_max < (dict['cam_max'] + inc):
+            new_max = cur_min + inc        
+            
+        
+            
+                                         
+        
+    focallength = new_lens
+    cam1.lens = focallength
+    cam2.lens = focallength
+    cam3.lens = focallength
+    try:
+        cam.min = new_min
+        cam.max = new_max  
+        #print(new_min, new_max)     
+    except:
+        pass    
+    
+                    
+main()

scripts/car.py

+"""
+
+CarSetup 
+
+
+"""
+
+#import blender game engine content
+from bge import logic, constraints
+
+#import other modules
+import math, mathutils
+
+
+os = 'Windows'
+from sys import platform
+if platform != "win32":
+ os = 'Linux'
+def onWindows():
+ return os == 'Windows'
+import bge
+import GameLogic
+import ctypes
+
+dict = bge.logic.globalDict 
+
+
+reduction = 400000
+axisTh = 0.03 
+
+cont = GameLogic.getCurrentController() 
+obj = bge.logic.getCurrentScene().objects
+own = cont.owner
+
+class CarSetup:
+    
+    def __init__(self):
+        
+        #list of cars
+        self.carList = {}
+        
+        #list of tires
+        self.tires = {}
+        
+        #car turn amount
+        self.turnAmount = {}
+    
+    
+    def carInitialized(self, car):
+        
+        #check for initialized property
+        if "initialized" in car:
+            
+            #check if car is initialized
+            if car["initialized"] == True:
+                
+                #car is initialized
+                return True
+        
+        #car is not initialized
+        return False
+    
+    
+    def carConstraint(self, car):
+        
+        #get physics ID
+        carPhysicsID = car.getPhysicsId()
+         
+        #create a vehicle constraint 
+        vehicleConstraint = constraints.createConstraint(carPhysicsID, 0, 11)
+         
+        #get the constraint ID
+        constraintID = vehicleConstraint.getConstraintId()
+          
+        #get the vehicle constraint ID
+        vehicleID =  constraints.getVehicleConstraint(constraintID)
+    
+        #save vehicle constraint ID as an object variable
+        car["vehicleID"] = vehicleID
+        
+        #return vehicle ID
+        return vehicleID
+    
+    
+    def positionTires(self, car):
+        
+        #get the list of tires
+        tireList = self.tires[car]
+        
+        tire1 = tireList["TireFD"]  #tire front drivers
+        tire2 = tireList["TireFP"]  #tire front passengers
+        tire3 = tireList["TireRD"]  #tire rear drivers
+        tire4 = tireList["TireRP"]  #tire rear passnengers
+        
+        tire1Pos = tire1.worldPosition  #tire front drivers
+        tire2Pos = tire2.worldPosition  #tire front passengers
+        tire3Pos = tire3.worldPosition  #tire rear drivers
+        tire4Pos = tire4.worldPosition  #tire rear passnengers
+        
+        #car position
+        carPos = car.worldPosition
+        
+        #tire front drivers
+        tire1Pos = [tire1Pos[0] - carPos[0],
+                    tire1Pos[1] - carPos[1],
+                    tire1Pos[2] - carPos[2]]
+        
+        #tire front passengers
+        tire2Pos = [tire2Pos[0] - carPos[0],
+                    tire2Pos[1] - carPos[1],
+                    tire2Pos[2] - carPos[2]]
+        
+        #tire rear drivers
+        tire3Pos = [tire3Pos[0] - carPos[0],
+                    tire3Pos[1] - carPos[1],
+                    tire3Pos[2] - carPos[2]]
+        
+        #tire rear passengers
+        tire4Pos = [tire4Pos[0] - carPos[0],
+                    tire4Pos[1] - carPos[1],
+                    tire4Pos[2] - carPos[2]]
+            
+        return (tire1Pos, tire2Pos, tire3Pos, tire4Pos)
+    
+    
+    def tireRadius(self, car):
+        
+        #get the list of tires
+        tireList = self.tires[car]
+        
+        tire1Radius = tireList["TireFD"].localScale[2]/2    #tire front drivers
+        tire2Radius = tireList["TireFP"].localScale[2]/2    #tire front passengers
+        tire3Radius = tireList["TireRD"].localScale[2]/2    #tire rear drivers
+        tire4Radius = tireList["TireRP"].localScale[2]/2    #tire rear passengers
+        
+        #check for radius override
+        if "Radius" in tireList["TireFD"]:
+            tire1Radius = tireList["TireFD"]["Radius"]
+            
+        if "Radius" in tireList["TireFP"]:
+            tire2Radius = tireList["TireFP"]["Radius"]
+            
+        if "Radius" in tireList["TireRD"]:
+            tire3Radius = tireList["TireRD"]["Radius"]
+            
+        if "Radius" in tireList["TireRP"]:
+            tire4Radius = tireList["TireRP"]["Radius"]
+        
+        #return (tire1Radius, tire2Radius, tire3Radius, tire4Radius)
+        return (.2, .2, .2, .2)
+    
+    
+    def suspensionHeight(self, car):
+        
+        tireList = self.tires[car]
+        
+        tire1height = 0.2   #tire front drivers
+        tire2height = 0.2   #tire front passengers
+        tire3height = 0.2   #tire rear drivers
+        tire4height = 0.2   #tire rear passengers
+        
+        #check for suspension height override
+        if "Height" in tireList["TireFD"]:
+            tire1height = tireList["TireFD"]["Height"]
+            
+        if "Height" in tireList["TireFP"]:
+            tire2height = tireList["TireFP"]["Height"]
+            
+        if "Height" in tireList["TireRD"]:
+            tire3height = tireList["TireRD"]["Height"]
+            
+        if "Height" in tireList["TireRP"]:
+            tire4height = tireList["TireRP"]["Height"]
+        
+        return (tire1height, tire2height, tire3height, tire4height)
+    
+    
+    def suspensionAngle(self):
+        
+        tire1Angle = [0, 0, -1] #tire front drivers
+        tire2Angle = [0, 0, -1] #tire front passengers
+        tire3Angle = [0, 0, -1] #tire rear drivers
+        tire4Angle = [0, 0, -1] #tire rear passengers
+        
+        return (tire1Angle, tire2Angle, tire3Angle, tire4Angle)
+    
+    
+    def tireAxis(self):
+        
+        tire1Axis = [-1, 0, 0]  #tire front drivers
+        tire2Axis = [-1, 0, 0]  #tire front passengers
+        tire3Axis = [-1, 0, 0]  #tire rear drivers
+        tire4Axis = [-1, 0, 0]  #tire rear passengers
+        
+        return (tire1Axis, tire2Axis, tire3Axis, tire4Axis)
+    
+    
+    def tireSteering(self):
+        
+        tire1Steer = True   #tire front drivers
+        tire2Steer = True   #tire front passengers
+        tire3Steer = False  #tire rear drivers
+        tire4Steer = False  #tire rear passengers
+        
+        return (tire1Steer, tire2Steer, tire3Steer, tire4Steer)
+    
+    
+    def addTires(self, car, vehicleID):
+        
+        #get the list of tires
+        tireList = self.tires[car]
+        
+        #list the tires
+        tires = [tireList["TireFD"],
+                 tireList["TireFP"],
+                 tireList["TireRD"],
+                 tireList["TireRP"]]
+        
+        #position the tires
+        tirePos = self.positionTires(car)
+        
+        #calculate tire radius
+        tireRadius = self.tireRadius(car)
+        
+        #get the suspension heght
+        suspensionHeight = self.suspensionHeight(car)
+        
+        #get the suspension angle
+        suspensionAngle = self.suspensionAngle()
+        
+        #get the tire axis
+        tireAxis = self.tireAxis()
+        
+        #get which wheels turn
+        tireSteer = self.tireSteering()
+        
+        for tire in range(0, 4):
+            
+            #tire object
+            obj = tires[tire]
+            
+            #tire position
+            pos = tirePos[tire]
+            
+            #tire suspension height
+            suspenHeight = suspensionHeight[tire]
+            
+            #angle of suspension
+            suspenAngle = suspensionAngle[tire]
+            
+            #tire rotation axis
+            axis = tireAxis[tire]
+            
+            #tire radius
+            radius = tireRadius[tire]
+            
+            #tire steering
+            steering = tireSteer[tire]
+            
+            #add wheel to car
+            vehicleID.addWheel(obj, pos, suspenAngle, axis, suspenHeight, radius, steering)
+            
+    
+    def tireGrip(self, car, vehicleID):
+        
+        #list of tires
+        tireList = self.tires[car]
+        #10
+        tire1Grip = 8  #tire front drivers
+        tire2Grip = 8  #tire front Passengers
+        tire3Grip = 8  #tire rear drivers
+        tire4Grip = 8  #tire rear passengers
+        
+        #check for grip override
+        if "Grip" in tireList["TireFD"]:
+            tire1Grip = tireList["TireFD"]["Grip"]
+            
+        if "Grip" in tireList["TireFP"]:
+            tire2Grip = tireList["TireFP"]["Grip"]
+            
+        if "Grip" in tireList["TireRD"]:
+            tire3Grip = tireList["TireRD"]["Grip"]
+            
+        if "Grip" in tireList["TireRP"]:
+            tire4Grip = tireList["TireRP"]["Grip"]
+        
+        vehicleID.setTyreFriction(tire1Grip, 0) #tire front drivers
+        vehicleID.setTyreFriction(tire2Grip, 1) #tire front Passengers
+        vehicleID.setTyreFriction(tire3Grip, 2) #tire rear drivers
+        vehicleID.setTyreFriction(tire4Grip, 3) #tire rear passengers
+        
+    
+    def suspensionCompression(self, car, vehicleID):
+        
+        #list of tires
+        tireList = self.tires[car]
+        #6
+        tire1Compress = 6   #tire front drivers
+        tire2Compress = 6   #tire front Passengers
+        tire3Compress = 6   #tire rear drivers
+        tire4Compress = 6   #tire rear passengers
+        
+        #check for compression override
+        if "Compression" in tireList["TireFD"]:
+            tire1Compress = tireList["TireFD"]["Compression"]
+            
+        if "Compression" in tireList["TireFP"]:
+            tire2Compress = tireList["TireFP"]["Compression"]
+            
+        if "Compression" in tireList["TireRD"]:
+            tire3Compress = tireList["TireRD"]["Compression"]
+            
+        if "Compression" in tireList["TireRP"]:
+            tire4Compress = tireList["TireRP"]["Compression"]
+        
+        vehicleID.setSuspensionCompression(tire1Compress, 0)    #tire front drivers
+        vehicleID.setSuspensionCompression(tire2Compress, 1)    #tire front Passengers
+        vehicleID.setSuspensionCompression(tire3Compress, 2)    #tire rear drivers
+        vehicleID.setSuspensionCompression(tire4Compress, 3)    #tire rear passengers
+    
+    
+    def suspensionDamping(self, car, vehicleID):
+        
+        #list of tires
+        tireList = self.tires[car]
+        
+        tire1Damp = 5   #tire front drivers
+        tire2Damp = 5   #tire front Passengers
+        tire3Damp = 5   #tire rear drivers
+        tire4Damp = 5   #tire rear passengers
+        
+        #check for damping override
+        if "Damping" in tireList["TireFD"]:
+            tire1Damp = tireList["TireFD"]["Damping"]
+            
+        if "Damping" in tireList["TireFP"]:
+            tire2Damp = tireList["TireFP"]["Damping"]
+            
+        if "Damping" in tireList["TireRD"]:
+            tire3Damp = tireList["TireRD"]["Damping"]
+            
+        if "Damping" in tireList["TireRP"]:
+            tire4Damp = tireList["TireRP"]["Damping"]
+        
+        vehicleID.setSuspensionDamping(tire1Damp, 0)    #tire front drivers
+        vehicleID.setSuspensionDamping(tire2Damp, 1)    #tire front Passengers
+        vehicleID.setSuspensionDamping(tire3Damp, 2)    #tire rear drivers
+        vehicleID.setSuspensionDamping(tire4Damp, 3)    #tire rear passengers
+    
+    
+    def suspensionStiffness(self, car, vehicleID):
+        
+        #list of tires
+        tireList = self.tires[car]
+        
+        tire1Stiffness = 12.5       #tire front drivers
+        tire2Stiffness = 12.5       #tire front Passengers
+        tire3Stiffness = 12.5       #tire rear drivers
+        tire4Stiffness = 12.5       #tire rear passengers
+        
+        #check for stiffness override
+        if "Stiffness" in tireList["TireFD"]:
+            tire1Stiffness = tireList["TireFD"]["Stiffness"]
+            
+        if "Stiffness" in tireList["TireFP"]:
+            tire2Stiffness = tireList["TireFP"]["Stiffness"]
+            
+        if "Stiffness" in tireList["TireRD"]:
+            tire3Stiffness = tireList["TireRD"]["Stiffness"]
+            
+        if "Stiffness" in tireList["TireRP"]:
+            tire4Stiffness = tireList["TireRP"]["Stiffness"]
+        
+        vehicleID.setSuspensionStiffness(tire1Stiffness, 0) #tire front drivers
+        vehicleID.setSuspensionStiffness(tire2Stiffness, 1) #tire front Passengers
+        vehicleID.setSuspensionStiffness(tire3Stiffness, 2) #tire rear drivers
+        vehicleID.setSuspensionStiffness(tire4Stiffness, 3) #tire rear passengers
+    
+    
+    def suspensionRollInfluence(self, car, vehicleID):
+        
+        #list of tires
+        tireList = self.tires[car]
+        
+        tire1Roll = -0.16   #tire front drivers
+        tire2Roll = -0.16   #tire front Passengers
+        tire3Roll = -0.16   #tire rear drivers
+        tire4Roll = -0.16   #tire rear passengers
+        
+        #check for roll influence override
+        if "RollInfluence" in tireList["TireFD"]:
+            tire1Roll = -tireList["TireFD"]["RollInfluence"]
+            
+        if "Roll" in tireList["TireFP"]:
+            tire2Roll = -tireList["TireFP"]["RollInfluence"]
+            
+        if "Roll" in tireList["TireRD"]:
+            tire3Roll = -tireList["TireRD"]["RollInfluence"]
+            
+        if "Roll" in tireList["TireRP"]:
+            tire4Roll = -tireList["TireRP"]["RollInfluence"]
+        
+        vehicleID.setRollInfluence(tire1Roll, 0)    #tire front drivers
+        vehicleID.setRollInfluence(tire2Roll, 1)    #tire front Passengers
+        vehicleID.setRollInfluence(tire3Roll, 2)    #tire rear drivers
+        vehicleID.setRollInfluence(tire4Roll, 3)    #tire rear passengers
+    
+    
+#create CarSetup object
+carsetup = CarSetup()
+
+
+def _initialize(controller):
+    
+    #get the car object
+    car = controller.owner
+    
+    #get current orientation
+    carOrient = car.worldOrientation
+    
+    #convert orientation to euler
+    carEuler = carOrient.to_euler()
+    newCarEuler = carOrient.to_euler()
+    
+    #set euler rotation
+    newCarEuler[0] = 0
+    newCarEuler[1] = 0
+    newCarEuler[2] = 0
+    
+    #set car orientation
+    car.worldOrientation = newCarEuler.to_matrix()
+    
+    if not car.name in carsetup.carList:
+        
+        #assign the car
+        carsetup.carList[car] = car
+        
+        tires = {}
+        
+        #look for tires
+        for c in car.children:
+            
+            tire = "Tire"
+            
+            #check if tire object
+            if "Tire" in c:
+                
+                #build the tire name
+                tire += c["Tire"]
+                
+                #add tire to list
+                tires[tire] = c
+                
+                #assign tires owner
+                c["owner"] = car.name
+                
+                #clear tire parent
+                c.removeParent()
+        
+        #add tires to list of tires
+        carsetup.tires[car] = tires
+        
+        #build the car constraint
+        vehicleID = carsetup.carConstraint(car)
+        
+        #add tires to car
+        carsetup.addTires(car, vehicleID)
+        
+        #set tire grip
+        carsetup.tireGrip(car, vehicleID)
+        
+        #set suspension compression
+        carsetup.suspensionCompression(car, vehicleID)
+        
+        #set suspension damping
+        carsetup.suspensionDamping(car, vehicleID)
+        
+        #set suspension stiffness
+        carsetup.suspensionStiffness(car, vehicleID)
+        
+        #set suspension roll influence
+        carsetup.suspensionRollInfluence(car, vehicleID)
+    
+    #set car orientation
+    car.worldOrientation = carEuler.to_matrix()
+    
+    #set car to initialized
+    car["initialized"] = True
+    
+    #set turn amount
+    carsetup.turnAmount[car] = 0
+    
+    #check for "TurnAmount" property in car
+    if not "TurnAmount" in car:
+        
+        #set default turn amount
+        car["TurnAmount"] = 50#35
+        
+    #check for "TurnSpeed" property in car
+    if not "TurnSpeed" in car:
+        
+        #set default turn speed
+        car["TurnSpeed"] = 1
+        car["TurnSpeed2"] = 20#2
+
+
+
+def _constraintID(car):
+        
+    # get saved vehicle Constraint ID
+    vehicleID = car["vehicleID"]
+    
+    return vehicleID
+
+
+def _powertrain(controller, car):
+    
+    #declare variables
+    gas = None
+    reverse = None
+    brake = None
+    ebrake = None
+    
+    #get the vehicl id
+    vehicleID = _constraintID(car)
+    
+    #engine power
+    power = 0
+    
+    #engine
+    engine = True
+    
+    #check for engine override
+    if "Engine" in car:
+        engine = car["Engine"]
+    
+    
+    
+    #set default values
+    forwardSpeed = 70
+    
+    reverseSpeed = 200
+    brakeAmount = 10
+    eBrakeAmount = 40
+    backdrive = True
+    frontdrive = False
+    
+    #check for forward speed override
+    if "ForwardSpeed" in car:
+        
+        #set forward speed
+        forwardSpeed = car["ForwardSpeed"]
+    
+    #check for reverse speed override
+    if "ReverseSpeed" in car:
+        
+        #set reverse speed
+        reverseSpeed = car["ReverseSpeed"]
+    
+    #check for brake amount override
+    if "BrakeAmount" in car:
+        
+        #set brake amount
+        brakeAmount = car["BrakeAmount"]
+    
+    #check for E-brake amount override
+    if "EBrakeAmount" in car:
+        
+        #set brake amount
+        eBrakeAmount = car["EBrakeAmount"]
+    
+    #check for BackWheelDrive override
+    if "BackWheelDrive" in car:
+        
+        #set back wheel drive
+        backdrive = car["BackWheelDrive"]
+    
+    #check for FrontWheelDrive override
+    if "FrontWheelDrive" in car:
+        
+        #set front wheel drive
+        frontdrive = car["FrontWheelDrive"]
+    
+    #check for gas sensor
+    if "Gas" in controller.sensors:
+        #gas = controller.sensors["Gas"]       
+        gas = own['gas']
+    #check for reverse sensor
+    #if "Reverse" in controller.sensors:
+        #reverse = controller.sensors["Reverse"]
+    reverse = own['reverse']
+    #check for brake sensor
+    #if "Brake" in controller.sensors:
+        #brake = controller.sensors["Brake"]
+    brake = own['brake']
+    #check for E-brake sensor
+    if "EBrake" in controller.sensors:
+        ebrake = controller.sensors["EBrake"]
+    
+    #check if gas exists
+    if gas:
+        
+        #check if gas is positive
+        if gas == 1:
+            
+            #check if engine is on
+            if engine:
+                #set power
+                power = -forwardSpeed
+    
+    #check if reverse exists
+    #if reverse:
+        
+    #check if reverse is positive
+    if reverse == 1:
+        
+        #check if engine is on
+        if engine:
+            
+            #set power
+            power = reverseSpeed
+            
+            #check if gas exists
+            if gas:
+                
+                #check if gas is positive
+                if gas == 1:
+                    
+                    #set power
+                    power = 0
+    
+    #check if brake exists
+    #if brake:
+        
+    #check if brake is positive
+    if brake == 1:
+        
+        #apply braking
+        vehicleID.applyBraking(brakeAmount, 2)
+        vehicleID.applyBraking(brakeAmount, 3)
+        
+        #set power
+        power = 0
+        
+    else:
+        #remove braking
+        vehicleID.applyBraking(0, 2)
+        vehicleID.applyBraking(0, 3)
+        
+    #check if e brake exists
+    if ebrake:
+        
+        #check if e brake is positive
+        if ebrake.positive:
+            
+            #apply braking
+            vehicleID.applyBraking(eBrakeAmount, 2)
+            vehicleID.applyBraking(eBrakeAmount, 3)
+            
+            #set power
+            power = 0
+    
+            
+    #check if back wheel drive
+    if backdrive:
+        
+        #apply power
+        vehicleID.applyEngineForce(-power, 2)
+        vehicleID.applyEngineForce(-power, 3)
+        
+    #check if front wheel drive
+    if frontdrive:
+        
+        #apply power
+        vehicleID.applyEngineForce(-power, 0)
+        vehicleID.applyEngineForce(-power, 1)
+
+
+def _steer(controller, car):
+    
+    #declare variables
+    #left = None
+    #right = None
+    left = own['left']
+    right = own['right']
+    #turn amount
+    turnAmount = math.radians(car["TurnAmount"])
+    
+    #get turn speed
+    turnSpeed = car["TurnSpeed"] * 0.01
+    turnSpeed2 = car["TurnSpeed2"] * 0.01
+    
+    #get vehicle id
+    vehicleID = _constraintID(car)
+    
+    #check for left sensor
+    #if "Left" in controller.sensors:
+        #left = controller.sensors["Left"]
+        
+    #check for right sensor
+    #if "Right" in controller.sensors:
+        #right = controller.sensors["Right"]
+    
+    #check if the sensors exist
+    #if left and right:
+        
+        #check if both are positive
+        #if left.positive and right.positive:
+            
+            #pass
+        
+        #check if left is positive
+        #elif left.positive and not right.positive:
+    if left == True:    
+        #check turn amount
+        if carsetup.turnAmount[car] < turnAmount:
+            
+            #add to turn value
+            carsetup.turnAmount[car] += turnSpeed
+            
+            #apply steering
+            vehicleID.setSteeringValue(carsetup.turnAmount[car],0)
+            vehicleID.setSteeringValue(carsetup.turnAmount[car],1)
+    
+    #check if right is positive
+    #elif not left.positive and right.positive:
+    elif right == True:    
+        #check turn amount
+        if carsetup.turnAmount[car] > -turnAmount:
+            
+            #subtract from turn value
+            carsetup.turnAmount[car] -= turnSpeed
+            
+            #apply steering
+            vehicleID.setSteeringValue(carsetup.turnAmount[car],0)
+            vehicleID.setSteeringValue(carsetup.turnAmount[car],1)
+            
+    #check if none are positive
+    #elif not left.positive and not right.positive:
+    elif right == 0 and left == 0:
+        #print(round(carsetup.turnAmount[car],2))
+        #check if steering right
+        if carsetup.turnAmount[car] <= -turnSpeed2:
+            #print("less than, subtract")
+            #add to turn value
+            carsetup.turnAmount[car] += turnSpeed2
+        #check if steering left
+        elif carsetup.turnAmount[car] > turnSpeed2:
+            #print("greater than add")
+            #subtract from turn value
+            carsetup.turnAmount[car] -= turnSpeed2
+        else:
+            carsetup.turnAmount[car] = 0
+            
+        #apply steering
+        vehicleID.setSteeringValue(carsetup.turnAmount[car],0)
+        vehicleID.setSteeringValue(carsetup.turnAmount[car],1)
+
+def exit():
+    print('exit car')
+    scene = bge.logic.getCurrentScene()
+    dict = bge.logic.globalDict
+    cube = scene.objects['control_cube.002']
+    camera = scene.objects["Camera.003"]
+    own['driving'] = False
+    cube['driving'] = False
+    dict['driving_reset'] = True
+    cube.removeParent()
+    cube.applyMovement([0,-1,0], True)
+    cube.removeParent()
+    #cube.suspendDynamics(True)
+    cube.restoreDynamics()
+    #camobj = scene.objects['camobj']
+    #own.actuators['Camera'].object = camobj
+    scene.suspend()
+    
+    
+    
+def check_exit(yBut):
+    if yBut == True and dict['last_yBut'] == False:
+        exit()
+    else:
+        dict['last_driving'] = True    
+    
+def main(controller):
+
+    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']
+
+    #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
+
+    #print(rTrig)
+    own['ForwardSpeed'] = rTrig * 6500
+    #if own['ForwardSpeed'] < 500:
+        #own['ForwardSpeed'] = 500:
+    if rTrig > .01:
+        own['gas'] = 1
+    else:
+        own['gas'] = 0 
+    if lTrig > .01:
+        own['brake'] = 1
+    else:
+        own['brake'] = 0 
+    if lLR > .04:
+        own['right'] = 1
+    else:
+        own['right'] = 0
+    if lLR < -.04:
+        own['left'] = 1
+    else:
+        own['left'] = 0
+    if aBut == 1:
+        own['reverse'] = 1
+    else:
+        own['reverse'] = 0         
+                                   
+    
+    #get the car object
+    car = controller.owner
+    
+    #check if car was initialized
+    if not carsetup.carInitialized(car):
+        
+        #initialize the car
+        _initialize(controller)
+        
+        #exit
+        return
+    
+    #build the car constraint
+    vehicleID = _constraintID(car)
+    
+    #set tire grip
+    carsetup.tireGrip(car, vehicleID)
+    
+    #set suspension compression
+    carsetup.suspensionCompression(car, vehicleID)
+    
+    #set suspension damping
+    carsetup.suspensionDamping(car, vehicleID)
+    
+    #set suspension stiffness
+    carsetup.suspensionStiffness(car, vehicleID)
+    
+    #set suspension roll influence
+    carsetup.suspensionRollInfluence(car, vehicleID)
+    
+    #run powertrain
+    _powertrain(controller, car)
+    
+    #run powertrain
+    _steer(controller, car)
+    
+    check_exit(yBut)

scripts/colors.py

+import bge
+from bge import texture
+
+dict = bge.logic.globalDict 
+scene = bge.logic.getCurrentScene()
+shirt = scene.objects["Char4:Zshirtt1"]
+deck = scene.objects["deck"]
+throw_deck = scene.objectsInactive["throw_deck"]
+throw_deck_trucks = scene.objectsInactive["throw_deck_trucks"]
+focus_deckA = scene.objectsInactive["focus_deckA"]
+focus_deckB = scene.objectsInactive["focus_deckB"]
+focus_deckA_trucks = scene.objectsInactive["focus_deckA_trucks"]
+focus_deckB_trucks = scene.objectsInactive["focus_deckB_trucks"]
+shoeR = scene.objects['Char4:Shoes02.R']
+shoeL = scene.objects['Char4:Shoes02.L']
+trucks = scene.objects['trucks']
+wheel1 = scene.objects['rollen.000']
+wheel2 = scene.objects['rollen.001']
+wheel3 = scene.objects['rollen.002']
+wheel4 = scene.objects['rollen.003']
+throw_deck_wheel1 = scene.objectsInactive["throw_deck_trucks_wheels"]
+throw_deck_wheel2 = scene.objectsInactive["throw_deck_trucks_wheels.001"]
+throw_deck_wheel3 = scene.objectsInactive["throw_deck_trucks_wheels.002"]
+throw_deck_wheel4 = scene.objectsInactive["throw_deck_trucks_wheels.003"]
+focus_deckA_wheel1 = scene.objectsInactive['focus_deckA_wheel1']
+focus_deckA_wheel2 = scene.objectsInactive['focus_deckA_wheel2']
+focus_deckB_wheel1 = scene.objectsInactive['focus_deckB_wheel1']
+focus_deckB_wheel2 = scene.objectsInactive['focus_deckB_wheel2']
+
+
+##
+white = [ .9, .9, .9, 1.0]
+yellow = [ 0.6, 0.33, 0, 1.0]
+grey = [ .5, .5, .5, 1.0]
+red = [ .2, 0, 0, 1]
+orange = [.47, .1, 0, 1]
+deckbrown = [.2, .075, .001, 1]
+lightblue = [.375, .6, 1, 1]
+## set colors
+shirtC = white
+deckC = red
+shoesC = grey
+def main():
+
+    cont = bge.logic.getCurrentController()
+    own = cont.owner
+
+    #shirt.color = shirtC
+    #print(dict['shirt_color'])
+    scol = [dict['shirt_color_r'], dict['shirt_color_g'], dict['shirt_color_b'], 1]
+    deckC = [dict['deck_color_r'], dict['deck_color_g'], dict['deck_color_b'], 1]
+    print(scol)
+    shirt.color = scol
+    deck.color = deckC
+    throw_deck.color = deckC
+    focus_deckA.color = deckC
+    focus_deckB.color = deckC
+    shoesC = [dict['shoe_color_r'], dict['shoe_color_g'], dict['shoe_color_b'], 1]
+    shoeR.color = shoesC
+    shoeL.color = shoesC
+    
+    trucks.color = [dict['trucks_r'], dict['trucks_g'], dict['trucks_b'], 1]
+    throw_deck_trucks.color = [dict['trucks_r'], dict['trucks_g'], dict['trucks_b'], 1]
+    focus_deckA_trucks.color = [dict['trucks_r'], dict['trucks_g'], dict['trucks_b'], 1]
+    focus_deckB_trucks.color = [dict['trucks_r'], dict['trucks_g'], dict['trucks_b'], 1]
+    wheel1.color = [dict['wheel1_r'], dict['wheel1_g'], dict['wheel1_b'], 1]
+    wheel2.color = [dict['wheel2_r'], dict['wheel2_g'], dict['wheel2_b'], 1]
+    wheel3.color = [dict['wheel3_r'], dict['wheel3_g'], dict['wheel3_b'], 1]
+    wheel4.color = [dict['wheel4_r'], dict['wheel4_g'], dict['wheel4_b'], 1]
+    throw_deck_wheel1.color = [dict['wheel1_r'], dict['wheel1_g'], dict['wheel1_b'], 1]
+    throw_deck_wheel2.color = [dict['wheel2_r'], dict['wheel2_g'], dict['wheel2_b'], 1]
+    throw_deck_wheel3.color = [dict['wheel3_r'], dict['wheel3_g'], dict['wheel3_b'], 1]
+    throw_deck_wheel4.color = [dict['wheel4_r'], dict['wheel4_g'], dict['wheel4_b'], 1]
+    focus_deckA_wheel1.color = [dict['wheel1_r'], dict['wheel1_g'], dict['wheel1_b'], 1]
+    focus_deckA_wheel2.color = [dict['wheel2_r'], dict['wheel2_g'], dict['wheel2_b'], 1]
+    focus_deckB_wheel1.color = [dict['wheel3_r'], dict['wheel3_g'], dict['wheel3_b'], 1]
+    focus_deckB_wheel2.color = [dict['wheel4_r'], dict['wheel4_g'], dict['wheel4_b'], 1]    
+    
+    #print("set color", deck.color)
+
+
+    logo = dict['shirt_logo']
+    logo1 = shirt.meshes[0].materials[0].textures[6]
+    logo2 = shirt.meshes[0].materials[0].textures[7] 
+    logo3 = shirt.meshes[0].materials[0].textures[5]   
+    try:
+        if logo == 1:
+            logo1.diffuseIntensity = 1
+            logo2.diffuseIntensity = 0
+            logo1.diffuseFactor = 1
+            logo2.diffuseFactor = 0
+            logo3.diffuseIntensity = 0
+            logo3.diffuseFactor = 0
+        if logo == 2:
+            logo1.diffuseIntensity = 0
+            logo1.diffuseFactor = 0
+            logo2.diffuseIntensity = 1 
+            logo2.diffuseFactor = 1   
+            logo3.diffuseIntensity = 0
+            logo3.diffuseFactor = 0        
+        if logo == 3:
+            logo1.diffuseIntensity = 0
+            logo1.diffuseFactor = 0
+            logo2.diffuseIntensity = 0 
+            logo2.diffuseFactor = 0                   
+            logo3.diffuseIntensity = 1
+            logo3.diffuseFactor = 1        
+        if logo == 0:
+            logo1.diffuseIntensity = 0
+            logo2.diffuseIntensity = 0            
+            logo1.diffuseFactor = 0
+            logo2.diffuseFactor = 0
+            logo3.diffuseIntensity = 0
+            logo3.diffuseFactor = 0        
+    except:
+        pass    
+
+main()
+
+
+def update_truck_tex():
+    #deck graphic testing
+    #pass
+    import glob
+    scene = bge.logic.getCurrentScene()
+    deck = scene.objects["deck"]
+    mainDir = bge.logic.expandPath("//")
+    fileName = mainDir + "textures\\decks\\*.png"    
+    deckList = glob.glob(fileName)
+    dict['deckList'] = deckList  
+    ID = texture.materialID(deck, 'MAdeck')
+    deck_texture = texture.Texture(deck, ID)
+    new_source = texture.ImageFFmpeg(deckList[dict["deck_index"]])
+    bge.logic.texture = deck_texture
+    bge.logic.texture.source = new_source
+    bge.logic.texture.refresh(False)
+    deck_name = deckList[dict['deck_index']]
+    deck_name = deck_name.replace(mainDir, '')
+    deck_name = deck_name.replace('textures\decks', '' )
+    deck_name = deck_name.replace('.png', '')   
+    deck_name = deck_name.replace("\\", "")  
+    print('deck texture updted to ', deck_name)
+    dict['deck_name'] = deck_name
+    
+def update_shirt_tex():
+    #pass
+    #deck graphic testing
+    import glob
+    scene = bge.logic.getCurrentScene()
+    #deck = scene.objects["deck"]
+    shirt = scene.objects["Char4:Zshirtt1"]
+    mainDir = bge.logic.expandPath("//")
+    fileName2 = mainDir + "textures\\shirt\\*.png"    
+    shirtList = glob.glob(fileName2)
+    dict['shirtList'] = shirtList  
+    ID = texture.materialID(shirt, 'MAshirt')
+    shirt_texture = texture.Texture(shirt, ID)
+    new_source2 = texture.ImageFFmpeg(shirtList[dict["shirt_logo"]])
+    bge.logic.texture2 = shirt_texture
+    bge.logic.texture2.source = new_source2
+    bge.logic.texture2.refresh(False)
+    shirt_name = shirtList[dict['shirt_logo']]
+    shirt_name = shirt_name.replace(mainDir, '')
+    shirt_name = shirt_name.replace('textures\shirt', '' )
+    shirt_name = shirt_name.replace('.png', '')   
+    shirt_name = shirt_name.replace("\\", "")  
+    print('shirt texture updted to ', shirt_name)
+    dict['shirt_name'] = shirt_name    
+
+

scripts/config_sample.ini

+#shuvit settings configuration file
+
+#debug
+######
+
+#show framerate
+framerate = 0
+#show profile
+profile = 0
+#----------
+
+#resolution
+###########
+
+resx = 1920
+resy = 1080
+fullscreen_on = 1
+music_player = 0
+#----------
+
+#level
+######
+level = warehouse
+#------------
+
+#replay recorder
+###############
+
+recorder_on = 1
+#--------------
+
+#camera 
+#######
+cam_height = -0.4
+focal_length = 10
+cam_min = 1.4
+cam_max = 2.0
+cch_targetHeight = 0.5
+
+
+#character settings
+###################
+
+character = becky
+
+shirt_logo = 1
+
+shirt_color_r = 0.35
+shirt_color_g = 0
+shirt_color_b = 0
+
+shoe_color_r = 0.23
+shoe_color_g = 0
+shoe_color_b = 0
+#-----------------
+
+#deck settings
+##############
+deck_index = 2
+deck_color_r = 1
+deck_color_g = 1.0
+deck_color_b = 1
+trucks_r = 0
+trucks_g = 0.53
+trucks_b = 0
+
+wheel1_r = 0.08
+wheel1_g = 0.08
+wheel1_b = 0.08
+wheel2_r = 0.08
+wheel2_g = 0.08
+wheel2_b = 0.08
+wheel3_r = 0.08
+wheel3_g = 0.08
+wheel3_b = 0.08
+wheel4_r = 0.08
+wheel4_g = 0.08
+wheel4_b = 0.08
+#-------------------
+
+#2d filter settings
+###################
+
+#brightness / contrast
+bc = 1
+BC_BRIGHTNESS = 1.3
+BC_CONTRAST = 1.0
+
+#HDR
+hdr = 1
+avgL = 0.7
+HDRamount = 0.65
+
+#Ambient Occlusion
+ao = 1
+onlyAO = 0
+aowidth = 1.0
+aoradius = 16
+
+#Depth of Field
+dof_on = 1
+
+#Bloom
+bloom_on = 1
+
+#FXAA
+fxaa = 1
+FXAA_SPAN_MAX = 8.0
+#-------------------
+
+#sun settings
+#############
+sun_strength = 0.9
+ambient_strength = 0.2
+sun_rot_x = -0.05
+sun_rot_y = -0.05
+shadow_on = 0
+#------------
+
+#physics
+########
+JUMPHEIGHT = 800
+MAX_VEL = 6.7
+SPEEDUP = 0.055
+SPEEDPUMP = 0.14#.09
+SPEEDPUMPFAST = 0.16#.13
+PUMP_SPEED_SENS = 0.4
+PUMP_SENS = 0.98
+ACCEL = 10
+CRUISE = 9
+COUNTDOWN = 20#pump and speed stuff
+pump_downforce = -0.1
+
+man_sens_l = 0.03
+man_sens_r = 0.08
+man_sens_side = 0.035
+turn_rotation = 0.02
+turn_addx = 0.004
+turn_air_rotation = 0.07
+grass_mult = 0.98
+ylimit = 0.84
+antibounce = -10.0
+gravity = -11

scripts/contributing.md

+We'd love for you to be able to contribute to this project; if you're interested, you'll need the following:
+
+Latest stable version of UPBGE.
+The lastest release of Shuvit (v0.1.2b)
+The latest .blend file (shuvit_v0.1.2b.blend as of time of writing this)
+
+Now that you've got those, follow these steps:
+
+1. Put the .blend fild in the folder with the Shuvit executable
+2. Open UPBGE
+3. In UPBGE go to File > User Preferences. Select the "File" tab. Make sure "Auto Run Python Scripts" is checked. Save preferences.
+4. Choose File -> open
+5. Navigate to the folder where you put the .blend file and select it
+6. Click "open blender file" in UPBGE
+7. Wait for it to import
+8. ????
+9. Profit

scripts/curves.osl

+
+
+uniform sampler2D bgl_RenderedTexture;
+
+uniform float BC_BRIGHTNESS = 2;
+uniform float BC_CONTRAST = 1;
+
+//const float BC_CONTRAST = 1.3;    //1 is no contrast.
+//const float BC_BRIGHTNESS = 1.15;    //1 is no brightness 1.15 is good
+
+void main()
+{
+    vec4 color = texture2D(bgl_RenderedTexture, gl_TexCoord[0].st);
+    
+    color = ((color-1)*max(BC_CONTRAST,0));
+    color = color+BC_BRIGHTNESS;
+     
+    gl_FragColor = color; 
+}

scripts/grindV2.py

+import bge
+import math
+
+def main():
+    cont = bge.logic.getCurrentController()
+    own = cont.owner
+    player = cont.owner
+    scene = bge.logic.getCurrentScene()
+    #grindDar = cont.sensors['grindDar']
+    grindEmpty = scene.objects['grindEmpty']
+    grindDar = grindEmpty.sensors['grindDar2']    
+    rGround = cont.sensors['r_Ground']
+    control_bottom = scene.objects['control_bottom']
+    #grindCol_bottom 
+    grindTouch = control_bottom.sensors['grindCol_bottom']
+    #grindTouch = cont.sensors['grindCol']
+    invertCol = cont.sensors['invertCol']
+    invertObjs = invertCol.hitObjectList
+    invert_on = own['invert_on']
+    detectedObjects = grindDar.hitObjectList
+    lastObject = own['grindTrackObj']
+    nearestObject = None
+    minDist = None
+    #act = cont.actuators["Target"]
+    test = own["test"]
+    grindold = own["grindOld"]
+    lgobj = own["lGobj"]
+    countdown = own['grindCountdown'] 
+    #print(lgobj)
+    ray = cont.sensors["GuardDuty"] # get the ray sensor attached to the controller named GuardDuty
+    gt_cd = own["gt_cd"]
+    pos = ray.hitPosition # get position where the game object hit by ray
+    linVelocity = own.getLinearVelocity(False)
+    linVelocity2 = own.getLinearVelocity(True)
+    pos[2] = pos[2] + 1 
+    norm = ray.hitNormal
+    STANCE = own["stance"]
+    orientation = own.worldOrientation
+    test = ray.hitObject
+    xyz = own.worldOrientation.to_euler()
+    rotz = math.degrees(xyz[2])
+    roty = math.degrees(xyz[1]) 
+    #print(roty)
+    roty = abs(roty) 
+    sub = 0
+    align_strength = .1#.3
+    align_strength2 = .2
+    touched = grindTouch.triggered
+    lgf = own['last_grind_frame']
+    gsf = own['grind_start_frame']
+    framenum = own['framenum']
+    last_ground_frame = own['lF_ground_frame']
+    frames_since_ground = framenum - last_ground_frame
+    frames_since_grind = framenum - lgf
+    frames_grinding = framenum - gsf
+    #if framenum - lgf > 60:
+    minus = framenum - gsf
+    grindspeed_rail = .996 #multiplied by current speed
+    grindspeed_cement = .995 #multiplied by current speed
+    grindDar_timer = own["grindDar_timer"]
+    last_grindDar = 0
+    last_manual = own["manual"]
+    joinit = 0
+    rot = own.getAxisVect( [0.0, 0.0, 1.0])
+    dropin = own['dropinTimer']
+    nearestObject = None
+    last_hit = own['grindDar_hit']
+    jump_timer = own['jump_timer']
+    grind_jump = own['grind_jump']
+    lastGround = own['lF_ground2']
+    OG_PLAYER_POS = own.worldPosition
+    grindvect = None
+    grindyvect = None
+    skipcol = 0
+    skipconst = 0
+    try:
+        no_grind_pull = own['no_grind_pull']
+    except:    
+        own['no_grind_pull'] = 0
+        no_grind_pull = 0
+        
+    since_jumped = framenum - own['last_jump_frame']    
+    #no grind
+    no_grind = 1
+    if jump_timer > 50:
+        own['no_grind_timer'] = 0
+    if own['no_grind_timer'] > 0:
+        no_grind = 0
+        own['no_grind_timer'] -= 1
+        
+    if grindold == 1:
+        no_grind = 0    
+    #don't grind unless you were in the air recently or were on a ramp recently or were grinding.
+    
+    #if (own['onramp'] == 0 and frames_since_grind > 30):
+        #no_grind = 1
+        
+    #if frames_since_grind > 30:
+        #no_grind = 0
+        
+    if frames_since_ground > 30 or since_jumped < 120:
+        no_grind = 0         
+    if jump_timer > 50:
+        no_grind = 1
+        
+   
+    #print('no grind timer', no_grind, own['no_grind_timer'])
+    
+    
+    if (own['fak_nmanual'] == 1 or own['reg_nmanual'] == 1 or own['fak_manual'] == 1 or own['reg_manual'] == 1):
+        manual = 1    
+    else:
+        manual = 0
+    #manual = own['manual']
+    own["nogrindsound"] = 0
+    
+#---------###########___###########-----------    
+#start new                     #######     
+##----------##############----------############
+
+#grindvect func
+    grindvect = None
+    grindyvect = None
+    lastobj = own["grindTouchobj"]
+    grindpos = own["grindpos"]
+    player_e = own.worldOrientation.to_euler()
+    player_rotz = math.degrees(player_e[2]) 
+    velxb = linVelocity2.x
+    player_e = own.worldOrientation.to_euler()
+    
+    ogrot = own.orientation
+    ogrot = player_e
+    
+    if (framenum - gsf) > 15:
+        velx = linVelocity2.x
+        vely = linVelocity2.y
+        #print("limit speed")
+    else:    
+         velx = linVelocity2.x
+         vely = linVelocity2.y     
+    if abs(own['pregrind_vely']) > abs(vely) and own['LAST_GRIND'] == 0:
+        #convely = own['pregrind_vely']
+        #print('changing convely')
+        convely = vely
+    else:
+        convely = vely  
+    def grindvect(obj):
+        STANCE = own['stance']
+        if obj != None:
+            grinder_e = obj.worldOrientation.to_euler()
+            grinder_rotz = math.degrees(grinder_e[2])            
+            rot = player_rotz - grinder_rotz
+        if rot >= 0 and rot < 45: 
+            grindvect = "pos"
+        if rot >= 45 and rot < 90: 
+            grindvect = "pos" 
+            grindyvect = "pos"
+        if rot >= 90 and rot < 135: 
+            grindvect = "neg"
+            grindyvect = "neg"
+        if rot >= 135 and rot < 180: 
+            grindvect = "neg"
+        if rot >= 180 and rot < 225: 
+            grindvect = "neg"
+        if rot >= 225 and rot < 270: 
+            grindvect = "neg"
+            grindyvect = "pos"
+        if rot >= 270 and rot < 315: 
+            grindvect = "pos" 
+            grindyvect = "neg"
+        if rot >= 315: 
+            grindvect = "pos"
+        if rot < 0 and rot >= -45: 
+            grindvect = "pos"
+        if rot < -45 and rot >= -90: 
+            grindvect = "pos"
+            grindyvect = "neg"
+        if rot < -90 and rot >= -135: 
+            grindvect = "neg"
+            grindyvect = "pos"
+        if rot < -135 and rot >= -180: 
+            grindvect = "neg"  
+        if rot < -180 and rot >= -225: 
+            grindvect = "neg" 
+        if rot < -225 and rot >= -270: 
+            grindvect = "neg"
+            grindyvect = "neg"
+        if rot < -270 and rot >= -315: 
+            grindvect = "pos" 
+            grindyvect = "pos"
+        if rot < -315: 
+            grindvect = "pos"   
+
+        rot = round((rot * .01), 1)
+        rot *= 100
+
+        #print(own['inverting'])
+        if frames_grinding > 20 and own['inverting'] == False: 
+            #print("setting stance")       
+            if (rot == 90 or rot == -270) and STANCE == True:
+                #print("90 fak stance")
+                own['stance'] = 1
+                STANCE = 1
+            if (rot == 90 or rot == -270) and STANCE == False:
+                #print("90 fak stance")
+                own['stance'] = 1
+                STANCE = 1
+            if (rot == -90 or rot == 270) and STANCE == True:
+                #print("-90 reg stance")
+                own['stance'] = 0
+                STANCE = 0
+            if (rot == -90 or rot == 270) and STANCE == False:
+                #print("-90 reg stance")                        
+                own['stance'] = 0
+                STANCE = 0
+    def grindrotvel(obj):        
+        skipconst = 1              
+        joinit = 0
+        grinder_e = obj.worldOrientation.to_euler()
+        grinder_rotz = math.degrees(grinder_e[2]) 
+        grinder_vect = obj.getAxisVect( [1, 0, 0]) 
+        grinder_vectz = obj.getAxisVect( [0, 0, 1]) 
+        rot = player_rotz - grinder_rotz        
+        rayhit = ray.hitObject
+        own['grind_rot'] = rot
+        vect = obj.getAxisVect( [1.0, 0.0, 0.0])
+        xyzb = obj.worldOrientation.to_euler()
+        rotzb = math.degrees(xyzb[2])   
+        grindpos = "None"         
+        align = "None"
+        sub_converted = 0
+        rotz = math.degrees(xyz[2])
+        roty = math.degrees(xyz[1])
+        bsrot = [ 0.0, 0.0, 1.570796327]    
+        negbsrot = [ 0.0, 0.0, -1.570796327]
+        zvel = own.linearVelocity
+        zvel = zvel.z * .95
+        if grindold == 0:
+            if rotz < 0:
+                rotz = rotz + 360
+            if rotzb < 0:
+                rotzb = rotzb + 360    
+            if rotz > rotzb:
+                sub_converted = rotz - rotzb
+            if rotz < rotzb:
+                sub_converted = rotzb - rotz
+
+        #z align
+        #print("zalign") 
+        stre = .15#.075#.15
+        player.alignAxisToVect(grinder_vectz, 2, stre)                                                  
+        
+        if rot >= 0 and rot < 45:
+            player.alignAxisToVect(grinder_vect, 0, align_strength)
+            grindvect = "pos"
+            #player.applyForce([0, 0, 0], True)            
+            player.setLinearVelocity([velxb, 0.0, zvel], 1)  
+            grindpos = "reg_5050"
+            #print("50-1")
+
+
+        elif rot >= 45 and rot < 90:  
+            player.alignAxisToVect([-grinder_vect.y, grinder_vect.x, 0], 0, align_strength)
+            grindvect = "pos"
+            align = "pos"            
+            player.setLinearVelocity([0, convely, zvel], 1)   
+            grindpos = "reg_board"     
+            grindyvect = "pos"
+            #print("bs1, don't switch")       
+                           
+        elif rot >= 90 and rot < 135:  
+            grinder_vect = grinder_vect * -1                
+            player.alignAxisToVect([grinder_vect.y, -grinder_vect.x, 0], 0, align_strength) 
+            grindvect = "neg"
+            align = "neg"
+            grindyvect = "neg"
+            player.setLinearVelocity([0, convely, zvel], 1)
+            grindpos = "reg_board"  
+            #print("-bs2, don't switch?")          
+                     
+        elif rot >= 135 and rot < 180:
+            player.alignAxisToVect(-grinder_vect, 0, align_strength)
+            grindvect = "neg"
+            player.setLinearVelocity([velxb, 0.0, zvel], 1) 
+            grindpos = "reg_5050"
+            #print("50-2")
+           
+        elif rot >= 180 and rot < 225:
+            player.alignAxisToVect(-grinder_vect, 0, align_strength)
+            grindvect = "neg"
+            player.setLinearVelocity([velxb, 0.0, zvel], 1)
+            grindpos = "reg_5050" 
+            #print("50-3")
+            
+        elif rot >= 225 and rot < 270:
+            player.alignAxisToVect([grinder_vect.y, -grinder_vect.x, 0], 0, align_strength)
+            grindvect = "neg"
+            align = "pos"
+            player.setLinearVelocity([0, convely, zvel], 1)
+            grindpos = "reg_board"
+            grindyvect = "pos"
+            #print("bs3")             
+           
+        elif rot >= 270 and rot < 315:
+            player.alignAxisToVect([grinder_vect.y, -grinder_vect.x, 0], 0, align_strength) 
+            grindvect = "pos" 
+            align = "neg"
+            player.setLinearVelocity([0, convely, zvel], 1)
+            grindpos = "reg_board"   
+            grindyvect = "neg"
+            #print("-bs4")          
+            
+        elif rot >= 315:
+            player.alignAxisToVect(grinder_vect, 0, align_strength)
+            grindvect = "pos"
+            player.setLinearVelocity([velxb, 0.0, zvel], 1)
+            grindpos = "reg_5050"
+            #print("50-4")
+                         
+#-------------------------------------------------------------            
+        elif rot < 0 and rot >= -45:
+            player.alignAxisToVect(grinder_vect, 0, align_strength)
+            grindvect = "pos"
+            player.setLinearVelocity([velxb, 0.0, zvel], 1)  
+            grindpos = "reg_5050" 
+            #print("50-5")                    
+        elif rot < -45 and rot >= -90:
+            grinder_vect = grinder_vect * -1
+            player.alignAxisToVect([-grinder_vect.y, grinder_vect.x, 0], 0, align_strength)
+            grindvect = "pos"
+            align = "neg"
+            player.setLinearVelocity([0, convely, zvel], 1)
+            grindpos = "reg_board"   
+            #print("-bs5")           
+            grindyvect = "neg"
+        elif rot < -90 and rot >= -135:
+            player.alignAxisToVect([grinder_vect.y, -grinder_vect.x, 0], 0, align_strength)
+            grindvect = "neg"
+            align = "pos"
+            player.setLinearVelocity([0, convely, zvel], 1)
+            grindpos = "reg_board"  
+            grindyvect = "pos"
+            #print("bs6")                   
+        elif rot < -135 and rot >= -180:
+            player.alignAxisToVect(-grinder_vect, 0, align_strength)
+            grindvect = "neg"   
+            player.setLinearVelocity([velxb, 0.0, zvel], 1)  
+            grindpos = "reg_5050" 
+            #print("50-6")       
+        elif rot < -180 and rot >= -225:
+            player.alignAxisToVect(-grinder_vect, 0, align_strength) 
+            grindvect = "neg"           
+            player.setLinearVelocity([velxb, 0.0, zvel], 1)  
+            grindpos = "reg_5050" 
+            #print("50-7")
+        elif rot < -225 and rot >= -270:
+            grinder_vect = grinder_vect * -1
+            player.alignAxisToVect([grinder_vect.y, -grinder_vect.x, 0], 0, align_strength) 
+            grindvect = "neg"
+            align = "neg"
+            player.setLinearVelocity([0, convely, zvel], 1)
+            grindpos = "reg_board"   
+            grindyvect = "neg"
+            #print("-bs7")              
+        elif rot < -270 and rot >= -315:
+            player.alignAxisToVect([-grinder_vect.y, grinder_vect.x, 0], 0, align_strength) 
+            grindvect = "pos"
+            align = "pos"
+            player.setLinearVelocity([0, convely, zvel], 1)
+            grindpos = "reg_board"    
+            grindyvect = "pos"
+            #print("bs8")                                   
+        elif rot < -315:
+            player.alignAxisToVect(grinder_vect, 0, align_strength) 
+            grindvect = "pos"                     
+            player.setLinearVelocity([velxb, 0.0, zvel], 1)  
+            grindpos = "reg_5050"  
+            #print("50-8")
+
+        own['grindpos'] = grindpos
+        own['grindvect'] = grindvect
+        own['grindervect'] = grinder_vect
+        try:   
+            own['grindyvect'] = grindyvect
+            
+        except:
+            pass 
+                
+#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@        
+    def grind(obj):
+        try:
+            grindyvect = own['grindyvect']
+        except:
+            grindyvect = 0 
+        grindvect = own['grindvect'] 
+        
+        if 'rail' in obj:
+            own["grindSound"] = "rail" 
+        else:
+            own["grindSound"] = "concrete"
+        own['lGobj'] = obj         
+        
+        grinding = 1                
+        
+        framenum = own['framenum']
+        lastairframe = own['lF_air_frame']
+        jumpside = 0
+        if (framenum - lastairframe) < 10:
+            player_pos = own['jumpPos'] 
+            jumpside = 1   
+        else:    
+            player_pos = OG_PLAYER_POS
+        player_pos = own.worldPosition    
+        try:    
+            if 1 == 1:       
+                grinder_pos = obj.worldPosition 
+                worldVect = [1, 0, 0]
+                vect = obj.getAxisVect(worldVect)      
+                go = obj.worldOrientation
+                grinder_axis = [0,1,0]
+                try: 
+                    delta = player_pos - grinder_pos
+                except:
+                    #print("delta broke: ", player_pos, grinder_pos)
+                    pass 
+                delta = delta.cross(vect)
+                if delta[2] >= 0:
+                    grindside = "right"
+
+                else:
+                    grindside = "left"
+                edge = 0
+                if 'edge' in obj:
+                    edge = 1    
+                #print('grind on', grindside, edge)
+                if (delta[2] > .00001 or delta[2] < -.00001) and (delta[2] < .8 or delta[2] < -.8):
+                    rotation = own.worldOrientation[2] - obj.worldOrientation[2]
+                    player_e = own.worldOrientation.to_euler()
+                    player_rotz = math.degrees(player_e[2])
+                    grinder_e = obj.worldOrientation.to_euler()
+                    grinder_rotz = math.degrees(grinder_e[2])
+                    deltamove = delta[2] * .3
+                    #print(round(deltamove, 4), "deltamove")
+                    #5050
+                    if own["grindpos"] == "reg_5050":
+                        #print("missing delta")
+                        if (jumpside == 1 or jumpside == 0) and grindvect == "pos":
+                            move = [0, deltamove, 0]
+                            #print("1deltamove", deltamove)
+                            own.applyMovement(move, True)    
+                        if (jumpside == 1 or jumpside == 0) and grindvect == "neg":
+                            move = [0, -deltamove, 0]
+                            #print("2deltamove -", deltamove)
+                            own.applyMovement(move, True)  
+                    #board
+                    if own["grindpos"] == "reg_board":
+                        if grindvect == "neg":
+                            if (jumpside == 1 or jumpside == 0) and grindyvect == "pos":
+                                move = [-deltamove, 0, 0]
+                                #print("3deltamove", deltamove)
+                                own.applyMovement(move, True)        
+                            if (jumpside == 1 or jumpside == 0) and grindyvect == "neg":
+                                move = [deltamove, 0, 0]
+                                #print("4deltamove -", deltamove)
+                                own.applyMovement(move, True)            
+                        if grindvect == "pos":
+                            if (jumpside == 1 or jumpside == 0) and grindyvect == "pos":
+                                move = [deltamove, 0, 0]
+                                #print("5deltamove", deltamove)
+                                own.applyMovement(move, True)        
+                            if (jumpside == 1 or jumpside == 0) and grindyvect == "neg":
+                                move = [-deltamove, 0, 0]
+                                own.applyMovement(move, True)                    
+                own['grindside'] = grindside    
+        except:
+            pass
+        #speed limit    
+        velo = own.getLinearVelocity(True)
+        touchobj = obj
+        if touchobj != None and gt_cd == 0:       
+            if 'rail' in touchobj:
+                newvelx = velo.x * grindspeed_rail   
+                newvely = velo.y * grindspeed_rail
+            else:
+                newvelx = velo.x * grindspeed_cement  
+                newvely = velo.y * grindspeed_cement            
+            player.setLinearVelocity([newvelx, newvely, velo.z], 1)   
+            player_rot = own.worldOrientation[2]
+            grinder_rot = touchobj.worldOrientation[2]
+            player_rot = own.getAxisVect( [0.0, 0.0, 1.0])
+            xyz3 = own.worldOrientation.to_euler()
+            player_rot = math.degrees(xyz3[2])
+            xyz4 = touchobj.worldOrientation.to_euler()
+            grinder_rot = math.degrees(xyz4[2]) 
+            if player_rot < 0:
+                player_rot = abs(player_rot) + 180
+            if grinder_rot < 0:
+                grinder_rot = abs(grinder_rot) + 180                   
+            subtraction = player_rot - grinder_rot
+        
+    def invertpos(detectedObjects):
+        minDist = None
+        nearestObject = None
+        for obj in detectedObjects:
+            dist = own.getDistanceTo(obj)
+            if (minDist is None or dist < minDist):
+                nearestObject = obj
+                minDist = dist
+        if nearestObject != None:                            
+            own.linearVelocity.x = 0
+            own.linearVelocity.y = 0            
+    
+    if grindDar.positive == False and grindTouch.triggered and grindold == 0 and dropin == 0 and grind_jump == 0 and own["grindoutturn"] == 0 and gt_cd == 0 and manual == 0 and no_grind == 0 and nearestObject != lastObject and own['grindjumpturn'] == 0 and own['gt_cd2'] == 0 and own['air_mover'] == False:
+        #print("touching, no dar")
+        pass
+    #print(grindold, "grindold")        
+    if (grindDar.positive or grindTouch.positive) and no_grind == 0:        
+        if grindDar.positive:
+            detectedObjects = grindDar.hitObjectList
+            dist = 0
+            for obj in detectedObjects:
+                dist = own.getDistanceTo(obj)
+                if (minDist is None or dist < minDist):
+                    nearestObject = obj
+                    minDist = dist     
+        elif grindTouch.positive:
+            nearestObject = grindTouch.hitObject
+            dist = .7
+            #print('using touch object')                    
+        
+#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@        
+        #init grind
+        
+        if invert_on:
+            invertpos(detectedObjects)
+            own['inverting'] = True
+        else:
+            own['inverting'] = False
+        grind_dist = .8#.6
+        #print(lastobj.worldPosition)
+        if dist < grind_dist and dropin == 0 and manual == 0 and no_grind == 0 and own['grindoutturn'] == 0 and own['manual'] == 0 and own['gt_cd2'] < 40 and invert_on == False and own['air_mover'] == False and no_grind_pull == 0 and own['last_invert'] == False and own['grindjumpturn'] == 0 and grind_jump == 0 and own['airup'] == 0:
+            #print('grind')      
+            hitObject, hitPoint, hitNormal = own.rayCast(nearestObject.worldPosition, own.worldPosition, .0, 'grind')
+            if grindold == 0:     
+                if grindTouch.triggered:
+                    nearpos = nearestObject.worldPosition
+                    if hitNormal != None:
+                        stre = .45
+                        own.alignAxisToVect(hitNormal, 2, stre) 
+                        #print("align")                   
+                    own.worldPosition = [nearpos.x, nearpos.y, nearpos.z + .2975]
+                    #print('moving world')
+            #print("grinding")
+            grind_height_dif = (own.worldPosition[2] - nearestObject.worldPosition[2]) - .287
+            worldPos = own.worldPosition
+            if grind_height_dif > -.05:#02:
+                grindvect(nearestObject)          
+                grindrotvel(nearestObject)
+                grind(nearestObject)
+                grindold = True
+                own['grindold_timer'] = 0
+                own["grindHit"] = True
+                own['grindnew_timer'] += 1
+                
+                if own['grindnew_timer'] < 1:
+                    if grindTouch.triggered:
+                        nearpos = nearestObject.worldPosition
+                        if hitNormal != None:
+                            stre = .15
+                            own.alignAxisToVect(hitNormal, 2, stre) 
+                            #print("align")                   
+                        #own.worldPosition = [nearpos.x, nearpos.y, nearpos.z + .2975]
+                        #print('new moving world')                    
+
+    else:
+        #grindold = False 
+        own['grindold_timer'] += 1
+        own["grindHit"] = False
+        own['inverting'] = False   
+    
+    if own['grindold_timer'] > 5:
+        grindold = False
+        own['grind_start_frame'] = framenum
+        own["grindSound"] = None
+    
+    if own['grindHit'] == False:
+        own['grindnew_timer'] = 0  
+ 
+#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@    
+       
+#if you are touching grinder and last_manual is off keep manual off
+    if (own['fak_nmanual'] == 1 or own['reg_nmanual'] == 1 or own['fak_manual'] == 1 or own['reg_manual'] == 1) and lastGround == True and grindold == False:
+        manual = 1
+        if last_manual == 0 and grindTouch.triggered == True:
+            manual = 0
+        own["nogrindsound"] = 1
+    grindhit = own["grindHit"]
+
+    if abs(own['pregrind_vely']) > abs(vely) and own['LAST_GRIND'] == 0:
+        convely = own['pregrind_vely']
+    else:
+        convely = vely    
+
+    off = 0
+
+    if touched == True:
+        own["grindTouchobj"] = grindTouch.hitObject
+    else:
+        own["grindTouchobj"] = None  
+ 
+    if ray.triggered and dropin == 0:
+        lgobj = ray.hitObject
+        own['lGobj'] = lgobj
+        obj = ray.hitObject
+        #prop = obj.get("property", None)
+        linVelocity3 = own.getLinearVelocity(True)
+        grindpos2 = own["grindpos"]
+        regboard = "reg_board"
+        fakboard = "fak_board"
+        if obj is not None:        
+            if 'rail' in ray.hitObject:
+                own["grindSound"] = "rail" 
+            else:
+                own["grindSound"] = "concrete"
+        own['lGobj'] = lgobj    
+    else:
+        lgobj = "empty"
+        own['lGobj'] = lgobj
+    def timer():
+        countdown = own["grindCountdown"]
+        if touched == 1:
+            countdown = 20
+        else:
+            countdown = countdown - 1
+        own['grindCountdown'] = countdown
+    def aligntimer():
+        if own['grindOld'] == 0 and ray.triggered == 1:
+            own['aligntimer'] = 20
+        if own['grindOld'] == 1 and ray.triggered == 1:
+            own['aligntimer'] = own['aligntimer'] - 1
+        if own['grindOld'] == 0 and ray.triggered == 0:
+            own['aligntimer'] = 0   
+
+    def invertpos():
+        minDist = None
+        nearestObject = None
+        for obj in invertObjs:
+            dist = own.getDistanceTo(obj)
+            if (minDist is None or dist < minDist):
+                nearestObject = obj
+                minDist = dist
+        vect = nearestObject.getAxisVect( [1.0, 0.0, 0.0])
+        #own.alignAxisToVect(vect, 0, 0)
+        own.worldPosition = [nearestObject.worldPosition.x, nearestObject.worldPosition.y, nearestObject.worldPosition.z +.1]
+       #own.setLinearVelocity([0, 0.0, 0], 1)                    
+            
+    def set_pregrind_vel():
+        if grindDar.triggered == False and ray.triggered == False:
+            own['pregrind_velx'] = linVelocity2.x
+            own['pregrind_vely'] = linVelocity2.y
+            own['pregrind_velz'] = linVelocity2.z
+            
+    def stop_bounce():
+        if grindTouch.triggered and no_grind == 0 and grind_jump == 0 and jump_timer < 30:
+            linVelocity4 = own.getLinearVelocity(True)
+            if linVelocity4.z > 0:
+                own.setLinearVelocity([linVelocity4.x, linVelocity4.y, 0], 1)
+                        
+    if jump_timer < 30 :
+        own['grind_jump'] = 0 
+    if grindold == False and ray.triggered:
+        own['grind_start_frame'] = own['framenum']  
+        
+    if grindDar_timer > 0:
+        grindDar_timer -= 1
+    if ray.triggered == False and touched == True  and own['footplant_on'] == False and manual == 0 and own['gt_cd2'] < 55 and own['grindoutturn'] == 0 and own['grindjumpturn'] == 0 :        
+        obj = grindTouch.hitObject 
+        try:
+            nearpos = obj.worldPosition
+        except:
+            pass    
+    if ray.triggered == False:
+        own["nogrindsound"] = 1 
+    def slow_roty():
+      #print(abs(roty - own['last_roty']))
+      #print(roty)                
+      
+      #if roted > 5:
+        #pass
+        #align slow  
+        constraint = cont.actuators['gConstraint']
+        if (own['framenum'] - own['grind_start_frame'] < 40) and touched == 1:
+          #print('limit rot')              
+          #constraint.damp = 80
+        #else:
+          #constraint.damp = 30
+        #constraint.rotDamp = 80
+            cont.activate(constraint) 
+        else:
+            cont.deactivate(constraint)      
+    timer()    
+    aligntimer()
+    stop_bounce() 
+    slow_roty()
+      
+                   
+    own['grindOld'] = grindold 
+    own['test'] = test
+    own['grindTrackObj'] = nearestObject
+    own['grindDar_hit'] = grindDar.positive
+    own['lastTouched'] = touched
+    own['grindTouch'] = grindTouch.triggered
+    own["grindDar_timer"] = grindDar_timer
+    own["last_grindDar"] = last_grindDar
+    own['last_roty'] = roty
+    linVelocity3 = own.getLinearVelocity(True)
+    set_pregrind_vel()
+    own['last_z'] = own.worldPosition.z
+    own["manual"] = manual
+
+main()

scripts/inputs.py

+################################################
+#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  
+    
+    joy_con = dict['joy_con']  
+    scenes = bge.logic.getSceneList()
+        
+#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   
+    
+    
+    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_q = events.QKEY      
+    kb_en = events.ENTERKEY   
+    kb_la = events.LEFTARROWKEY
+    kb_ra = events.RIGHTARROWKEY
+    kb_ua = events.UPARROWKEY
+    kb_da = events.DOWNARROWKEY
+    kb_lsh = events.LEFTSHIFTKEY
+    kb_space = events.SPACEKEY
+    #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_q'] = dict['kb_q']  
+    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['last_kb_lsh'] = dict['kb_lsh'] 
+    dict['last_kb_space'] = dict['kb_space']    
+    
+    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_q'] = keyboard[kb_q]    
+    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['kb_lsh'] = keyboard[kb_lsh]
+    dict['kb_space'] = keyboard[kb_space]      
+    
+    
+    if not any(bge.logic.joysticks):
+        #print("joystick not connnected")
+        dict['joy_con'] = 0
+    else:    
+        dict['joy_con'] = 1 
+        
+    if dict['joy_con'] != dict['last_joy_con'] and own['counter'] > 500:
+        if dict['joy_con'] == 0 and dict['last_joy_con'] == 1:
+            if 'joy_warn' not in scenes:
+                #add scene
+                #print('print add joy overlay')
+                cont.activate(cont.actuators['add_controller'])
+        else:
+            if dict['joy_con'] == 1 and dict['last_joy_con'] == 0:
+                #remove scene            
+                #print('print remove joy overlay')            
+                cont.activate(cont.actuators['remove_controller'])
+#get controller axis value 0-100   
+    if dict['joy_con'] == 1: 
+        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
+        #    
+
+      
+        
+        
+        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
+        dict['last_joy_con'] = joy_con
+
+    if dict['driving_reset'] == True:
+        dict['driving_reset'] = False
+        level = dict['level']
+
+        scenelist = bge.logic.getSceneList()
+        if level in scenelist:
+            level = scenelist[level]
+            level.resume()
+            print('resuming', level)
+            cube = level.objects['control_cube.002']
+            #cube.suspendDynamics(False)
+            #print(scenelist)
+            cube.restoreDynamics()
+            print(cube.isSuspendDynamics)
+
+main()
+

scripts/lensflare01.osl

+
+uniform sampler2D bgl_RenderedTexture;
+uniform float bgl_RenderedTextureWidth;
+uniform float bgl_RenderedTextureHeight;
+uniform float sunX;
+uniform float sunY;
+uniform float timer;
+uniform float sundirect;
+uniform float sunScale; 
+
+float noise( float n )
+{
+     return fract(sin(n+timer/2.0));
+}
+
+//float noise2(vec2 co){
+    //return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+//}
+
+vec3 lensflare(vec2 uv,vec2 pos,float sunscale)
+{
+	vec2 main = uv-pos;
+	vec2 uvd = uv*(length(uv));
+	
+	float ang = atan(main.y, main.x);
+	float dist=length(main); dist = pow(dist,.1);
+	float n = noise1(vec2((ang-timer/9.0)*16.0,dist*32.0));
+	
+	float f0 = 1.0/(length(uv-pos)/sunscale+1.0);
+	
+	f0 = f0+f0*(sin((ang+timer/18.0 + noise1(abs(ang)+n/2.0)*2.0)*12.0)*.1+dist*.1+.8);
+
+	float f2 = max(1.0/(1.0+32.0*pow(length(uvd+0.8*pos),2.0)),.0)*00.25;
+	float f22 = max(1.0/(1.0+32.0*pow(length(uvd+0.85*pos),2.0)),.0)*00.23;
+	float f23 = max(1.0/(1.0+32.0*pow(length(uvd+0.9*pos),2.0)),.0)*00.21;
+	
+	vec2 uvx = mix(uv,uvd,-0.5);
+	
+	float f4 = max(0.01-pow(length(uvx+0.4*pos),2.4),.0)*6.0;
+	float f42 = max(0.01-pow(length(uvx+0.45*pos),2.4),.0)*5.0;
+	float f43 = max(0.01-pow(length(uvx+0.5*pos),2.4),.0)*3.0;
+	
+	uvx = mix(uv,uvd,-.4);
+	
+	float f5 = max(0.01-pow(length(uvx+0.2*pos),5.5),.0)*2.0;
+	float f52 = max(0.01-pow(length(uvx+0.4*pos),5.5),.0)*2.0;
+	float f53 = max(0.01-pow(length(uvx+0.6*pos),5.5),.0)*2.0;
+	
+	uvx = mix(uv,uvd,-0.5);
+	
+	float f6 = max(0.01-pow(length(uvx-0.3*pos),1.6),.0)*6.0;
+	float f62 = max(0.01-pow(length(uvx-0.325*pos),1.6),.0)*3.0;
+	float f63 = max(0.01-pow(length(uvx-0.35*pos),1.6),.0)*5.0;
+	
+	vec3 c = vec3(.0);
+	
+	c.r+=f2+f4+f5+f6; c.g+=f22+f42+f52+f62; c.b+=f23+f43+f53+f63;
+	c+=vec3(f0);
+	
+	return c;
+}
+
+void main()
+{
+    vec4 renderedTex = texture2D(bgl_RenderedTexture, gl_TexCoord[0].st);
+    float xconv = bgl_RenderedTextureWidth / bgl_RenderedTextureHeight;
+    vec2 sunPos = vec2((sunX - 0.5) * xconv, sunY - 0.5);
+    vec2 uv = vec2((gl_TexCoord[0].s - 0.5) * xconv, gl_TexCoord[0].t - 0.5);
+    vec3 lens = lensflare(uv, sunPos, sunScale);
+    renderedTex.rgb += lens * sundirect;
+    gl_FragColor = renderedTex;
+}

scripts/load_char.py

+import bge
+
+def ai(cont):  
+#    own = cont.owner
+#    scene = bge.logic.getCurrentScene()
+#    #actu = cont.actuators['start_level']
+#    dict = bge.logic.globalDict
+#    objList = scene.objects
+#    mainDir = bge.logic.expandPath("//")
+#    skater = 'ai_ed'
+#    
+#    fileName = mainDir + "npc_skaters/" + str(skater) + '.blend'    
+#    
+#    path = bge.logic.expandPath(fileName)
+#    bge.logic.LibLoad(path, 'Scene') 
+#    
+
+#    # get object named MainCharacter
+#    armature = objList["npc_ed_arm"]
+
+#    # combine child's shape with parent's
+#    compound = True
+
+#    # child is solid
+#    ghost = False
+
+#    # set parent
+#    armature.setParent( own, compound, ghost) 
+    
+    print('loading ai') 
+
+def main(cont):
+    own = cont.owner
+    scene = bge.logic.getCurrentScene()
+    actu = cont.actuators['start_level']
+    dict = bge.logic.globalDict
+    mainDir = bge.logic.expandPath("//")
+ #   if dict['char_loaded'] == 0:
+    fileName = mainDir + "characters/" + str(dict["character"]) + '.blend'    
+    
+    path = bge.logic.expandPath(fileName)
+    try:
+        bge.logic.LibLoad(path, 'Scene')  
+    except:
+        pass    
+    
+    fileName = mainDir + "assets/" + 'bmx_player' + '.blend'    
+    
+    path = bge.logic.expandPath(fileName)
+    bge.logic.LibLoad(path, 'Scene')     
+    fileName = mainDir + "assets/" + 'prop_bike.blend'    
+    
+    path = bge.logic.expandPath(fileName)
+    bge.logic.LibLoad(path, 'Scene') 
+#        dict['char_loaded'] = 1
+    
+    
+#    fileName = mainDir + "characters/sun.blend"    
+#    
+#    path = bge.logic.expandPath(fileName)
+#    bge.logic.LibLoad(path, 'Scene')      
+
+
+    cont.activate(actu)
+    

scripts/load_npc.py

+
+import bge
+from mathutils import Vector
+
+def rot_deck(cont):
+      
+    scene = bge.logic.getCurrentScene()
+    deck = scene.objects['npc_ed_deck']
+    #rot = [ 0.0, 0.0, -1.570796327]
+    print('rotating')
+    deck.alignAxisToVect(Vector([1,0,0]),2,.25) 
+    #rot = [ 0.0, 0.0, -0.10796327]
+    #deck.applyRotation(rot,True) 
+    #print('rotating')    
+    
+def collect_npc(cont):
+    #add ed
+    own = cont.owner
+    scene = bge.logic.getCurrentScene()
+    dict = bge.logic.globalDict
+    objList = scene.objects   
+    
+    try:
+        spawned_list = dict['spawned_npc_list']
+        to_spawn = dict['to_spawn']
+    except:
+        dict['spawned_npc_list'] = []  
+        dict['to_spawn'] = []  
+        to_spawn = [] 
+        own['npc_index'] = 0
+    
+    npc_index = 0
+    for x in objList:
+        
+        if 'npc_skater' in x:
+            
+            dict['to_spawn'].append(x)
+            print(x.name, 'added to list')
+            
+def spawn_npc(cont):
+    own = cont.owner
+    scene = bge.logic.getCurrentScene()
+    dict = bge.logic.globalDict
+    objList = scene.objects 
+    to_spawn = dict['to_spawn']
+    #print(to_spawn)
+    npc_index = own['npc_index']
+    
+    if to_spawn:
+        x = dict['to_spawn'][0]  
+        print(x) 
+        
+        x['rpStartLoc'] = [0.0,0.0,0.0] 
+        x['rpStartLoc_set'] = False
+        x['move'] = False  
+        x['npc_rotate'] = False 
+        x['rotate_in'] = False
+        x['move_to'] = False
+        x['rotate_out'] = False      
+
+        obj = scene.addObject('npc_ed_deck', own, 0)
+        obj.setParent(x, False, False)            
+        dict['spawned_npc_decks'].append(obj)
+        obj = scene.addObject('npc_ed_trucks', own, 0)
+        obj.setParent(x, False, False)            
+        dict['spawned_npc_trucks'].append(obj)
+        obj = scene.addObject('npc_ed_arm', own, 0)
+        obj.setParent(x, False, False)
+        dict['spawned_npcs'].append(obj)
+                
+        if npc_index == 0:        
+            shirt = obj.children["npc:Zshirtt1"]
+            shirt.color = [.9,.1,.1,1]
+        if npc_index == 1:        
+            shirt = obj.children["npc:Zshirtt1"]
+            shirt.color = [.1,.9,.1,1]
+        if npc_index == 2:        
+            shirt = obj.children["npc:Zshirtt1"]
+            shirt.color = [.1,.1,.9,1]                        
+        
+        
+        #rot = [ 0.0, 0.0, 1.570796327]
+        x['npc_index'] = npc_index
+        npc_index += 1
+        own['npc_index'] = npc_index
+        print('adding npc character: ', x.name, obj.name)
+        dict['to_spawn'].remove(x)
+        
+        shirt = scene.objects["npc:Zshirtt1"]
+        shirt.color = [255,0,0,1]
+    
+def main():  
+    cont = bge.logic.getCurrentController()
+    own = cont.owner
+    scene = bge.logic.getCurrentScene()
+    #actu = cont.actuators['start_level']
+    dict = bge.logic.globalDict
+    objList = scene.objects
+    mainDir = bge.logic.expandPath("//")
+    skater = 'ai_ed'
+    
+    fileName = mainDir + "npc_skaters/" + str(skater) + '.blend'    
+    
+    path = bge.logic.expandPath(fileName)
+    try:
+        bge.logic.LibLoad(path, 'Scene') 
+    except:
+        print('trying to load', fileName, 'twice')    
+    
+
+    # get object named MainCharacter
+    #armature = objList["npc_ed_arm"]
+    #deck = objList['npc_ed_deck']
+    #trucks = objList['npc_ed_trucks']
+
+    # combine child's shape with parent's
+    compound = False
+
+    # child is solid
+    ghost = False
+    
+    # rotate the game object 1.570796327 radians (90 degrees)
+    #rot = [ 0.0, 0.0, -1.570796327]
+    #deck.applyRotation(rot,False)     
+
+    # set parent
+    #for x in [armature, deck, trucks]:
+        #x.setParent( own, compound, ghost) 
+        #rot = [ 0.0, 0.0, -1.570796327]
+        #deck.applyRotation(rot,True)     
+            
+
+       
+    #rot = [ 0.0, 0.0, -1.570796327]
+    #deck.applyRotation(rot,True) 
+    print('loading ai') 
+
+main()
+        

scripts/music_player.py

+#shuvit.org
+#mp3 player
+
+import bge
+import os
+import aud
+import random
+import glob
+from tinytag import TinyTag
+
+# dict
+dict = bge.logic.globalDict
+dict['mu_current_song'] = ''
+dict['mu_stopped'] = 1
+dict['change_track'] = 0
+dict['mu_track_time'] = 0
+
+# create file path
+directory = bge.logic.expandPath("//")
+file_name = directory + "Music\\*.mp3" # Test directory "Test\\Music\\*.mp3"
+file_list = glob.glob(file_name)
+selected = random.choice(file_list)
+full_path = os.path.join(directory, selected)
+dict['mu_playlist'] = file_list
+dict['mu_lib'] = file_list
+
+# inputs
+keyboard = bge.logic.keyboard
+JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
+
+def initer(cont):
+    own = cont.owner
+    dict = bge.logic.globalDict
+    if 'mplayback' not in dict:
+        dict['mplayback'] = True
+    if 'mp_inited' not in own:
+        own['mp_inited'] = True
+        print('Initializing music player')
+        
+        dict['mu_lib'] = file_list
+        dict['mu_playlist'] = file_list
+        dict['change_track'] = 0
+        selected = random.choice(file_list)
+        dict['mu_current_song'] = selected
+        print('Current Track: ', dict['mu_current_song'])
+        full_path = os.path.join(directory, selected)
+
+        try:
+            tag = TinyTag.get(full_path)
+            print('Artist: %s' % tag.artist, 'Track: %s' % tag.title)
+            dict['mu_artist'] = tag.artist
+            dict['mu_title'] = tag.title            
+        except:
+            print("Track has no tag.")  
+            
+def stop_music(sound):
+
+    print("Stop music")    
+    sound.pauseSound()
+    dict['mu_stopped'] = 1
+    dict['music_player'] = 0
+    
+def play_music():
+
+    print("Play music") 
+    full_path = os.path.join(directory, dict['mu_current_song'])
+    sound = bge.logic.getCurrentController().actuators['music_player']
+    sound.sound = aud.Factory(full_path)
+    sound.stopSound()
+    sound.startSound()
+    dict['mu_stopped'] = 0
+    dict['change_track'] = 0
+    dict['mu_track_time'] = 0 
+    dict['music_player'] = 1  
+    try:
+        tag = TinyTag.get(full_path)
+        print('Playing: ', 'Artist: %s' % tag.artist, 'Track: %s' % tag.title)
+        dict['mu_artist'] = tag.artist
+        dict['mu_title'] = tag.title
+        info = ('Music > ', 'Artist: %s' % tag.artist, 'Track: %s' % tag.title)
+        dict['music_info'] = info
+    except:
+        print("Track has no tag.") 
+    print(dict['mu_title'], 'mu_title')
+    
+def next_track():
+
+    print("next track")
+    dict = bge.logic.globalDict
+    plist = dict['mu_playlist']
+    cur_song = dict['mu_current_song']
+    pl_length = len(dict['mu_playlist'])    
+
+    if pl_length > 1:
+        try:
+            plist.remove(cur_song)
+        except:
+            pass    
+
+    if pl_length == 1:    
+        print('rebuilding playlist')
+        file_list = glob.glob(file_name)
+        plist = file_list
+
+    selected = random.choice(plist)
+    dict['mu_last_track'] = dict['mu_current_song']
+    dict['mu_current_song'] = selected
+    dict['mu_playlist'] = plist
+    dict['change_track'] = 0
+    dict['mu_track_time'] = 0
+    play_music()
+
+def previous_track():
+
+    print("previous track") 
+    dict['mu_current_song'] = dict['mu_last_track']
+    play_music()   
+
+def check_status():
+
+    sound = bge.logic.getCurrentController().actuators['music_player']
+    cur_song = dict['mu_current_song']
+    full_path = os.path.join(directory, dict['mu_current_song'])
+    sound = bge.logic.getCurrentController().actuators['music_player']
+    sound.sound = aud.Factory(full_path)  
+
+    if sound.time < dict['mu_track_time'] and dict['mu_stopped'] == 0 and dict['change_track'] == 0:
+        print('song over, getting new one')
+        dict['change_track'] = 1
+        dict['mu_track_time'] = 0
+    else:
+        dict['change_track'] = 0
+    dict['mu_track_time'] = sound.time    
+
+def main(cont):
+
+    dict = bge.logic.globalDict        
+    cur_song = dict['mu_current_song']    
+    full_path = os.path.join(directory, dict['mu_current_song'])
+    sound = bge.logic.getCurrentController().actuators['music_player']
+    sound.sound = aud.Factory(full_path)
+    sound.mode = 1
+    initer(cont)
+    if dict['music_player'] != 0:
+        if dict['mu_stopped'] == 1:        
+            play_music()
+        if dict['change_track'] == 1:
+            dict['change_track'] = 0
+            next_track() 
+
+    plist = dict['mu_playlist']  
+    pl_length = len(dict['mu_playlist'])    
+    if pl_length == 0:
+        dict['mu_playlist'] = dict['mu_lib']       
+         
+    #allow controlls while paused or in replay    
+    if dict['npause']  == 1 or dict['playback'] == True:
+        if dict['yBut'] == False and dict['last_yBut'] == True:
+            if dict['mu_stopped'] == 1:
+                play_music() 
+            else:
+                stop_music(sound)  
+        if dict['lBump'] == False and dict['last_lBump'] == True:
+            previous_track()
+        if dict['rBump'] == False and dict['last_rBump'] == True:
+            next_track() 

scripts/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()
+    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']   
+    
+    cube = scene.objects['control_cube.002']
+    
+    try:
+        pause_state = dict['npause']
+        last_pause = dict['last_npause']
+    except:
+        dict['npause'] = 0
+        dict['last_npause'] = 0
+        pause_state = 0
+        last_pause = 0
+
+
+    def printplaying():
+        splaying_layers = "S: "
+        playing_layers = "D: "
+        tplaying_layers = "T: "
+        for x in range(1000):
+            if skater.isPlayingAction(x):
+            #if trucks.isPlayingAction(x):
+            #if skater.isPlayingAction(x):                        
+                splaying_layers += str(x)
+                splaying_layers += " "        
+            if deck.isPlayingAction(x):
+            #if trucks.isPlayingAction(x):
+            #if skater.isPlayingAction(x):                        
+                playing_layers += str(x)
+                playing_layers += " "
+            if trucks.isPlayingAction(x):
+            #if trucks.isPlayingAction(x):
+            #if skater.isPlayingAction(x):                        
+                tplaying_layers += str(x)
+                tplaying_layers += " "            
+        print(splaying_layers, playing_layers, tplaying_layers)
+
+    
+    #switch pause state
+    if dict['stBut'] == True and dict['last_stBut'] == False:
+        if pause_state == 0:
+            pause_state = 1
+        else:
+            pause_state = 0    
+        dict['npause'] = pause_state
+    
+    #enter pause    
+    if pause_state == 1 and last_pause == 0:
+        own.suspendDynamics()
+        own['pre_pause_linvel'] = [own['linvelx'], own['linVely'], 0]
+        own.setLinearVelocity([0,0,0],1)  
+        cont.activate(cont.actuators['empty'])
+        if mcam['playback'] == False:
+            cont.activate(cont.actuators['add_overlay']) 
+        cont.activate(cont.actuators['remove_stance'])  
+        cube['camera'] = 2
+        cube['camnum'] = 2 
+        scene.active_camera = freecam 
+        freecam.lens = mcam['focal_length'] 
+        freecam.worldPosition = mcam.worldPosition
+        freecam.worldOrientation = mcam.worldOrientation                      
+
+    if pause_state == 1: 
+        if mcam['playback'] == False:       
+            layer = 2
+            if skater.isPlayingAction(layer):
+                skater.stopAction(layer)
+            if deck.isPlayingAction(layer):    
+                deck.stopAction(layer)
+            if trucks.isPlayingAction(layer):    
+                trucks.stopAction(layer)
+            layer = 3
+            if skater.isPlayingAction(layer):
+                skater.stopAction(layer)
+            if deck.isPlayingAction(layer):    
+                deck.stopAction(layer)
+            if trucks.isPlayingAction(layer):    
+                trucks.stopAction(layer)
+            layer = 4
+            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:
+        Settings.writeSettings()
+        Settings.writeChar()
+        own.restoreDynamics()
+
+        if own['walk'] == False:
+            cont.activate(cont.actuators['roll'])
+        else:
+            cont.activate(cont.actuators['walk'])    
+        try:
+            own.setLinearVelocity(own['pre_pause_linvel'], 1) 
+        except:
+            pass    
+        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'])                                   
+    dict['last_npause'] = pause_state
+    
+main()

scripts/npcChangeAnim.py

+#npcChangeAnim
+
+import bge
+import random
+
+a_starts = ['20secA.dat', '20secE.dat', 'shopSaEa40a.dat', 'shopSaEb40a.dat', 'shopSaEb20a.dat', 'shopSaEa30a.dat']
+a_ends = ['20secA.dat', '20secE.dat', 'shopSaEa40a.dat', 'shopSbEa50a.dat', 'shopSbEa60a.dat', 'shopSaEa30a.dat']
+b_starts = ['shopSbEb40sec.dat', 'shopSbEa50a.dat', 'shopSbEa60a.dat', 'shopSbEb50a.dat']
+b_ends = ['shopSbEb40sec.dat', 'shopSaEb40a.dat', 'shopSaEb20a.dat', 'shopSbEb50a.dat']
+
+def main(cont):
+    own = cont.owner
+    own['npc_playback'] = False
+    
+    if own['npc_replay_name'] in a_ends:
+        num = len(a_starts) - 1
+        ran = random.randint(0,num)
+        own['npc_replay_name'] = a_starts[ran]
+    elif own['npc_replay_name'] in b_ends:
+        num = len(b_starts) - 1
+        ran = random.randint(0,num)
+        own['npc_replay_name'] = b_starts[ran]        
+    
+    if own['npc_replay_name'] == '20secA.dat':
+        own['replay_length'] = 2400
+    if own['npc_replay_name'] == '20secE.dat':
+        own['replay_length'] = 2400    
+    if own['npc_replay_name'] == 'shopSaEa40a.dat':
+        own['replay_length'] = 6500 
+    if own['npc_replay_name'] == 'shopSaEb40a.dat':
+        own['replay_length'] = 5500  
+    if own['npc_replay_name'] == 'shopSbEa50a.dat':
+        own['replay_length'] = 6500  
+    if own['npc_replay_name'] == 'shopSbEb40sec.dat':
+        own['replay_length'] = 6500 
+    if own['npc_replay_name'] == 'shopSaEb20a.dat':
+        own['replay_length'] = 2300     
+    if own['npc_replay_name'] == 'shopSbEa60a.dat':
+        own['replay_length'] = 7100 
+    if own['npc_replay_name'] == 'shopSaEa30a.dat':
+        own['replay_length'] = 3200 
+    if own['npc_replay_name'] == 'shopSbEb50a.dat':
+        own['replay_length'] = 6000                                             
+
+    print('Playing NPC-Replay:', own['npc_replay_name'])
+
+    
+    own['rpStartLoc_set'] = False  

scripts/pause.py

+import bge
+cont = bge.logic.getCurrentController()
+own = cont.owner
+dict = bge.logic.globalDict
+
+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']
+
+#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()
+    dict = bge.logic.globalDict
+#    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
+    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 = "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 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()

scripts/pause_menu2.py

+import bge
+
+
+def check_idle():
+    dict = bge.logic.globalDict
+    dict['menu_idle_timer'] +=1
+    idle = 0
+    if dict['aBut'] or dict['bBut'] or dict['xBut'] or dict['yBut'] or dict['ddPad'] or dict['udPad'] or dict['ldPad'] or dict['rdPad'] or (dict['lUD'] > .02 or dict['lUD'] < -.02) or (dict['lLR'] > .02 or dict['lLR'] < -.02) or (dict['rUD'] > .02 or dict['rUD'] < -.02) or (dict['rLR'] > .02 or dict['rLR'] < -.02):
+        dict['menu_idle_timer'] = 0
+    #print('idtime', dict['menu_idle_timer']) 
+    if dict['menu_idle_timer'] > 500:
+        idle =1
+    return idle                        
+
+def update_text(cont):
+    own = cont.owner
+    scene = bge.logic.getCurrentScene()
+    dict = bge.logic.globalDict
+    if dict['pause_menu_text'] == '':
+        scene.objects['menu_text'].text = 'menu > fuck' 
+    else:
+        if 'menu_text' in scene.objects: 
+            scene.objects['menu_text'].text = dict['pause_menu_text']   
+        if 'menu_text.001' in scene.objects: 
+            scene.objects['menu_text.001'].text = dict['pause_menu_text']               
+
+#    scene = bge.logic.getCurrentScene()
+    for object in scene.objects:
+        if isinstance(object, bge.types.KX_FontObject):
+            object.resolution = 16     
+                    
+    info = ('Music > ' + dict['mu_artist'] + ' - ' + dict['mu_title'])
+    #print(info)
+    try:
+        scene.objects['music_info_txt'].text = info                       
+    except:
+        pass    
+                    
+                    
+def main(cont):
+    update_text(cont)  
+    check_idle()      
+
+#active selection list        
+#selected_item_index

scripts/scene_init.py

+import bge
+import colors
+
+def main():
+    import bge
+    #import GameLogic
+    cont = bge.logic.getCurrentController()
+    own = cont.owner
+    dict = bge.logic.globalDict
+    #print("nnnnnnpause level", dict['level'])
+    own['last_stBut'] = False
+    level = dict['level']
+    scene = bge.logic.getCurrentScene()
+    cam = scene.objects['Camera.003']
+    curscene = bge.logic.getCurrentScene()
+    
+#    scenes = bge.logic.getSceneList()
+#    for scene in scenes :
+#        if scene.name == 'main':
+#            player = scene.objects['player']    
+#    main = bge.logic.getSceneList["main"]
+
+    dict['overlay_fadeout'] = 1
+    scenes = bge.logic.getSceneList()
+    own['pre_pause_linvel'] = 0.0
+
+    objList = scene.objects
+
+    # get object named MainCharacter
+    parent = objList["control_cube.002"]
+
+    # combine child's shape with parent's
+    compound = True
+    obj = scene.objects['Char4']
+    # child is solid
+    ghost = False
+    # set parent
+    obj.setParent( parent, compound, ghost) 
+    parent.worldPosition.z += .5 
+  
+    scene.gravity = [0,0,dict['gravity']]    
+    for i in scenes:
+        if i.name == "main":
+            main = i
+    
+    for i in scenes:
+        if i.name == "fade_out":
+            print('ending fade_out', scenes)
+            scene2 = i
+            scene2.end()  
+               
+    
+    if level == 'newday':
+        brightness = 2.6
+        cam['BC_BRIGHTNESS'] = 1.3
+        cam['BC_CONTRAST'] = 1.5
+#    elif level == 'lot':
+#        brightness = 2.6
+#        cam['BC_BRIGHTNESS'] = 1
+#        cam['BC_CONTRAST'] = 1   
+#        #main.world.zenithColor = [1.0, .9, .975, 0]
+#        #main.world.horizonColor = [.42, .555, .823, 0] 
+#        curscene.world.zenithColor = [1.0, .9, .975, 0]
+#        curscene.world.horizonColor = [.42, .555, .823, 0]                 
+        #print("sadfasdfsdfasdfasdfasdfasdfasdf")
+    elif level == 'spine':
+        brightness = 2.6
+        cam['BC_BRIGHTNESS'] = .85
+        cam['BC_CONTRAST'] = 1.1  
+        
+    elif level == 'sc':
+        print('setting color of', curscene)
+        curscene.world.zenithColor = [.23, .23, .25, 1] #[0.1,.2,.4,.5]#[.58, .86, 1.0, 0] #[.3, 0.3, 0.3, 0]
+        curscene.world.horizonColor = [.1, .15, .3, 1] #[0.1,0,0,1] #[.58, .86, 1.0, 1]         
+        
+    elif level == 'garage18':
+        print('setting color of', curscene)
+        curscene.world.zenithColor = [0, 0.0, 0.0, 0]
+        curscene.world.horizonColor = [0, 0, 0.0, 0]   
+
+    elif level == 'pats':
+        print('setting color of', curscene)
+     
+    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"])
+        
+    if dict['bloom_on'] == 1:
+        cont.activate(cam.actuators["Bloom"])
+
+    else:
+        cont.activate(cam.actuators["bloom_off"])
+        
+#    print(dict['shadow_on'], 'shadow_on')    
+#    if dict['shadow_on'] == 1:
+#        bge.render.setGLSLMaterialSetting("shadows", 1) 
+#    else:
+#        bge.render.setGLSLMaterialSetting("shadows", 0)  
+
+    if dict['music_player'] == 1:
+        dict['music_start'] =  True   
+        print('starting music') 
+    else:
+        print('not starting music', dict['music_player'])        
+        
+    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']
+    cam['dof_on'] = dict['dof_on']
+    cam['bloom_on'] = dict['bloom_on'] 
+    cam['fxaa'] = dict['fxaa']
+    cam['FXAA_SPAN_MAX'] = dict['FXAA_SPAN_MAX']     
+    own['grindnew_timer'] = 0   
+    own['last_ramp'] = 0
+    own['requestAction'] = ''
+    own['l_actionState'] = ''
+    own['actionState'] = ''
+    own['transition_timer'] = 0
+    own['transitioning'] = 0
+    own['driving'] = False
+    dict['last_driving'] = False
+    own['last_roty'] = 0.0
+    
+    own['walk_targ_speed'] = 2
+    own['walk_fast_targ_speed'] = 5
+    own['walk_speed'] = 0
+    own['walk_inc'] = .05
+    own['walk_jump_timer'] = 0
+    own['no_grind_timer'] = 0
+    own['last_jump_frame'] = 0
+    
+    colors.update_shirt_tex() 
+    colors.update_truck_tex()
+    
+    print('scene init ran')
+      
+main()

scripts/stance.py

+import bge
+from bge import logic
+cont = bge.logic.getCurrentController()
+own = cont.owner
+
+
+#scene = bge.logic.getCurrentScene()
+#control_bottom = scene.objects['control_bottom']
+#grindTouch = control_bottom.sensors['grindCol_bottom']
+#edge = 0
+#try:
+#    if 'edge' in grindTouch.hitObject:
+#        print('Edge')
+#        edge = 1
+#except:
+#    pass        
+
+#constants
+STANCE_SENS = 0.05
+STANCE = own["stance"]
+jumpstance = own['jump_stance']
+grindpos = own['grindpos']
+# use game object axis
+local = True
+try:
+    #stance detection   
+    if own['ground'] == True and (own['grindpos'] != 'reg_board' or own['grindOld'] == False) and own['invert_on'] == False:
+        #print("detect stance") 
+        LVX = own.localLinearVelocity.x
+        if LVX > STANCE_SENS:
+            STANCE = 1
+            
+        if LVX < (-STANCE_SENS):
+            STANCE = 0
+except:
+    print("no stance")
+#if jumpstance == 3:
+#    if own["grindOld"] == 0:
+#        own["stance"] = STANCE
+#else:
+#    if grindpos == "reg_5050":
+#        own["stance"] = STANCE
+#    else:
+#        STANCE = jumpstance
+own["stance"] = STANCE           
+dict = bge.logic.globalDict #Get the global dictionary
+dict['stance'] = STANCE #Store the new score
+#print(STANCE)
+#stance = dict.get('stance') #Get the current score or the number 0
+#print(LVX)    
+#print(STANCE)
+

scripts/trick_text.py

+import bge
+
+
+def main():
+
+    cont = bge.logic.getCurrentController()
+    own = cont.owner
+    dict = bge.logic.globalDict
+    trick_string = dict.get('trick_string')
+    #print(trick_string, "textstring")
+    print_text_timer = own['print_text_timer']
+    print_text_timer2 = own['print_text_timer2']
+    print_text_timer3 = own['print_text_timer3']
+    old_print_text = own['print_text']
+    old_print_text2 = own['print_text2']
+    old_print_text3 = own['print_text3']
+    print_text = ''
+    timer_length = 300
+    #set strings
+    show_tricks = 0
+    if show_tricks == 1:
+        if trick_string != None:
+            if old_print_text == '':
+            #if 1 == 1:    
+                own['print_text'] = trick_string
+                print_text_timer = timer_length
+                print_text = trick_string
+                own['print_text'] = print_text
+            elif old_print_text2 == '':
+                text = own['print_text']
+                text = '\n' + str(text)
+                own['print_text2'] = text
+                own['print_text'] = trick_string
+                print_text_timer2 = own['print_text_timer']
+                print_text_timer = timer_length
+                print_text = trick_string
+                own['print_text'] = print_text 
+            elif old_print_text3 == '':
+                own['print_text3'] = own['print_text2']
+                own['print_text2'] = own['print_text']
+                text = own['print_text']
+                text = '\n' + str(text)
+                own['print_text2'] = text
+                own['print_text'] = trick_string
+                print_text_timer3 = own['print_text_timer2']
+                print_text_timer2 = own['print_text_timer']
+                print_text_timer = timer_length
+                print_text = trick_string
+                own['print_text'] = print_text                
+            dict['trick_string'] = None
+
+    #read timers
+        #print("t1: ", print_text_timer, "t2: ", print_text_timer2)
+        if print_text_timer3 > 0:
+            print_text_timer3 = print_text_timer3 - 1
+            print_text3 = own['print_text3']
+            #own.text = (str(print_text) + str(print_text2))
+            own['print_text_timer3'] = print_text_timer3
+        if print_text_timer3 <=0:
+            print_text3 = ''
+            own['print_text_timer3'] = '' 
+            own['print_text3'] = '' 
+        if print_text_timer2 > 0:
+            print_text_timer2 = print_text_timer2 - 1
+            print_text2 = own['print_text2']
+            #own.text = (str(print_text) + str(print_text2))
+            own['print_text_timer2'] = print_text_timer2
+        if print_text_timer2 <=0:
+            print_text2 = ''
+            own['print_text_timer2'] = '' 
+            own['print_text2'] = ''    
+        if print_text_timer > 0:
+            print_text_timer = print_text_timer - 1
+            print_text = own['print_text']
+            #own.text = str(print_text)
+            own['print_text_timer'] = print_text_timer
+            #print("print text is: ", print_text)
+        if print_text_timer <= 0:
+            own.text = ''
+            own['print_text'] = ''   
+            own['print_text_timer'] = print_text_timer 
+    #        own['print_text_timer3'] = print_text_timer3 
+    #        own['print_text_timer2'] = print_text_timer2    
+        dict['last_trick_string'] = dict.get('trick_string')
+        print_text_timer = own['print_text_timer']
+        old_print_text = own['print_text']
+        old_print_text2 = own['print_text2']
+        old_print_text3 = own['print_text3']
+        output_text = str(old_print_text) + str(old_print_text2) + str(old_print_text3) 
+        own.text = output_text
+    #print("1: ", old_print_text, "2: ", old_print_text2, "3: ", old_print_text3)    
+    #print(print_text_timer, " : timer")
+    else:
+        own.text = ''
+main()

scripts/walk.py

+#shuvit.org
+#walk.py
+
+import bge
+import GameLogic
+import ctypes
+import random
+import math
+
+scene = bge.logic.getCurrentScene()
+objList = scene.objects
+
+cont = GameLogic.getCurrentController() 
+obj = bge.logic.getCurrentScene().objects
+char = bge.constraints.getCharacter
+own = cont.owner
+stance = own['stance']
+STANCE = own['stance']
+r_ground = cont.sensors["r_Ground"]
+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
+except:
+    own['walk_timer'] = 1
+    own['walk_targ_speed'] = 2.0
+
+truckon = 450
+deckon = 460
+
+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
+fliplay = 30
+dropinCol = own.sensors['dropinCol']
+cube = scene.objects['control_cube.002']
+skater = scene.objects["Char4"]
+deck = scene.objects["deck"]
+trucks = scene.objects["trucks"]
+camobj2 = scene.objects['camobj']
+throw_deck_empty = scene.objects["throw_deck_empty"]
+wheel1 = scene.objects["rollen.000"]
+wheel2 = scene.objects["rollen.001"]
+wheel3 = scene.objects["rollen.002"]
+wheel4 = scene.objects["rollen.003"]
+camobj = scene.objects["Camera.003"]
+camera = cont.actuators["Camera"]
+replayCam = cont.actuators["replayCam"]
+timer = own['dropinTimer']
+cam = scene.objects["Camera.003"]
+freecam = scene.objects["freecam"]
+followcam = scene.objects["followcam"]
+
+control_bottom = scene.objects['control_bottom']
+cb = control_bottom.sensors['grindCol_bottom']
+cb_td = control_bottom.sensors['td_bottom']
+
+noidle = 0
+
+#if skater.isPlayingAction(460):  
+#    noidle = 1  
+try:
+    walk_inc = own['walk_inc'] 
+except:
+    own['walk_inc'] = .01
+    walk_inc = own['walk_inc']  
+    own['walk_jump_timer'] = 0   
+if own['stair_counter'] != 0:
+    walk_inc = own['walk_inc']  *10
+
+if own["stance"] == None:
+    own["stance"] = True
+STANCE = own["stance"]
+def killact(layer):
+    if skater.isPlayingAction(layer):
+        skater.stopAction(layer)
+    if deck.isPlayingAction(layer):    
+        deck.stopAction(layer)
+    if trucks.isPlayingAction(layer):    
+        trucks.stopAction(layer)
+def killall():
+    for x in range(5000):
+        skater.stopAction(x)
+        deck.stopAction(x)
+        trucks.stopAction(x)
+def trucksisplaying():
+    for x in range(5000):
+        if deck.isPlayingAction(x):
+            print("deck is playing:", x)
+
+def printplaying():
+    splaying_layers = "S: "
+    playing_layers = "D: "
+    tplaying_layers = "T: "
+    for x in range(9900):
+        if skater.isPlayingAction(x):
+        #if trucks.isPlayingAction(x):
+        #if skater.isPlayingAction(x):                        
+            splaying_layers += str(x)
+            splaying_layers += " "        
+        if deck.isPlayingAction(x):
+        #if trucks.isPlayingAction(x):
+        #if skater.isPlayingAction(x):                        
+            playing_layers += str(x)
+            playing_layers += " "
+        if trucks.isPlayingAction(x):
+        #if trucks.isPlayingAction(x):
+        #if skater.isPlayingAction(x):                        
+            tplaying_layers += str(x)
+            tplaying_layers += " "            
+    print(splaying_layers, playing_layers, tplaying_layers) 
+#printplaying() 
+##
+if r_ground.positive and xBut == False and lastx == False:
+    killact(10)
+    #killact(11)
+    killact(12)
+    killact(13)              
+######################################    
+
+#idle      
+if stance == 0 and skater.isPlayingAction(fliplay) == False and yBut == False and r_ground.triggered and xBut == False and noidle == 0 and own['walk_idling'] == 0 and own['sit'] == 0 and own['dropinTimer'] == 0 and own['lasty']  == False:
+    own['requestAction'] = 'reg_idle'
+    if own['throw_deck'] == True:
+        own['requestAction'] = 'reg_idle_nb'
+
+if stance == 1 and skater.isPlayingAction(fliplay) == False and yBut == False and r_ground.triggered and xBut == False and noidle == 0 and own['walk_idling'] == 0 and own['sit'] == 0 and own['dropinTimer'] == 0 and own['lasty']  == False:
+    own['requestAction'] = 'fak_idle'
+    if own['throw_deck'] == True:
+        own['requestAction'] = 'fak_idle_nb'
+
+if lUD < -sens:
+    lup = 1
+else:
+    lup = 0
+if lUD > sens:
+    ldown = 1
+else:
+    ldown = 0 
+if lLR < -sens:
+    lLeft = 1
+else:
+    lLeft = 0
+if lLR > sens:
+    lRight = 1
+else:
+    lRight = 0        
+
+
+
+#turning
+turning = False
+if r_ground.positive:
+    num = .5
+    tilt = .015
+    if STANCE == 1:
+        num *= -1
+        tilt *= -1
+    if lRight == 1 or dict['kb_ra'] == 2:
+        #cont.activate(own.actuators['right'])
+        own.linearVelocity.y = num
+        if own['stair_counter'] > 0:
+            if STANCE == 0:
+                own.applyRotation([0,0,.05], True)
+            else:
+                own.applyRotation([0,0,-.05], True)                
+        else:
+            own.applyRotation([-tilt, 0, 0], True)
+        turning = True
+    else:
+        #cont.deactivate(own.actuators['right']) 
+        pass  
+        
+    if lLeft == 1 or dict['kb_la'] == 2:
+        #cont.activate(own.actuators['left']) 
+        own.linearVelocity.y = -num
+        if own['stair_counter'] > 0:
+            if STANCE == 0:
+                own.applyRotation([0,0,.05], True)
+            else:
+                own.applyRotation([0,0,-.05], True)                                
+        else:        
+            own.applyRotation([tilt, 0, 0], True)        
+        turning = True
+    else:
+        #cont.deactivate(own.actuators['left'])        
+        pass
+
+#in air        
+#if (lup == 1 or dict['kb_ua'] != 0) and r_ground.positive == False:
+if r_ground.positive == False:
+    airrot = .05
+    if lLeft == 1 or dict['kb_la'] == 2:
+        if stance == 0:
+            own.applyRotation([0,0,airrot], True)
+        if stance == 1:    
+            own.applyRotation([0,0,airrot], True)
+    if lRight == 1 or dict['kb_ra'] == 2:
+        if stance == 0:
+            own.applyRotation([0,0,-airrot], True)
+        if stance == 1:    
+            own.applyRotation([0,0,-airrot], True)  
+            
+    if lup == 1 or dict['kb_ua'] == 2:
+        if own.linearVelocity.x < 10 and own .linearVelocity.x > - 10:
+            if stance == 0:
+                own.linearVelocity.x -= .04
+            if stance == 1:
+                own.linearVelocity.x += .04                             
+    own['lF_air_frame'] = own['framenum']  
+    own.actuators["walkondirt"].stopSound()
+
+    
+#walking
+
+#new walking
+vel = own.getLinearVelocity(True)
+if own['walk_timer'] < 50:
+    velx = vel.x * .95             
+    own.setLinearVelocity([velx, 0, vel.z], True)
+    #print('y is zero')
+else:
+    pass
+    #own.setLinearVelocity([0, 0, vel.z], True)
+    
+wf = 1
+if own['last_walk_frame'] - own['last_roll_frame'] > 55:
+    wf = 0   
+   
+if ((lup == 1 and aBut == 0) or (dict['kb_ua'] == 2 and dict['kb_lsh'] == 0)) and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0 and wf == 0 and dict['kb_space'] == 0:
+    own['walking'] = "regular"
+    walking = "regular"
+    
+elif ((lup == 1 and aBut == 1) or (dict['kb_lsh'] == 2 and dict['kb_ua'] == 2)) and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0 and wf == 0 and dict['kb_space'] != 2:
+    own['walking'] = "fast"
+    walking = "fast"
+else:
+    own['walking'] = None
+    walking = None
+   
+if walking == "regular":  
+    if stance == 1:
+        if linvel.x < own['walk_targ_speed']:
+            own.linearVelocity.x = linvel.x + walk_inc
+        else:
+            own.linearVelocity.x = own['walk_targ_speed']    
+    else:
+        if linvel.x > -own['walk_targ_speed']:
+            own.linearVelocity.x = linvel.x - walk_inc       
+        else:
+            own.linearVelocity.x = -own['walk_targ_speed']                
+if walking == "fast":   
+    if stance == 1:
+        if linvel.x < own['walk_fast_targ_speed']:
+            own.linearVelocity.x = linvel.x + walk_inc
+        else:
+            own.linearVelocity.x = own['walk_fast_targ_speed']  
+    else:
+        if linvel.x > -own['walk_fast_targ_speed']:
+            own.linearVelocity.x = linvel.x - walk_inc      
+        else:
+            own.linearVelocity.x = -own['walk_fast_targ_speed'] 
+
+if walking == None and r_ground.positive and own['walk_jump_timer'] == 0:      
+    if own['walk_timer'] < 50 and turning == False:
+        velx = vel.x * .95             
+        own.setLinearVelocity([velx, 0, vel.z], True)
+    elif own['walk_timer'] > 50:
+        if own.linearVelocity.x > .1 or own.linearVelocity.x < -.1:
+            own.linearVelocity.x *= .01
+        else:
+            own.linearVelocity.x = 0
+        if turning == False:    
+            if own.linearVelocity.y > .01 or own.linearVelocity.y < -.01:
+                own.linearVelocity.y *= .01
+            else:
+                own.linearVelocity.y = 0                
+        #own.setLinearVelocity([0, 0, vel.z], True) 
+    
+#old walking
+if ((lup == 1 and aBut == 0) or (dict['kb_ua'] == 2 and dict['kb_lsh'] == 0)  and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0) or (turning == True and aBut == 0):
+    own.actuators["walkondirt"].volume = .2
+    own.actuators["walkondirt"].pitch = 1
+    cont.activate(own.actuators["walkondirt"])          
+    if stance == 0 and skater.isPlayingAction(fliplay) == False:             
+        #without deck
+        if own['throw_deck'] == True:
+            own['requestAction'] = 'reg_walk_nb'
+        else:
+            own['requestAction'] = 'reg_walk'
+               
+    if stance == 1 and skater.isPlayingAction(fliplay) == False:        
+        #without deck
+        if own['throw_deck'] == True:
+            own['requestAction'] = 'fak_walk_nb'
+        else:
+            own['requestAction'] = 'fak_walk'
+       
+elif (((lup == 1 and aBut == 1) or (dict['kb_lsh'] == 2 and dict['kb_ua'] == 2)) and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0) or (turning == True and aBut == 1):
+    own.actuators["walkondirt"].volume = .2
+    own.actuators["walkondirt"].pitch = 1.3
+    cont.activate(own.actuators["walkondirt"])
+    #print('fastwalk')
+    if stance == 0 and skater.isPlayingAction(fliplay) == False:        
+        if own['throw_deck'] == True:
+            own['requestAction'] = 'reg_walkFast_nb'
+        else:
+            own['requestAction'] = 'reg_walkFast'
+         
+    if stance == 1 and skater.isPlayingAction(fliplay) == False:        
+        if own['throw_deck'] == True:
+            own['requestAction'] = 'fak_walkFast_nb'          
+        else:
+            own['requestAction'] = 'fak_walkFast'             
+else:
+    vel = own.getLinearVelocity(True)
+    cont.deactivate(own.actuators["walkondirt"])       
+
+       
+#---------------
+if rLR > .05:
+    cont.activate(camobj.actuators['camRight'])
+else:
+    cont.deactivate(camobj.actuators['camRight'])    
+if rLR < -.05:
+    cont.activate(camobj.actuators['camLeft'])
+else:
+    cont.deactivate(camobj.actuators['camLeft'])     
+if rUD > .05:
+    cont.activate(camobj.actuators['camDown'])
+else:
+    cont.deactivate(camobj.actuators['camDown'])     
+if rUD < -.05:
+    cont.activate(camobj.actuators['camUp'])
+else:
+    cont.deactivate(camobj.actuators['camUp'])     
+                
+#----------------
+#camera.height = .01 #.9
+#camera.min = 1.75
+#camera.max = 2.25
+lasty = own['lasty']     
+
+def onboard():
+    if own['walk'] == 0:
+        #print("start walking")
+        own['walk_idling'] = 0
+        if own['framenum'] > 100 and own['fall'] == False:
+            cont.activate(own.actuators['pop'])
+        own['getoffboard'] = False
+        own["walk_idle_frame"] = own["framenum"]
+        own['grindcement_vol'] = 0
+        own['grindcement_pitch'] = 0
+        own['grindrail_vol'] = 0
+        own['grindrail_pitch'] = 0 
+        own['sroll_vol'] = 0
+        own['sroll_pitch'] = 0   
+        
+        #camobj.worldPosition.z += 4              
+        try:
+            vel = own['offboard_vel']
+            vel = [velx, vel.y, vel.z]           
+        except: 
+            pass
+         
+        if STANCE == 0:
+            own['requestAction'] = 'reg_offboard'             
+            
+        if STANCE == 1:
+            own['requestAction'] = 'fak_offboard'                          
+def jump():
+    #limit fall speed
+    if linvel.z < -10:
+        own.linearVelocity.z = -10
+    if xBut == True or dict['kb_space'] == 1: 
+        if own['lastx'] == 0:
+            #killact(3)
+            #killact(4)
+            #killact(5)
+            #killact(6)
+            #killact(7)      
+            if STANCE == 0:  
+                own['requestAction'] ='reg_jump'  
+                #print('jump') 
+            if STANCE == 1:
+                own['requestAction'] ='fak_jump'             
+                #print('jump')
+            JUMPHEIGHT = 1100
+            force = [ 0.0, 0.0, JUMPHEIGHT]
+            # use local axis
+            local = False
+            # apply force -- limit jump speed
+            if linvel.z < 10:
+                #own.applyForce(force, local)
+                own.linearVelocity.z += 5
+                own.linearVelocity.x = linvel.x
+                own.linearVelocity.y = linvel.y
+                own['walk_jump_timer'] = 20
+        own['lastx'] = 1
+    else:
+        own['lastx'] = 0
+def dropin():
+    if dropinCol.positive == True:
+        pass       
+        
+def getonboard(dict):
+    #print(dict['kb_q'])
+    getonboard = own['getonboard']
+    fliplay2 = 50#8560
+    if ((yBut == True and dict['last_yBut'] == False) or dict['kb_q'] == 2):# and (cont.sensors["vehicleNear"].positive == False and own['throw_deck'] == False):
+        fliplay3 = fliplay2 + 1 
+        if dropinCol.positive == True: 
+            nearestObject = None
+            grindEmpty = scene.objects['grindEmpty']
+            grindDar = grindEmpty.sensors['grindDar2']
+            minDist = None             
+            if grindDar.positive:
+                detectedObjects = grindDar.hitObjectList
+                dist = 0
+                for obj in detectedObjects:
+                    dist = own.getDistanceTo(obj)
+                    if (minDist is None or dist < minDist):
+                        nearestObject = obj
+                        minDist = dist
+            if nearestObject != None:
+                #print(nearestObject)
+                obj = nearestObject
+                player_e = own.worldOrientation.to_euler()
+                player_pos = own.worldPosition
+                player_rotz = math.degrees(player_e[2])                
+                grinder_e = obj.worldOrientation.to_euler()
+                grinder_rotz = math.degrees(grinder_e[2])            
+                rot = player_rotz - grinder_rotz  
+                grinder_pos = obj.worldPosition 
+                worldVect = [1, 0, 0]
+                vect = obj.getAxisVect(worldVect)      
+                go = obj.worldOrientation
+                grinder_axis = [1,0,0] 
+                try: 
+                    delta = player_pos - grinder_pos
+                    
+                    delta = delta.cross(vect)
+                    if delta[2] >= 0:
+                        grindside = "right"
+                    else:
+                        grindside = "left"                    
+                    deltamove = delta[2] * .1#.25
+                    if STANCE == 0:
+                        move = [-deltamove, 0, 0]
+                    else:
+                        move = [deltamove, 0, 0]                            
+                    own.applyMovement(move, True)                    
+                except:
+                    pass 
+
+            if STANCE == 0: 
+                own['requestAction'] ='reg_dropin_pos' 
+                own['dropinTimer'] = 60                                     
+                    
+            if STANCE == 1: 
+                own['requestAction'] ='fak_dropin_pos'  
+                own['dropinTimer'] = 60                                 
+                                     
+    if getonboard == 1:
+        fliplay3 = 6000 
+        onboard_speed = .1                                      
+        own['getonboard'] = 0 
+        own['walk_idling'] = 0
+    if (yBut == False and lasty == True) or (yBut == True or dict['kb_q'] == 2) and dropinCol.positive:
+        deckact = deck.actuators["Visibility"]
+        trucksact = trucks.actuators["Visibility"]
+        wheel1act = wheel1.actuators["Visibility"]
+        wheel2act = wheel2.actuators["Visibility"]
+        wheel3act = wheel3.actuators["Visibility"]
+        wheel4act = wheel4.actuators["Visibility"]        
+        deckact.visibility = True
+        trucksact.visibility = True
+        wheel1act.visibility = True
+        wheel2act.visibility = True
+        wheel3act.visibility = True
+        wheel4act.visibility = True  
+        cont.activate(deck.actuators['Visibility'])
+        cont.activate(trucks.actuators['Visibility'])
+        cont.activate(wheel1.actuators['Visibility'])
+        cont.activate(wheel2.actuators['Visibility'])
+        cont.activate(wheel3.actuators['Visibility'])
+        cont.activate(wheel4.actuators['Visibility']) 
+        own['throw_deck'] = False 
+        throw_deck_empty = scene.objects["throw_deck_empty"]
+        throw_deck_empty['kill_deck'] = 1 
+    if ((yBut == False and lasty == True) or dict['kb_q'] == 3):# and cont.sensors["vehicleNear"].positive == False:               
+        own['getonboard'] = 1 
+        own['walk_idling'] = 0      
+
+def nextframe():
+    framenumber = own["framenum"]
+    framenumber = framenumber + 1
+    if framenumber == 900000:
+        framenumber = 0
+    own["framenum"] = framenumber
+    own['last_walk_frame'] = framenumber
+            
+def checkidle():
+    idle = cont.sensors["idle"]
+    idle_frame = own["walk_idle_frame"]
+    if idle.positive:
+        own["walk_idle_frame"] = 0
+        cont.deactivate(camobj.actuators['idle_camRight'])  
+        #camera.height = .5
+        camera.height = dict['cam_idle_height']
+    else: 
+        if idle_frame == 0:
+            own["walk_idle_frame"] = own["framenum"] 
+        diff = own["framenum"] - idle_frame
+        
+        if (diff > 700 and idle_frame != 0 and dropinCol.positive == False and own['walk'] != 0) or own['sit'] == 1:
+            cont.activate(camobj.actuators['idle_camRight'])  
+            #camera.height = .9   
+            #camera.min = 2
+            #camera.max = 2.50
+            own['walk_idling'] = 1
+        else:
+            own['walk_idling'] = 0    
+            
+def idle_anim():
+    if own['walk_idling'] == 1 and own['sit'] == 0:
+        walk_idle_frame = own['walk_idle_frame']
+        mod_num = (own["framenum"] - walk_idle_frame) % 240
+        idle_lay = 300
+        if mod_num == 0:
+            if own['idle_skipper'] > 0:
+               own['idle_skipper'] -= 1 
+            ran_num = random.randint(1, 8)
+            if own['last_idle_num'] == ran_num:
+                ran_num = 1
+            if own['idle_skipper'] == 0:
+                own['last_idle_num'] = ran_num
+                if ran_num == 1 or ran_num > 7:    
+                    killact(3)
+                    if STANCE == 0 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'reg_idle1'
+                    elif STANCE == 0 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'reg_idle1'
+                    elif STANCE == 1 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'fak_idle1'
+                    elif STANCE == 1 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'fak_idle1'
+                                                                           
+                elif ran_num == 2:    
+                    killact(3)
+                    if STANCE == 0 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'reg_idle2'
+                    elif STANCE == 0 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'reg_idle2_nb'
+                    elif STANCE == 1 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'fak_idle1'
+                    elif STANCE == 1 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'fak_idle1'
+                elif ran_num == 3:    
+                    killact(3)
+                    if STANCE == 0 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'reg_idle3'
+                    elif STANCE == 0 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'reg_idle3'
+                    elif STANCE == 1 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'fak_idle1'
+                    elif STANCE == 1 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'fak_idle1'
+                    own['idle_skipper'] = 2 
+                elif ran_num == 4:    
+                    killact(3)
+                    if STANCE == 0 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'reg_idle4'
+                    elif STANCE == 0 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'reg_idle4'
+                    elif STANCE == 1 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'fak_idle4'
+                    elif STANCE == 1 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'fak_idle4' 
+                elif ran_num == 5:    
+                    killact(3)
+                    if STANCE == 0 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'reg_idle5'
+                    elif STANCE == 0 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'reg_idle5'
+                    elif STANCE == 1 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'fak_idle5'
+                    elif STANCE == 1 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'fak_idle5'
+                elif ran_num == 6:    
+                    killact(3)
+                    if STANCE == 0 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'reg_idle6'
+                    elif STANCE == 0 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'reg_idle6'
+                    elif STANCE == 1 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'fak_idle6'
+                    elif STANCE == 1 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'fak_idle6'
+                elif ran_num == 7:    
+                    killact(3)
+                    if STANCE == 0 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'reg_idle7'
+                    elif STANCE == 0 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'reg_idle7'
+                    elif STANCE == 1 and own['throw_deck'] == 0:
+                        own['requestAction'] = 'fak_idle6'
+                    elif STANCE == 1 and own['throw_deck'] == 1:
+                        own['requestAction'] = 'fak_idle6'
+
+def reset_pos():
+    #reset
+    if ddPad == 1:   
+        spawn_pos = own['spawn_pos']
+        spawn_rot = own['spawn_rot']
+        spawn_cam_pos = own['spawn_cam_pos']
+        spawn_cam_rot = own['spawn_cam_rot']            
+        try:
+            own.worldPosition = (spawn_pos[0], spawn_pos[1], (spawn_pos[2] + .1))
+            own.worldOrientation = [[spawn_rot[0][0],spawn_rot[0][1],spawn_rot[0][2]], [spawn_rot[1][0],spawn_rot[1][1],spawn_rot[1][2]], [0.0, 0.0, 1.0]]
+            cam.worldPosition = (spawn_cam_pos[0], spawn_cam_pos[1], (spawn_cam_pos[2]))
+            cam.worldOrientation = [[spawn_cam_rot[0][0],spawn_cam_rot[0][1],spawn_cam_rot[0][2]], [spawn_cam_rot[1][0],spawn_cam_rot[1][1],spawn_cam_rot[1][2]], [0.0, 0.0, 1.0]]            
+        except:    
+            own.worldPosition = (0, 0, .1)
+            own.worldOrientation = [[1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0], [0.0, 0.0, 1.0]] 
+        own['stance'] = own['spawn_stance']                          
+        if own["spawn_stance"] == 1:
+            own.setLinearVelocity([.1,0,0], 1)
+        else: 
+            own.setLinearVelocity([-.1,0,0], 1)         
+            
+    if udPad == 1:        
+        own['spawn_pos'] = [own.worldPosition[0], own.worldPosition[1], own.worldPosition[2]] 
+        own['spawn_rot'] = [[own.worldOrientation[0][0],own.worldOrientation[0][1],own.worldOrientation[0][2]], [own.worldOrientation[1][0],own.worldOrientation[1][1],own.worldOrientation[1][2]], own.worldOrientation[2][2]]
+        own['spawn_cam_pos'] = [cam.worldPosition[0], cam.worldPosition[1], cam.worldPosition[2]] 
+        own['spawn_cam_rot'] = [[cam.worldOrientation[0][0],cam.worldOrientation[0][1],cam.worldOrientation[0][2]], [cam.worldOrientation[1][0],cam.worldOrientation[1][1],cam.worldOrientation[1][2]], cam.worldOrientation[2][2]]            
+        stance = own["stance"]
+        own["spawn_stance"] = stance   
+def falldeck():
+    throw_deck_empty = scene.objects["throw_deck_empty"]
+    deckact = deck.actuators["Visibility"]
+    trucksact = trucks.actuators["Visibility"]
+    wheel1act = wheel1.actuators["Visibility"]
+    wheel2act = wheel2.actuators["Visibility"]
+    wheel3act = wheel3.actuators["Visibility"]
+    wheel4act = wheel4.actuators["Visibility"]
+            
+    if own['throw_deck'] == False:
+        own['throw_deck'] = True
+        deckact.visibility = False
+        trucksact.visibility = False
+        wheel1act.visibility = False
+        wheel2act.visibility = False
+        wheel3act.visibility = False
+        wheel4act.visibility = False
+        act = throw_deck_empty.actuators['throw_dec_act']
+        if STANCE == True:
+            act.linearVelocity = [0.0, 1.0, 1.0]
+        if STANCE == False:
+            act.linearVelocity = [0.0, 1.0, -1.0]  
+        cont.activate(act)
+    else:
+        own['throw_deck'] = False    
+        deckact.visibility = True
+        trucksact.visibility = True
+        wheel1act.visibility = True
+        wheel2act.visibility = True
+        wheel3act.visibility = True
+        wheel4act.visibility = True
+        throw_deck_empty['kill_deck'] = 1    
+    cont.activate(deck.actuators['Visibility'])
+    cont.activate(trucks.actuators['Visibility'])
+    cont.activate(wheel1.actuators['Visibility'])
+    cont.activate(wheel2.actuators['Visibility'])
+    cont.activate(wheel3.actuators['Visibility'])
+    cont.activate(wheel4.actuators['Visibility']) 
+
+def throwdeck(strength, ud):
+    throw_deck_empty = scene.objects["throw_deck_empty"]
+    deckact = deck.actuators["Visibility"]
+    trucksact = trucks.actuators["Visibility"]
+    wheel1act = wheel1.actuators["Visibility"]
+    wheel2act = wheel2.actuators["Visibility"]
+    wheel3act = wheel3.actuators["Visibility"]
+    wheel4act = wheel4.actuators["Visibility"]
+            
+    if own['throw_deck'] == False:
+        own['throw_deck'] = True
+        deckact.visibility = False
+        trucksact.visibility = False
+        wheel1act.visibility = False
+        wheel2act.visibility = False
+        wheel3act.visibility = False
+        wheel4act.visibility = False
+        act = throw_deck_empty.actuators['throw_dec_act']
+        hard = strength * .08
+        if hard > 9:
+            hard = 9
+        if hard < 1:
+            hard = 1    
+        ud = ud * 4
+        own['bbut_timer'] = 0
+        if STANCE == True:
+            own['requestAction'] = 'fak_throw'
+            act.linearVelocity = [0.0, ud, hard]
+        if STANCE == False:
+            own['requestAction'] = 'fak_throw'
+            act.linearVelocity = [0.0, ud, -hard]  
+        cont.activate(act)
+    else:
+        own['throw_deck'] = False    
+        deckact.visibility = True
+        trucksact.visibility = True
+        wheel1act.visibility = True
+        wheel2act.visibility = True
+        wheel3act.visibility = True
+        wheel4act.visibility = True
+        throw_deck_empty['kill_deck'] = 1     
+    cont.activate(deck.actuators['Visibility'])
+    cont.activate(trucks.actuators['Visibility'])
+    cont.activate(wheel1.actuators['Visibility'])
+    cont.activate(wheel2.actuators['Visibility'])
+    cont.activate(wheel3.actuators['Visibility'])
+    cont.activate(wheel4.actuators['Visibility'])            
+def throwdeck_trigger():
+    lastb = own['lastb']
+    throw_deck_empty = scene.objects["throw_deck_empty"]
+    if bBut == True:
+        own['bbut_timer'] += 1
+        ud = (rUD * 10) +1
+    if bBut == False:
+        throw_deck_empty['kill_deck'] = 0
+    if bBut == False and own['lastb'] == True:        
+        strength = own['bbut_timer']
+        ud = (rUD * 10) +1
+        throwdeck(strength, ud)   
+        
+def focus_deck():
+    since_air = own['framenum'] - own['lF_air_frame']
+    if cb_td.positive and since_air < 10:
+        object = 'focus_deckA'
+        object2 = 'focus_deckB'            
+        other = throw_deck_empty
+        throw_deck = scene.objects["throw_deck"]
+        throw_deck.endObject()
+        scene.addObject(object, other, 0)          
+        scene.addObject(object2, other, 0)
+                
+    if own['throw_deck'] == True:
+        if dict['ldPad'] == False and dict['last_ldPad'] == True: 
+            object = 'focus_deckA'
+            object2 = 'focus_deckB'            
+            other = throw_deck_empty
+            scene.addObject(object, other, 0)          
+            scene.addObject(object2, other, 0)          
+              
+def fall():
+    if own['fall'] == True:
+        falldeck()        
+        if STANCE == 1:
+            own['requestAction'] = 'fak_air-walk_air'            
+            own.setLinearVelocity([3,2,0], True)
+        else:
+            own['requestAction'] = 'reg_air-walk_air'
+            own.setLinearVelocity([-3,-2,0], True)    
+        own['fall'] = False
+
+def sit():
+    #turn off sit
+    if lup == 1 or ldown == 1 or lUD > sens or lUD < -sens:
+        if own['sit'] == 1:
+            killact(300)
+            killact(299)
+        own['sit'] = 0
+
+    if aBut == False and lasta == True:
+        try:
+            if 'sit' in r_ground.hitObject:
+                #print("sit")
+                own['sit'] = 1
+                killact(3)
+                if STANCE == 0:
+                    own['requestAction'] = 'reg_sit'
+                elif STANCE == 1:
+                    own['requestAction'] = 'fak_sit'                                        
+        except:
+            pass    
+    if own['sit'] == 1:
+        try:
+            killact(3)
+            sit_vect = r_ground.hitObject.getAxisVect( [0, 1, 0])
+            if STANCE == 0:
+                own.alignAxisToVect(-sit_vect, 0, .2)
+                own['requestAction'] = 'reg_sit'                               
+                
+            elif STANCE == 1:
+                own['requestAction'] = 'fak_sit'
+                own.alignAxisToVect(sit_vect, 0, .2)                    
+        except:
+            pass    
+                      
+def switchcam():
+    if ltsBut == False and own['lastlts'] == True and rtsBut == False:
+        if own['camera'] == 1:
+            own['camera'] = 0
+        else:
+            own['camera'] = 1
+    if rtsBut == False and own['lastrts'] == True and ltsBut == False:
+        if own['camera'] == 2:
+            own['camera'] = 0
+        else:
+            own['camera'] = 2 
+#followcam 
+def move_followcam():
+    if own['camera'] == 2:
+        if own['lastbkBut'] == True and bkBut == False:
+            #print("activate move followcam") 
+            if own['move_followcam'] == False:
+                own['move_followcam'] = True
+            else:
+                own['move_followcam'] = False                       
+        if own['move_followcam'] == True:
+            camspeed1 = .015
+            camspeed2 = .055
+            camrot1 = .005
+            camrot2 = .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"])
+            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"])
+            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"])                       
+def move_flycam():
+    if own['camera'] == 1:
+        if own['lastbkBut'] == True and bkBut == False: 
+            if own['move_freecam'] == False:
+                own['move_freecam'] = True
+            else:
+                own['move_freecam'] = False                       
+        if own['move_freecam'] == True:
+            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"])
+            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 r_ground.triggered == False:
+    cont.deactivate(own.actuators["walk_align"])
+else:
+    cont.activate(own.actuators["walk_align"])                    
+
+#walking on stairs
+if r_ground.triggered:
+    try:
+        if 'stair' in r_ground.hitObject:
+            own['stair_counter'] = 20
+            
+    except:
+        pass        
+    if own['stair_counter'] > 0:
+        own.linearVelocity.z += .1
+        own['stair_counter'] -= 1     
+
+if yBut == True:
+    own['walk_idling'] = 0
+    own["walk_idle_frame"] = 0
+
+
+
+if own['stair_counter'] > 5 and r_ground.triggered == False:
+    own.applyForce([0,0,-200], True)                          
+   
+if deck.visible:
+    own['deckvis'] = 1
+else:
+    own['deckvis'] = 0       
+
+if own['requestAction'] == 'empty' or own['requestAction'] == None:
+    if STANCE == 0:
+        own['requestAction'] = 'reg_idle1'
+    if STANCE == 1:
+        own['requestAction'] = 'fak_idle1'        
+    
+def onground():
+    if r_ground.positive:
+        own['lF_ground_frame'] = own['framenum']
+        if 'grind' in r_ground.hitObject:
+            if own['framenum'] - own['last_fall_frame'] < 90:
+                own.applyForce([0,100,0], True)
+                #print('moving away from rail')
+                
+        yvel = own.linearVelocity.y
+        yvel = yvel *.1
+        if own.linearVelocity.y > .01 or own.linearVelocity.y < -.01 and own['stair_counter'] == 0:
+            if STANCE == 0:
+                own.applyRotation([0,0,-yvel], True) 
+            else:
+                own.applyRotation([0,0,yvel], True) 
+        else:
+            own.linearVelocity.y = 0                           
+
+    else:
+        #print('in air')            
+        if  own['framenum'] - own['lF_ground_frame'] > 10:
+            if STANCE == 0:            
+                own['requestAction'] = 'reg_walk_air'
+            else:
+                own['requestAction'] = 'fak_walk_air' 
+    #if control bottom is touching ground object, turn ground on            
+    if cb.positive:
+        if own['framenum'] - own['last_fall_frame'] < 90:
+            own['lF_ground_frame'] = own['framenum']
+            
+            
+
+def get_in_car():
+    vehicleNear = cont.sensors["vehicleNear"]
+    #print('vh', vehicleNear.positive)
+    scene = bge.logic.getCurrentScene()
+    cam = scene.active_camera
+    #dict = bge.logic.globalDict 
+    if vehicleNear.positive and 'car' in vehicleNear.hitObject:
+        obj = vehicleNear.hitObject
+        if yBut == True:
+            obj['driving'] = True
+            own['driving'] = True
+            cube.suspendDynamics(True)
+            cube.worldPosition = obj.worldPosition
+            cube.worldOrientation = obj.worldOrientation
+            rot = [ 0.0, 0.0, 1.570796327]
+            cube.applyRotation(rot,False)            
+            compound = False
+
+            # child is solid
+            ghost = True
+
+            # set parent
+            cube.setParent( obj, compound, ghost)            
+            
+            
+
+            #cam.target = obj
+            #cam.state = 2
+            cont.actuators['Camera'].object = obj
+            cont.actuators['Camera'].height = 3
+            cont.actuators['Camera'].min = 6
+            cont.actuators['Camera'].max = 10
+            own.state = 2
+        #print('near car')
+        
+    if dict['last_driving'] == True:
+        cont.actuators['Camera'].object = scene.objects['camCube']    
+        cont.activate(cont.actuators['walk'])               
+    if own['driving'] == False:  
+        #cont.actuators['Camera'].object = scene.objects['camCube'] 
+        #cont.activate(cont.actuators['walk']) 
+        dict['last_driving'] = False
+        
+def get_on_bike(dict, own):
+    #bikeCol = cont.sensors['bikeCol']
+    vehicleNear = cont.sensors["vehicleNear"]
+    #print('vh', vehicleNear.positive)
+    scene = bge.logic.getCurrentScene()
+    #cam = scene.active_camera
+    #dict = bge.logic.globalDict 
+    try:
+        if vehicleNear.positive and 'bike' in vehicleNear.hitObject:          
+            if yBut == True and dict['last_yBut'] == False and own['throw_deck'] == True:
+                vehicleNear.hitObject.endObject()
+                dict['bike'] = True 
+                cont.activate(own.actuators['bike_state']) 
+
+                object = "player_bike"
+                # instantly add bullet
+                newbike = scene.addObject(object, own, 0)
+                #bike.localScale = 4.6            
+                newbike.setParent(cube, False, False)
+                #rot = [ 0.0, 0.0, 1.570796327]
+                #bike.applyRotation(rot,False) 
+    except:
+        pass            
+                                              
+if dict['driving_reset'] == True:
+    scene.resume()
+    cube.suspendDynamics(False)
+    cont.actuators['Camera'].object = camobj2
+    cont.activate(own.actuators['walk'])
+    #dict['driving_reset'] = False
+    #print('reseting driving')   
+if own['walk_jump_timer'] != 0:
+    own['walk_jump_timer'] = own['walk_jump_timer'] - 1    
+wts = own['walk_targ_speed'] +1                 
+if own['requestAction'] == 'reg_walkFast' and own.linearVelocity.x > (wts * -1):
+    own['requestAction'] = 'reg_walk' 
+if own['requestAction'] == 'fak_walkFast' and own.linearVelocity.x < wts:
+    own['requestAction'] = 'fak_walk' 
+if own['requestAction'] == 'reg_walkFast_nb' and own.linearVelocity.x > (wts * -1):
+    own['requestAction'] = 'reg_walk_nb' 
+if own['requestAction'] == 'fak_walkFast_nb' and own.linearVelocity.x < wts:
+    own['requestAction'] = 'fak_walk_nb'                         
+onboard() 
+jump()
+dropin()
+throwdeck_trigger()
+
+nextframe()
+checkidle()
+getonboard(dict)
+reset_pos()
+switchcam()
+move_flycam()
+move_followcam()
+fall()
+idle_anim()
+sit()
+onground()
+focus_deck()
+get_in_car()
+get_on_bike(dict, own)
+
+#printplaying() 
+
+own.alignAxisToVect([0.0,0.0,1.0], 2, .03)
+own.actuators["sroll"].stopSound() 
+wheel1 = scene.objects["rollen.000"]
+wheel2 = scene.objects["rollen.001"]
+wheel3 = scene.objects["rollen.002"]
+wheel4 = scene.objects["rollen.003"]
+wheel1.stopAction(2)
+wheel2.stopAction(2)
+wheel3.stopAction(2)
+wheel4.stopAction(2)
+own['lasty'] = yBut
+own['lastb'] = bBut  
+own['lasta'] = aBut
+own['lastx'] = xBut   
+own['lastlts'] = ltsBut
+own['lastrts'] = rtsBut        
+own['lastbkBut'] = bkBut
+own['dropinCol'] = dropinCol
+own['walk'] = 1
+dict['walk'] = 1
+