Merge branch 'configobj_config_file' of shuvit/shuvit into dev

Settings.py

-#from bge import logic
+import bge
 import GameLogic
-#from os.path import dirname, realpath, join
+import configobj
+from configobj import ConfigObj
 
-#BASE_DIR = os.path.join( os.path.dirname( __file__ ), '..' )
 mainDir = GameLogic.expandPath("//")
 
-fileName = mainDir + "Settings.dat"
-resx = 1280
-resy = 720
+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():
-    import GameLogic
-    import bge
-    cont = GameLogic.getCurrentController()
-    own = cont.owner
-    scenes = bge.logic.getSceneList()
-    main_scene = [scene for scene in scenes if scene.name=="main"][0]
-    own = main_scene.objects['Empty']
-    
-    with open(fileName) as reading:
-        #data = [line.split()[0] for line in reading]
-        data = reading.readlines()
-        #print lines[25]
-        #print lines[29]
-        reading.close()
+    config.walk(to_dict)     
 
-    #own["val"] = int(data[1])
-    #own["bright"] = int(data[1])
-    own["playerName"] = data[4]
-    #own["audio"] = int(data[3])
-    own["level"] = data[5]
-    #data6 = data[6]
-    #data6.split(None, 1)[0]
-    #data5 = data5.strip('\n')
-    #print(data6)
-    own["resx"] = int(data[7])
-    own["resy"] = int(data[8])
-    own["framerate"] = int(data[10])
-    own["profile"] = int(data[12])
-    dict = bge.logic.globalDict #Get the global dictionary
-    
-    dict['resx'] = own["resx"]
-    dict['resy'] = own["resy"]   
-    level = data[5]
-    level = level.split(None, 1)[0]
-    level = str(level)
-    own["level"] = level
-    dict["level"] = level
-    print("reading. settings")
-    print("Level: ", level)
-    recorder_on = int(data[14])
-    print("Game play recorder on: ", recorder_on) 
-    #dict = bge.logic.globalDict
-    dict['recorder_on'] = recorder_on
-    own['recorder_on'] = recorder_on
-    dict['recorder_on'] = recorder_on 
-    character = data[1]
-    dict["character"] = str(character.split(None, 1)[0])
-    dict["shirt_color_r"] = float(data[16])
-    dict["shirt_color_g"] = float(data[17])
-    dict["shirt_color_b"] = float(data[18])
-    dict["shoe_color_r"] = float(data[20])
-    dict["shoe_color_g"] = float(data[21])
-    dict["shoe_color_b"] = float(data[22]) 
-    dict["deck_color_r"] = float(data[24])
-    dict["deck_color_g"] = float(data[25])
-    dict["deck_color_b"] = float(data[26]) 
-    dict["shirt_logo"] = int(data[28])  
-    dict["bc"] = int(data[30])
-    dict["BC_BRIGHTNESS"] = float(data[31])
-    dict["BC_CONTRAST"] = float(data[32])  
-    dict['hdr'] = int(data[34])
-    dict['avgL'] = float(data[35])
-    dict['HDRamount'] = float(data[36])
-    dict['ao'] = int(data[38])
-    dict['onlyAO'] = int(data[39])
-    dict['aowidth'] = float(data[40])
-    dict['aoradius'] = float(data[41])
-    dict['dof_on'] = float(data[43])
-    dict['sun_strength'] = float(data[45])
-    dict['sun_rot_x'] = float(data[46])
-    dict['sun_rot_y'] = float(data[47])            
-    dict['shadow_on'] = int(data[48])
-    dict['ambient_strength'] = float(data[49]) 
-    dict['fullscreen_on'] = int(data[51]) 
-    dict['bloom_on'] = int(data[53]) 
-    dict['cam_height'] = float(data[55]) 
-    dict['focal_length'] = int(data[56])        
-    dict['cam_min'] = float(data[57])
-    dict['cam_max'] = float(data[58])
-    dict['music_player'] = int(data[60]) 
-    dict['fxaa'] = int(data[62]) 
-    dict['FXAA_SPAN_MAX'] = float(data[63])   
-    dict['cch_targetHeight'] = float(data[65])         
-    dict["trucks_r"] = float(data[67])
-    dict["trucks_g"] = float(data[68])
-    dict["trucks_b"] = float(data[69])
-    dict["wheel1_r"] = float(data[71])
-    dict["wheel1_g"] = float(data[72])
-    dict["wheel1_b"] = float(data[73])
-    dict["wheel2_r"] = float(data[75])
-    dict["wheel2_g"] = float(data[76])
-    dict["wheel2_b"] = float(data[77])
-    dict["wheel3_r"] = float(data[79])
-    dict["wheel3_g"] = float(data[80])
-    dict["wheel3_b"] = float(data[81])
-    dict["wheel4_r"] = float(data[83])
-    dict["wheel4_g"] = float(data[84])
-    dict["wheel4_b"] = float(data[85])  
-    dict["deck_index"] = int(data[87])                        
-    
-    #print('bc = ', dict['bc'])        
-    #dict['music_player_on'] = int(data[16])  
-def writeSettings():
-    import GameLogic
-    import bge
-    cont = GameLogic.getCurrentController()
-    own = cont.owner
-    scenes = bge.logic.getSceneList()
+def from_dict(section, key):
     dict = bge.logic.globalDict
