adding recorder scripts

Record.py

@@ -0,0 +1,610 @@
+#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"]
+
+
+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(3020):
+            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(3020):
+            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 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"]    
+    
+    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 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 != '':
+                    deck.playAction(deckanim, DAF,DAF, layer=9999, play_mode=1, speed=1)
+                    trucks.playAction(deckanim, 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:
+            try:
+                #cube = scene.objects[sound_empty]
+                spopsound = round(spopsound, 2)
+                act = cube.actuators["pop"]
+                if spopsound == 1:
+                    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.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"]
+                #slandsound = round(slandsound, 2)
+                if sdeckvis == 1:
+                    print('setting deck visible')
+                    #wheel1.visible = True
+                    #wheel2.visible = True
+                    #wheel3.visible = True
+                    #wheel4.visible = True 
+                    #deck.visible = True
+                    #trucks.setVisible(True, True)
+                    
+                    
+                    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'])                     
+                               
+                else:
+                    print('setting deck invisible')
+                    #wheel1.visible = False
+                    #wheel2.visible = False
+                    #wheel3.visible = False
+                    #wheel4.visible = False
+                    #deck.visible = False
+                    #trucks.setVisible(False, False)
+
+                    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'])                     
+
+
+
+            except:
+                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)                               
+            
+         
+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

SortData.py

@@ -0,0 +1,574 @@
+#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 = []
+
+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 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)]    
+        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                                        
+            
+        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()
+                            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()
+                            
+                            if printDebug:
+                                print("Read file "+allDataPath)
+                    except:
+                        print("error reading replay data")        
+            except IOError:
+                if printDebug:
+                    print("Error reading "+allDataPath)
+
+    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 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))