-    main_scene = [scene for scene in scenes if scene.name=="main"][0]
-    own = main_scene.objects['Empty']
-    print("writing called")
-    with open(fileName, 'w') as writing:
-        writing.write(str("//settings.dat")+"\n")
-        writing.write(str(dict["character"])+"\n")
-        writing.write(str(own["bright"])+"\n")
-        writing.write(str("-\n"))
-        writing.write(str("//level (e.g. spine, city, city2)")+"\n")
-        writing.write(str(own["level"])+"\n")
-        writing.write(str("//resolution")+"\n")
-        writing.write(str(dict["resx"])+"\n")
-        writing.write(str(dict["resy"])+"\n")
-        writing.write(str("//show framerate")+"\n")
-        writing.write(str(own["framerate"])+"\n")
-        writing.write(str("//show profile")+"\n")
-        writing.write(str(own["profile"])+"\n")
-        writing.write(str("//Game play recorder off/on (0,1)")+"\n")
-        writing.write(str(own["recorder_on"])+"\n")
-        writing.write(str("//Shirt color [r,g,b]")+"\n")
-        writing.write(str(dict["shirt_color_r"])+"\n") #16
-        writing.write(str(dict["shirt_color_g"])+"\n")
-        writing.write(str(dict["shirt_color_b"])+"\n")    # 
-        writing.write(str("//Shoe color [r,g,b]")+"\n")
-        writing.write(str(dict["shoe_color_r"])+"\n") #16
-        writing.write(str(dict["shoe_color_g"])+"\n")
-        writing.write(str(dict["shoe_color_b"])+"\n")    # 
-        writing.write(str("//Deck color [r,g,b]")+"\n")
-        writing.write(str(dict["deck_color_r"])+"\n") #24
-        writing.write(str(dict["deck_color_g"])+"\n")
-        writing.write(str(dict["deck_color_b"])+"\n")    #                           
-        writing.write(str("//Shirt Logo")+"\n")
-        writing.write(str(dict["shirt_logo"])+"\n") #24
-        writing.write(str("//Brightness/Contrast: On, brightness, contrast")+"\n")
-        writing.write(str(dict["bc"])+"\n")
-        writing.write(str(dict["BC_BRIGHTNESS"])+"\n")
-        writing.write(str(dict["BC_CONTRAST"])+"\n")
-        writing.write(str("//HDR: On, avgL, amount")+"\n")
-        writing.write(str(dict["hdr"])+"\n")
-        writing.write(str(dict["avgL"])+"\n")
-        writing.write(str(dict["HDRamount"])+"\n") 
-        writing.write(str("//AO: On, only, width, radius")+"\n")
-        writing.write(str(dict["ao"])+"\n")
-        writing.write(str(dict["onlyAO"])+"\n")
-        writing.write(str(dict["aowidth"])+"\n")                
-        writing.write(str(dict["aoradius"])+"\n") 
-        writing.write(str("//dof on")+"\n")
-        writing.write(str(dict["dof_on"])+"\n") 
-        writing.write(str("//sun settings: strength, rotx, roty, shadow on, ambient strength")+"\n")
-        writing.write(str(dict["sun_strength"])+"\n")                           
-        writing.write(str(dict["sun_rot_x"])+"\n")                           
-        writing.write(str(dict["sun_rot_y"])+"\n")                           
-        writing.write(str(dict["shadow_on"])+"\n")                                     
-        writing.write(str(dict["ambient_strength"])+"\n") 
-        writing.write(str("//fullscreen on (0,1)")+"\n")
-        writing.write(str(dict["fullscreen_on"])+"\n") 
-        writing.write(str("//bloom on (0,1)")+"\n")
-        writing.write(str(dict["bloom_on"])+"\n")  
-        writing.write(str("//cam")+"\n")
-        writing.write(str(dict["cam_height"])+"\n") 
-        writing.write(str(dict["focal_length"])+"\n") 
-        writing.write(str(dict["cam_min"])+"\n")                 
-        writing.write(str(dict["cam_max"])+"\n") 
-        writing.write(str("//music player on / off")+"\n")
-        writing.write(str(dict["music_player"])+"\n")
-        writing.write(str("//fxaa")+"\n")
-        writing.write(str(dict["fxaa"])+"\n") 
-        writing.write(str(dict["FXAA_SPAN_MAX"])+"\n")    
-        writing.write(str("//camera target height")+"\n")
-        writing.write(str(dict["cch_targetHeight"] )+"\n")   
-        writing.write(str("//trucks color [r,g,b]")+"\n")
-        writing.write(str(dict["trucks_r"])+"\n")
-        writing.write(str(dict["trucks_g"])+"\n")
-        writing.write(str(dict["trucks_b"])+"\n") 
-        writing.write(str("//wheel1 color [r,g,b]")+"\n")
-        writing.write(str(dict["wheel1_r"])+"\n")
-        writing.write(str(dict["wheel1_g"])+"\n")
-        writing.write(str(dict["wheel1_b"])+"\n") 
-        writing.write(str("//wheel2 color [r,g,b]")+"\n")
-        writing.write(str(dict["wheel2_r"])+"\n")
-        writing.write(str(dict["wheel2_g"])+"\n")
-        writing.write(str(dict["wheel2_b"])+"\n") 
-        writing.write(str("//wheel3 color [r,g,b]")+"\n")
-        writing.write(str(dict["wheel3_r"])+"\n")
-        writing.write(str(dict["wheel3_g"])+"\n")
-        writing.write(str(dict["wheel3_b"])+"\n") 
-        writing.write(str("//wheel4 color [r,g,b]")+"\n")
-        writing.write(str(dict["wheel4_r"])+"\n")
-        writing.write(str(dict["wheel4_g"])+"\n")
-        writing.write(str(dict["wheel4_b"])+"\n")                                          
-        writing.write(str("//deck index")+"\n")
-        writing.write(str(dict["deck_index"])+"\n")        
-        
-        #dict['ccH_targetHeight']     
-        
-        #writing.write(str(own["framerate"])+"\n")
-        print("writing settings")
-        writing.close()
-       
-       
+    config[key] = dict[key]
+
+def writeSettings():
+    config.walk(from_dict)  
+    config.write()    
+          
 def setres():
     import GameLogic
     import bge
     cont = GameLogic.getCurrentController()
     own2 = cont.owner
     dict = bge.logic.globalDict 
-    resx = dict["resx"]
-    resy = dict["resy"]
+    resx = int(dict["resx"])
+    resy = int(dict["resy"])
     fullscreen = bge.render.getFullScreen()
     print("fullscreen = ", fullscreen)
     if fullscreen != True:
     own = main_scene.objects['Empty']
     cont = GameLogic.getCurrentController()
     own2 = cont.owner
-    #readSettings()
 
     dict = bge.logic.globalDict #Get the global dictionary
     
-#    resx = dict["resx"]
-#    resy = dict["resy"]
-#    #dict['resx'] = resx
-#    #dict['resy'] = resy
-#    
-#    fullscreen = bge.render.getFullScreen()
-#    print("fullscreen = ", fullscreen)
-#    if fullscreen != True:
-#        if dict['fullscreen_on'] == 1:
-#            bge.render.setFullScreen(True)
-#    if fullscreen == True:
-#        if dict['fullscreen_on'] == 0:
-#            bge.render.setFullScreen(False) 
-#            
-#    bge.render.setWindowSize(resx, resy)         
-#    print("resolution = ", resx, resy)
-    #objList = scene.objects
     if own["framerate"] == 1:    
         bge.render.showFramerate(1)
     if own["profile"] ==1:    
         bge.render.showProfile(1)   
-    #cont = GameLogic.getCurrentController() 
-    #own = cont.owner
-    #cont = own2.controllers['loadLevel']
     act = own2.actuators["level"]
-    #cont.activate(own.actuators["loading"]) 
-    #level = own["level"]
-    
     dict = bge.logic.globalDict
     level = dict['level']
-    #dict['level'] = level
+    print('loading level', level)
     act.scene = level 
     cont.activate(own2.actuators["level"]) 
-    #cont.activate(own2.actuators["stance"])
     dict['npause'] = False 
     
 def timer():
     dict = bge.logic.globalDict    
     
     if dict['reload_timer'] == 1:
-        #restart
-        # get current scene
         scene = bge.logic.getCurrentScene()
-
-        # restart the current scene
-        #scene.restart()        
             
     if dict['reload_timer'] > 0:
        dict['reload_timer'] -= 1         
-    #print(dict['reload_timer'])
-    #own['reload_timer'] = dict['reload_timer']   

Startup.py

     dict['spawned_npc_decks'] = []
     dict['spawned_npc_trucks'] = []    
     dict['spawned_npcs'] = []
-    dict['JUMPHEIGHT'] = 800
-    dict['MAX_VEL'] = 6.7
+    #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()

Test/Music/Test.txt

-Hello, friend

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()

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

controller2.py

 
     #setable
     MAX_VEL = dict['MAX_VEL']
-    SPEEDUP = .055
-    SPEEDPUMP = .14 #.09
-    SPEEDPUMPFAST = .16 #.13
-    PUMP_SPEED_SENS = .4
-    PUMP_SENS = .98
-    ACCEL = 10
-    CRUISE = 9
-    COUNTDOWN = 20 #pump and speed stuff
+    SPEEDUP = dict['SPEEDUP']
+    SPEEDPUMP = dict['SPEEDPUMP']
+    SPEEDPUMPFAST = dict['SPEEDPUMPFAST']
+    PUMP_SPEED_SENS = dict['PUMP_SPEED_SENS']
+    PUMP_SENS = dict['PUMP_SENS']
+    ACCEL = dict['ACCEL']
+    CRUISE = dict['CRUISE']
+    COUNTDOWN = dict['COUNTDOWN'] #pump and speed stuff
     JUMPHEIGHT = dict['JUMPHEIGHT'] #775#750
     JUMPSTRENGTH = 0
     own['flip_manual_stance'] = 0
     #check manual
     ####
     #reg
-    if rUD > dict['man_sens_l'] and rUD < dict['man_sens_r'] and STANCE == 0 and rLR < .035 and rLR > -.035:
+    if rUD > dict['man_sens_l'] and rUD < dict['man_sens_r'] and STANCE == 0 and rLR < dict['man_sens_side'] and rLR > -dict['man_sens_side']:
         timer = own["reg_manual_timer"]
         timer = timer + 1
         own["reg_manual_timer"] = timer
           
     ####   
     #fak
-    if rUD > dict['man_sens_l'] and rUD < dict['man_sens_r'] and STANCE == 1 and rLR < .035 and rLR > -.035:
+    if rUD > dict['man_sens_l'] and rUD < dict['man_sens_r'] and STANCE == 1 and rLR < dict['man_sens_side'] and rLR > -dict['man_sens_side']:
         timer = own["fak_manual_timer"]
         timer = timer + 1
         own["fak_manual_timer"] = timer
      
     #####
     #reg nmanual
-    if rUD < -dict['man_sens_l'] and rUD > -dict['man_sens_r'] and STANCE == 0 and rLR < .035 and rLR > -.035:
+    if rUD < -dict['man_sens_l'] and rUD > -dict['man_sens_r'] and STANCE == 0 and rLR < dict['man_sens_side'] and rLR > -dict['man_sens_side']:
         timer = own["reg_nmanual_timer"]
         timer = timer + 1
         own["reg_nmanual_timer"] = timer
     #####
     #fak nmanual
     #print (rUD)
-    if rUD < -dict['man_sens_l'] and rUD > -dict['man_sens_r'] and STANCE == 1 and rLR < .035 and rLR > -.035:
+    if rUD < -dict['man_sens_l'] and rUD > -dict['man_sens_r'] and STANCE == 1 and rLR < dict['man_sens_side'] and rLR > -dict['man_sens_side']:
         timer = own["fak_nmanual_timer"]
         timer = timer + 1
         own["fak_nmanual_timer"] = timer
         velocity = own['velocity']
         #switch
         local = True
-        downforce = -.1        
+        downforce = dict['pump_downforce']       
         lF_air_frame = own['lF_air_frame']
         frames_since_ground = own['framenum'] - own['lF_air_frame']     
         if linVelocity.x < MAX_VEL and linVelocity.x >= -0 and STANCE == 1 and grindHit == False and frames_since_ground > 30 and own['last_manual_v2'] == 0:            
             distance = own.getDistanceTo(gray.hitPosition)
             since_grind_buf = 3
             if gray.hitObject != None and grindDar2.triggered == False and (frame - lgf) > since_grind_buf:
+                #add or colliding
                 if distance < .5:  
                     own.alignAxisToVect(gray.hitNormal, 2, .1)
                 elif distance >= .5 and distance < 1.75:  
         speed = 20
         
     def turn():   
-        rotamt = .02
+        #rotamt = .02
+        rotamt = dict['turn_rotation']
         linVelocity2 = own.getLinearVelocity(True)
-        speed = .004
+        #speed = .004
+        speed = dict['turn_addx']
         manual = 0
         if own['manual_v2'] == 1:     
             manual = 1       
             if abs(linVelocity.x) < 2:
-                speed = .005
+                speed = dict['turn_addx'] + .001
                 
         jumpstance = own['jump_stance']
         if lLR > turnsens or lLR < -turnsens:
                 if STANCE == 1:   
                     own.setLinearVelocity([linVelocity2.x + speed, linVelocity2.y, linVelocity2.z], 1)        
              
-    #air
+    #air   
         if r_ground.triggered == False and (lLR > turnsens or dict['kb_ra'] == 2) and (grindHit == False or (manual == 1 and grindHit == True)) and own["wallride"] == None:
-            rotamt = .07
             if STANCE == 0:
-                own.applyRotation([0,0,-rotamt], 1)
+                own.applyRotation([0,0,-dict['turn_air_rotation']], 1)
             if STANCE == 1:
-                own.applyRotation([0,0,-rotamt], 1) 
+                own.applyRotation([0,0,-dict['turn_air_rotation']], 1) 
         if r_ground.triggered == False and (lLR < -turnsens or dict['kb_la'] == 2) and (grindHit == False or (manual == 1 and grindHit == True)) and own["wallride"] == None:
-            rotamt = .07
             if STANCE == 0:
-                own.applyRotation([0,0,rotamt], 1)
+                own.applyRotation([0,0,dict['turn_air_rotation']], 1)
             if STANCE == 1:
-                own.applyRotation([0,0,rotamt], 1)                      
+                own.applyRotation([0,0,dict['turn_air_rotation']], 1)                      
 
     ###########
     def grindsound():
         try:
             if 'grass' in r_ground.hitObject:
                 linVel = own.getLinearVelocity(True)
-                linvelx = linVel.x * .98
+                linvelx = linVel.x * dict['grass_mult']
                 own.setLinearVelocity((linvelx, linVel.y, linVel.z), 1)
         except:
             pass    
         lgf = own['last_grind_frame']
         frame = own['framenum']
         frames_since_grinding = frame - lgf
-        ylimit = .84
+        #ylimit = .84
+        ylimit = dict['ylimit']
         #print(ground_since, 'ground_since')
         if ground_since < 20 and ground_since > 1 and grindHit == 0 and own['jump_timer'] < 40:
             ylimit = ylimit + ((ground_since - 15) * -.005)
         if grindHit == False:
             cont.deactivate(own.actuators['grindoutRight'])
             cont.deactivate(own.actuators['grindoutLeft'])  
-        if (grindHit == True and jumping == None and sincegrinding > 20 and ground_since > 20)or own['invert_on'] == True and own['last_grind'] == 1:
+        if (LAST_GRIND == True and jumping == None and sincegrinding > 20 and ground_since > 20) or own['invert_on'] == True and LAST_GRIND == 1:
             outloc = 0.022
             bsoutloc = .07
             bsoutvel = .1
     own["sel"] = bkBut  
 
     if r_ground.triggered and own["jump_timer"] < 20:
-        force2 = [0.0, 0, -10]
+        force2 = [0.0, 0, dict['antibounce']]
         own.applyForce(force2, True)
     if (grindDar == False and r_ground.triggered and own['grindTouch'] == False) or own['jump_timer'] > 40:
         own['grindType'] = ''

load_char.py

     fileName = mainDir + "characters/" + str(dict["character"]) + '.blend'    
     
     path = bge.logic.expandPath(fileName)
-    bge.logic.LibLoad(path, 'Scene')  
+    try:
+        bge.logic.LibLoad(path, 'Scene')  
+    except:
+        pass    
     
     fileName = mainDir + "assets/" + 'bmx_player' + '.blend'    
     

menuV3.py

         if motion == 'inc':
             level = "pats"
             main_empty["level"] = "pats"
-            own["level"] = level
+            dict['level'] = level
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "j_scene"
             main_empty["level"] = "j_scene"
-            own["level"] = level
+            dict['level'] = level
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "lot"
             main_empty["level"] = "lot"
-            own["level"] = level
+            dict['level'] = level
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "train"
             main_empty["level"] = "train"
-            own["level"] = level
+            dict['level'] = level
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "spine"
             main_empty["level"] = "spine"
-            own["level"] = level
+            dict['level'] = level
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "warehouse"
             main_empty["level"] = "warehouse"
-            own["level"] = level
+            dict['level'] = level
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "shop"
             main_empty["level"] = "shop"
-            own["level"] = level
+            dict['level'] = level
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
             
     if funct == 'SC':
         if motion == 'inc':
-            level = "SC"
-            main_empty["level"] = "SC"
-            own["level"] = level
+            level = "sc"
+            main_empty["level"] = "sc"
+            dict['level'] = level
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "user1"
             main_empty["level"] = "user1"
-            own["level"] = level
+            dict['level'] = level
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "user2"
             main_empty["level"] = "user2"
-            own["level"] = level
+            dict['level'] = level
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 

npause.py

 
     cont = bge.logic.getCurrentController()
     scene = bge.logic.getCurrentScene()
-    #own = cont.owner
     dict = bge.logic.globalDict 
     
     skater = scene.objects["Char4"]
     freecam = camList["freecam"] 
     mcam = camList['Camera.003']   
     
-    #freecam = scene.objects['freecam']
     cube = scene.objects['control_cube.002']
     
     try:
         cont.activate(cont.actuators['empty'])
         if mcam['playback'] == False:
             cont.activate(cont.actuators['add_overlay']) 
-            #pass
-        #printplaying()
         cont.activate(cont.actuators['remove_stance'])  
         cube['camera'] = 2
         cube['camnum'] = 2 
         scene.active_camera = freecam 
-        #print('set freecam', scene.active_camera)
         freecam.lens = mcam['focal_length'] 
         freecam.worldPosition = mcam.worldPosition
         freecam.worldOrientation = mcam.worldOrientation                      
             if trucks.isPlayingAction(layer):    
                 trucks.stopAction(layer)
         menuV3.main(cont)                                                    
-        
-        
-        
+                
     #exit pause     
     if pause_state == 0 and last_pause == 1:
-        #print("unpause")
         Settings.writeSettings()
         own.restoreDynamics()
-        #own['camera'] = 0
-        #own.setlinearVelocity([0,0,0],1] 
-        
+
         if own['walk'] == False:
             cont.activate(cont.actuators['roll'])
         else:
             cont.activate(cont.actuators['walk'])    
-        #print("pre_pause_linvel = ", own['pre_pause_linvel'])
         try:
             own.setLinearVelocity(own['pre_pause_linvel'], 1) 
         except:
             cont.activate(cont.actuators['remove_overlay']) 
         else:
             cont.activate(cont.actuators['add_overlay'])                                   
-    #print(pause_state)
     dict['last_npause'] = pause_state
-    #print(scene.active_camera, cube['camera'])
-
     
 main()

scene_init.py

     # set parent
     obj.setParent( parent, compound, ghost)  
   
-    
+    scene.gravity = [0,0,dict['gravity']]    
     for i in scenes:
         if i.name == "main":
             main = i
 #    if dict['shadow_on'] == 1:
 #        bge.render.setGLSLMaterialSetting("shadows", 1) 
 #    else:
-#        bge.render.setGLSLMaterialSetting("shadows", 0)         
+#        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']   
     

walk.py

     own['walk_timer'] = own['walk_timer'] +1
 except:
     own['walk_timer'] = 1
+    own['walk_targ_speed'] = 2.0
 
 truckon = 450
 deckon = 460
 try:
     walk_inc = own['walk_inc'] 
 except:
-    own['walk_inc'] = .05
+    own['walk_inc'] = .01
     walk_inc = own['walk_inc']  
     own['walk_jump_timer'] = 0   
 if own['stair_counter'] != 0:
     cont.deactivate(camobj.actuators['camUp'])     
                 
 #----------------
-camera.height = .01 #.9
-camera.min = 1.75
-camera.max = 2.25
+#camera.height = .01 #.9
+#camera.min = 1.75
+#camera.max = 2.25
 lasty = own['lasty']     
 
 def onboard():
     if idle.positive:
         own["walk_idle_frame"] = 0
         cont.deactivate(camobj.actuators['idle_camRight'])  
-        camera.height = .5
+        #camera.height = .5
+        camera.height = dict['cam_idle_height']
     else: 
         if idle_frame == 0:
             own["walk_idle_frame"] = own["framenum"] 
         
         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
+            #camera.height = .9   
+            #camera.min = 2
+            #camera.max = 2.50
             own['walk_idling'] = 1
         else:
             own['walk_idling'] = 0