keyframes

assets/buildings.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:4a2bc3b1265e7a6e573e1110e56921040c3672af984b5e3737dc42a8a0839404
-size 4268444
+oid sha256:f43c0bb9a8c03f07c19800c8a2a4337b7467dc5c6832bdfe625f2b3d0980c667
+size 4289468

assets/custom_shaders/wind.py

 import os
 import sys
 
+#shader_components.Wind
+
 from bge import logic
 
 from . import custom_shader_base

assets/dlt2.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:64bd90e199281f5461377a895af35e925cf612adceade30bde988e6f3966a95d
+size 486512

assets/fire_hydrant.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:b29c1834f4e73e9d32ed16512376074342d98510aef1f70d4b28cd992604503a
+size 3282344

assets/ground_tiles.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:9a2e2a33d6ac41ce916e90fb32558ccd8731ba489fbdb8d09ca0d0451cca5914
-size 244357568
+oid sha256:ad004a37b47996e6a3066b47b79c3c9473034ba55c423262983a14c7876c16f0
+size 244779648

assets/grunge_wall.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:0a8de71602b83655a255c6f6bea738ff2e37c5606c4ebf5f3c796a291f602498
+oid sha256:01e157a384b4736e15868650e616754bf3aecd731bea49eaa8c890915d959658
 size 24078236

assets/kits/base_kit.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:6aa0a25cf625aaeeffa308ecaa3fa078f6922ac1dc19894c02738e3e03d97473
+size 4693592

assets/legde_b.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:87f103e80a463bea577381582e42fb64ae46ea45daf7b0c7d49215ec7351f3f5
+size 842508

assets/lot.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:73bd8bfdb24ae22fe73f84701d07b3ffb522ac70117fba245727ec5c2f70d196
-size 17534196
+oid sha256:17e1ac8fb2cd02856193b0653ff269dda7e7d5bdaefc9fbe20e1853703588861
+size 17609292

assets/lot2.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:024222c7bfdaa404c40fb5b94968dad5a1ccb8b2eaed03130597ae8f8f16ab4a
+size 17024612

assets/manny_pad.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:3e9ef93be5c934af075dea795f92295a13b0d12896a5fab1a8da9dfa747b3422
-size 16278492
+oid sha256:49fbd5d3312b9a6194e96a7f981e1af87e172b9cd3a63cb49bab27d7d3618c9e
+size 9898104

assets/materials/base_m_kit.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:da2b7a5bdd1d133e398ceb3abdfaeca7d98b3f1092ef55adf0589756a1528a5a
+size 18290540

assets/materials/builtins/skybox0/__init__.py

         self.sunx = 0.0
         self.suny = 0.0
         self.sunz = 0.0
+        self.luminance = 1.0 #1.180
+        
 
     def pre_draw(self, shader):
         dict = bge.logic.globalDict
         shader.setUniform1f('sunx', self.sunx)
         shader.setUniform1f('suny', self.suny)
         shader.setUniform1f('sunz', self.sunz)
+        shader.setUniform1f('luminance', self.luminance)
         #shader.setUniform1f('luminance', bge.logic.luminance)
         #shader.setUniform1f('bias', bge.logic.bias)
         #shader.setUniform1f('contrast', bge.logic.contrast)

assets/materials/builtins/skybox0/sky.fs

 
 varying vec4 fragPos; //fragment coordinates
 varying vec3 wT, wB, wN; //tangent binormal normal
-varying vec3 wPos, pos, viewPos, sunPos;
+//varying vec3 wPos, pos, viewPos, sunPos;
+varying vec3 wPos, pos, viewPos;
 uniform vec3 cameraPos;
 uniform float bias, lumamount, contrast;
-varying float luminance;
+//varying float luminance;
+
+uniform float luminance;
+
+uniform float sunx;
+uniform float suny;
+uniform float sunz;
+
+vec3 sunPos = vec3(sunx, suny, sunz);
+//vec3 sunPos = (sunx,suny,sunz);
 
 vec3 sunDirection = normalize(sunPos);
 
 float sunIntensity(float zenithAngleCos)
 {
 	return EE * max(0.0, 1.0 - exp(-((cutoffAngle - acos(zenithAngleCos))/steepness)));
+	//return (EE * max(0.0, 1.0 - exp(-((cutoffAngle - acos(zenithAngleCos))/steepness))))*.001;
+	//return 5;
 }
 
 float logLuminance(vec3 c)

assets/materials/builtins/skybox0/sky.vs

     viewPos = wPos - cameraPos.xyz;
     //sunPos = m3(ModelMatrix)*vec3(gl_ModelViewMatrixInverse*gl_LightSource[0].position);
     sunPos = vec3(sunx, suny, sunz);
+    //luminance = 10000.000003
     luminance = gl_Color.r;
     gl_Position = ftransform();
 }

assets/mini_island.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:9442ac2acf03e4a9d82759aaec72bb3eff2553bce69ef6aa7b17e0cf944f9063
-size 40017556
+oid sha256:c3d90c1a86a0e292498f14c8fc961b5df8fca946620afca9ca7f9a5b40470a9b
+size 39460788

assets/ppUrbanFoliage.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:926ecbe2278edcf6ed6d8eda2898a2e21a93098a7d43506801831c942b14ccea
-size 43058620
+oid sha256:319826994742cf80200ea0ca95663d7224fa226a2e0e020fff87adede70230a4
+size 43059804

assets/ppbld.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:8d5442ebb7953575d423c4382f6deaf0a280a5b148eeff6203f6978379755a7c
-size 47017612
+oid sha256:465882844e0d746676538e6d7ceb622d418fe673724132011817f7875b548702
+size 46980680

assets/semi_trailer.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:f2457b0febbf9b3ace295d27e8337011af255067b2c1991c385d688a77c10005
+size 10309576

assets/test.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:0be647d192d726d848bb7d950636f99cf2aaf060574b72425d73f1b2e96df532
+size 474132

assets/trees_pine.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:9310259c32d38fe1e7fe5c2e753474a46385e2589807414ccbb6c9c502e85ac2
-size 36185972
+oid sha256:da39fcded16904eeb3427cf30feeb9dcb6f87d5e45fca4c7f5e999a41465687f
+size 36121736

assets/user1.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:ac165edb7ce95ce49d6366e08693815c1455fe08591a5499b90b0a2f683c70c9
-size 2449700
+oid sha256:48f3197fc6658c31a60f740ec5d9608a40574a606b466ce48906761e18dd01fd
+size 1858156

assets/user1.blend1

 version https://git-lfs.github.com/spec/v1
-oid sha256:d2023b474f2cab2919049873e28728001572b808df806fd60826283f5df59980
-size 2449700
+oid sha256:3dd6f036660f74af3ddd2238de4887f21a6a8ec48c9f037d155a15a8610f8d68
+size 1894700

assets/user10.blend

-version https://git-lfs.github.com/spec/v1
-oid sha256:21f3ed5602d16daea652c30a275003df77f188f3b62559df257fce952ea64ef0
-size 2161220

assets/user11.blend

-version https://git-lfs.github.com/spec/v1
-oid sha256:4cc1e32b2f58cabe808266d2e834e23c2869b35ea6ba8daa7804015a201b39d8
-size 36463320

assets/user12.blend

-version https://git-lfs.github.com/spec/v1
-oid sha256:485b07900da509361a609d67509954047504672705269f1afc0253e7d997bdf7
-size 1180316

assets/user2.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:15c9fd3f50f8392246ac6af75bf25f976c632bcccc7ba657e7c07ec4bbf8aae1
-size 36473068
+oid sha256:2236921166ae3004513b314a3e66bda97dbcb9a45c94fc7184773c363b3207f3
+size 992868

assets/user3.blend

-version https://git-lfs.github.com/spec/v1
-oid sha256:6956a1e0d6ca1e03871bb671307217946e9ae1f81cdfca8dba5d62939d272698
-size 36473948

assets/user4.blend

-version https://git-lfs.github.com/spec/v1
-oid sha256:af4b267013012d995c4255e257f6851b8722d039bf3f4673ede90ab2569d3b14
-size 35783136

assets/user5.blend

-version https://git-lfs.github.com/spec/v1
-oid sha256:d13471ea619595c852adba5390cb4e6d46f00df6c2e625ba5ba9c43ac18fc53e
-size 509604

assets/user6.blend

-version https://git-lfs.github.com/spec/v1
-oid sha256:51cf794716ca3eefa69d428040d92f752022cf794b96e8508f8a742a4dd89d2b
-size 1445604

assets/user7.blend

-version https://git-lfs.github.com/spec/v1
-oid sha256:37e8c486113ad7c83ac9c41bfb0834c0177da0f19b3193549c2164b8ca1c1aad
-size 36419300

assets/user8.blend

-version https://git-lfs.github.com/spec/v1
-oid sha256:218d06a4088e0bff2666b6ce25b3a50b74c2efbb0e48f567f889b2f211a38bf1
-size 36473068

characters/annie.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:e99508665078153c4fef77c8bc194a116193619a6f3cd78713f3a0e291dda88b
-size 23468904
+oid sha256:6120cab7a0209e6dd566129a652626ba424846ed9740da9b12120d1874c00619
+size 3981620

characters/annie.ini

 
 shirt_logo = 5
 
-shirt_color_r = 0
-shirt_color_g = 0.16
-shirt_color_b = 0
+shirt_color_r = 0.21
+shirt_color_g = 0.13
+shirt_color_b = 0.26
 
 shoe_color_r = 0.08
 shoe_color_g = 0.05
 
 #deck settings
 ##############
-deck_index = 7
-deck_color_r = 0.28
-deck_color_g = 0.1
-deck_color_b = 0
+deck_index = 2
+deck_color_r = 1
+deck_color_g = 1.0
+deck_color_b = 1
 trucks_r = 0
-trucks_g = 0.41
+trucks_g = 0
 trucks_b = 0
 
-wheel1_r = 0.31
+wheel1_r = 0.83
 wheel1_g = 0.16
 wheel1_b = 0
-wheel2_r = 0.31
+wheel2_r = 0.83
 wheel2_g = 0.16
 wheel2_b = 0
-wheel3_r = 0.31
+wheel3_r = 0.83
 wheel3_g = 0.16
 wheel3_b = 0
-wheel4_r = 0.31
+wheel4_r = 0.83
 wheel4_g = 0.16
 wheel4_b = 0
 #-------------------

config.ini

 
 #level
 ######
-level = user1
+level = user2
+levelBlend = user2
 #------------
 
 #replay recorder
 #character settings
 ###################
 
-character = annie
+character = ralph
 
-shirt_logo = 5
+shirt_logo = 4
 
-shirt_color_r = 0
-shirt_color_g = 0.16
-shirt_color_b = 0
+shirt_color_r = 0.54
+shirt_color_g = 0.4
+shirt_color_b = 0.05
 
-shoe_color_r = 0.08
-shoe_color_g = 0.05
+shoe_color_r = 0.02
+shoe_color_g = 0.02
 shoe_color_b = 0.02
 #-----------------
 
 #deck settings
 ##############
 deck_index = 7
-deck_color_r = 0.28
-deck_color_g = 0.1
-deck_color_b = 0
-trucks_r = 0
-trucks_g = 0.41
-trucks_b = 0
-
-wheel1_r = 0.31
-wheel1_g = 0.16
-wheel1_b = 0
-wheel2_r = 0.31
-wheel2_g = 0.16
-wheel2_b = 0
-wheel3_r = 0.31
-wheel3_g = 0.16
-wheel3_b = 0
-wheel4_r = 0.31
-wheel4_g = 0.16
-wheel4_b = 0
+deck_color_r = 1
+deck_color_g = 1.0
+deck_color_b = 1
+trucks_r = 0.46
+trucks_g = 0.03
+trucks_b = 0.03
+
+wheel1_r = 1
+wheel1_g = 0.71
+wheel1_b = 0.08
+wheel2_r = 1
+wheel2_g = 0.71
+wheel2_b = 0.08
+wheel3_r = 1
+wheel3_g = 0.71
+wheel3_b = 0.08
+wheel4_r = 1
+wheel4_g = 0.71
+wheel4_b = 0.08
 #-------------------
 
 #2d filter settings
 
 #brightness / contrast
 bc = 1
-BC_BRIGHTNESS = 1.05
-BC_CONTRAST = 1.05
+BC_BRIGHTNESS = 1.01
+BC_CONTRAST = 1.03
 
 #HDR
 hdr = 1
-avgL = 0.55
-HDRamount = 0.05
+avgL = 0.56
+HDRamount = 0.01
 
 #Ambient Occlusion
 ao = 1
 onlyAO = 0
-aowidth = 1.0
-aoradius = 16
+aowidth = 23.0
+aoradius = 96.0
 
 #Depth of Field
 dof_on = 1
 
 #sun settings
 #############
-sun_strength = 1.05
-ambient_strength = 0.5
-sun_rot_x = 0.05
+sun_strength = 1.0
+ambient_strength = 0.68
+sun_rot_x = -0.05
 sun_rot_y = -0.05
 shadow_on = 0
 #------------
 
 #physics
 ########
-JUMPHEIGHT = 800
+JUMPHEIGHT = 840#800
 MAX_VEL = 6.7
 SPEEDUP = 0.055
 SPEEDPUMP = 0.14#.09
 ylimit = 0.84
 antibounce = -10.0
 gravity = -10.5
+fall_height = .4

npc_walkers/larry.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:211bd7f82fe6cfae047a74eb0d35503752b73fb8ace4b291389f24a2ac33ce7a
+size 3686800

npc_walkers/larry1.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:a4163bd96d4b30a521f6a5e7ab2c43ee82c20940c39eba06837384173f1f7640
+size 5436788

npc_walkers/larry_loader.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:ea94954d1a22f822e08cfa1a885851ec792e0fd2e3abd12e5d807da2d75e5d74
+size 507660

scripts/Manager.py

             dict['rp_positions'] = [] 
             dict['rp_orientations'] = []
             freecam['cur_key'] = 0
-            freecam.worldOrientation = cam.worldOrientation    
+            if dict['npause'] == False:
+                freecam.worldOrientation = cam.worldOrientation    
         valueIndex = own['valueIndex']
         n = (valueIndex / recording_cutoff) * 1000
         n = int(round(n))

scripts/Record.py

     #-----Position-----#
     own["lengthPos"] = readData.getLengthPos()
     dict['replay_loop_end'] = own['lengthPos']
-    print('setting replay end', dict['replay_loop_end'])
+    #print('setting replay end', dict['replay_loop_end'])
     lengthPos = own["lengthPos"] 
     
     if lengthPos:

scripts/Settings.py

     own2 = cont.owner
 
     dict = bge.logic.globalDict #Get the global dictionary
-    
+    dict['scene_inited'] = False
     if own["framerate"] == 1:    
         bge.render.showFramerate(1)
     if own["profile"] ==1:    

scripts/Startup.py

     dict['sunz'] = 1.0 
     dict['replay_loop_start'] = 0
     dict['replay_loop_end'] = 0
-    dict['replay_record_length'] = 7300
+    dict['replay_record_length'] = 2400 #7300
+    dict['rp_keyframes'] = []
+    dict['rp_positions'] = []
+    dict['temp_list'] = []
+    dict['scene_inited'] = True
     
 main()

scripts/controller2.py

 
 # control script
     
-
 import bge
 import GameLogic
 import ctypes
 from mathutils import Vector
     
 def main():
-    #scale = .3
-    #action layers
-    #0-14 rolling
-    #fliplay = 500
-    #grindlay = 700
-#    os = 'Windows'
-#    
-#    if platform != "win32":
-#     os = 'Linux'
-#    def onWindows():
-#     return os == 'Windows'
-    
-
-
     scene = bge.logic.getCurrentScene()
-    try:
-        GameLogic.DictObjects
-        init=1
-    except:
-        init=0
-#    if init:
-#        cont.GameLogic.getCurrentController()
-#        own = cont.getOwner()
-#        name = own.getName()
-#        if not GameLogic.DictObjects.has_key(name):
-#            GameLogic.DictObjects[name]=cont
-#        own.init=0
-    #reduction = 400000
-    #axisTh = 0.03 
 
     #initialize quadrant variables
     q1on = 0
 
     def check_fall():
         playing_frame = 20
+        #hitDistance = own.worldPosition.z - r_ground.hitPosition.z
         if skater.isPlayingAction(fliplay):
             playing_frame = skater.getActionFrame(fliplay)
         if r_ground.triggered == True and skater.isPlayingAction(fliplay) and own['jump_timer'] < 40 and playing_frame < 14 and playing_frame > 3:
-            own['fall'] = 1
-            own['last_fall_frame'] = frame
-            if STANCE == 0:
-                own['requestAction'] = 'reg_air-walk_air'
-            if STANCE == 1:             
-                own['requestAction'] = 'fak_air-walk_air'
+            hitDistance = own.worldPosition[2] - r_ground.hitPosition[2]
+            if hitDistance < dict['fall_height']:
+                own['fall'] = 1
+                own['last_fall_frame'] = frame
+                if STANCE == 0:
+                    own['requestAction'] = 'reg_air-walk_air'
+                if STANCE == 1:             
+                    own['requestAction'] = 'fak_air-walk_air'
     check_fall()
 
     def check_landing():
             if STANCE == False:
                 reg_onefoot_grab_on()        
             else:
-                fak_frigid_grab_on()                    
-                                            
+                fak_frigid_grab_on()                                                               
             
     #kill grabs        
     if lTrig <= 0.02 and GRAB_ON == True and lTrig >= -.02 and rTrig <= .02 and rTrig >= -.2:
         lgf = own['last_grind_frame']
         frame = own['framenum']
         frames_since_grinding = frame - lgf
-        #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 STANCE == 0:
                 yvel *= -1
             try:    
-                #dist = r_ground.hitObject.worldPosition - own.worldPosition
-                #print('ground dist', dist)
                 if own.linearVelocity.y > .01 or own.linearVelocity.y < -.01:
                     own.applyRotation([0,0,yvel], True)
                 
                 pass       
         else:    
             if r_ground.triggered and touched == False and grindHit == 0 and frames_since_grinding > 20:    
-            #     linVelocity4 = own.getLinearVelocity(True)
-            #     newy = linVelocity4.y * ylimit   
-            #     force = [linVelocity4.x, newy, linVelocity4.z]
-            #     own.setLinearVelocity(force, True) 
                 yvel = own.linearVelocity.y
                 yvel = yvel *.03
                 if STANCE == 0:
                         own.applyRotation([0,0,yvel], True)
                     
                 except:
-                    pass 
-
-        #print(ylimit, 'ylimit')       
+                    pass       
 
     def getoffboard():
         lasty = own['lasty']
     def control_calib():
         #controller calibration test
         scenes = bge.logic.getSceneList()
-
         controller_calib = [scene for scene in scenes if scene.name=="controller_calib"][0]
         cq1 = controller_calib.objects['q1']
         cq2 = controller_calib.objects['q2']
             cont.deactivate(own.actuators['grindoutRight'])
             cont.deactivate(own.actuators['grindoutLeft'])  
         if (LAST_GRIND == True and jumping == None and sincegrinding > 20 and ground_since > 20) or own['invert_on'] == True and LAST_GRIND == 1:
-
-        #own['grindTouch']      
-
             outloc = 0.022
             bsoutloc = .07
             bsoutvel = .1
         linvelx = linVelocity.x
         lastx = own["linvelx"]
         if frames_since_ground < 10 and (abs(lastx) - abs(linvelx)) > .5:
-            #print('land boost')
             force = (lastx, linVelocity.y, linVelocity.z )                    
             own.setLinearVelocity(force, True)                 
     
     air_mover()
     dropinRotate()    
     onboard()   
-    #wallhit() 
     linvelx = own.getLinearVelocity(True)
-    #land_boost()
     own["linvelx"] = linvelx.x
     LAST_STANCE = STANCE
     LAST_STANCE = own["stance"]
     own["sel"] = bkBut  
 
     if r_ground.triggered and own["jump_timer"] < 20:
-        #if own['rotz'] > .65:
-        #if own['rotz'] > .15: 
         if 1 == 1:    
             force2 = [0.0, 0, dict['antibounce']]
-            #own.applyForce(force2, True)
 
             gdist = ((own.worldPosition.z - r_ground.hitPosition[2]))  
-            #print(gdist)
             if gdist < .2875 and gdist > .1:
-                #move = 2.875 - gdist
                 move = (.2875 - gdist)*.33
-                #move = (own.worldPosition.z + gdist)
                 if move > 0:
                     own.worldPosition.z = own.worldPosition.z + move
                 else:
                 own.linearVelocity.z = 0
         else:
             gdist = ((own.worldPosition.z - r_ground.hitPosition[2]))  
-            #print(gdist)
             if gdist < .2875 and gdist > .1:
-                #move = 2.875 - gdist
-                #move = (.2875 - gdist)*.33
                 move = (.2875 - gdist)*.4
-                #move = (own.worldPosition.z + gdist)
                 if move > 0:
                     own.worldPosition.z = own.worldPosition.z + move
                 else:
                     own.worldPosition.z = own.worldPosition.z - move    
-                own.linearVelocity.z = 0            
-                
-    
+                own.linearVelocity.z = 0                   
 
     Axis = 2 
     Distance = -10
-    # X axis is zero
-    # Y is 1
-    # Z is 2
     End = own.worldPosition + (own.worldOrientation.col[Axis]*Distance)
     Start = own.worldPosition
     localRay = own.rayCast(End,Start,0,'ground',1,0,0)
-    #print(localRay)
     if localRay[0]:
         localHitDist = (own.worldPosition - localRay[1]).length
-        #print(localHitDist)
-        #print(localRay[2])
         if localHitDist < .287:
             own.localPosition[2] += (.287 - localHitDist)
             if localRay[2] != [0,0,-1] and grindHit == 0:
                 own.alignAxisToVect(localRay[2], 2, .75)
-                #print('moving local')
-
-    # if own['LAST_GRIND'] == False and touched:
-    #     print('touching but not grinding')
-    #     if STANCE == 0:
-    #         own.applyMovement([-.05, 0, .01], True)
-    #     else:
-    #         own.applyMovement([.05, 0, .01], True)    
-    # #rend = bge.render
-    #rend.drawLine(Start, End, [1,0,0,1])
-    #print(own['rotz'])
-
 
     if own.linearVelocity.x > 10:
         own.linearVelocity.x = 10
     if (grindDar == False and r_ground.triggered and own['grindTouch'] == False) or own['jump_timer'] > 40:
         own['grindType'] = ''
     
-    dict['walk'] = 0  
-
-    #print(own["LAST_GRIND"])
+    dict['walk'] = 0  

scripts/dynamicLoader.py

+import bge
+
+def finished_cb(status):
+	print("Library (%s) loaded in %.2fms." % (status.libraryName, status.timeTaken))    
+
+
+def main(cont):
+	own = cont.owner
+	sens = cont.sensors['Collision']
+
+	if sens.positive:
+		mainDir = bge.logic.expandPath("//")
+		wLib = mainDir + "assets\\" + own['libName'] 
+		print('colliding') 
+		to_free = None
+
+		if own['libName'] not in str(bge.logic.LibList()):
+			print(wLib, 'loading')
+			#bge.logic.LibLoad(wLib, 'Scene', asynchronous=True).onFinish = finished_cb
+			bge.logic.LibLoad(wLib, 'Scene', async=True).onFinish = finished_cb
+		else:
+			y = bge.logic.LibList()
+			for x in y:
+				if own['libName'] in x:
+					print('unloading', x)
+					to_free = x
+					#bge.logic.LibFree(x)
+		if to_free != None:
+			bge.logic.LibFree(to_free)			
+				#else:
+					#print('cant unload', x, y)	
+			#print('not loading', bge.logic.LibList(), wLib)
+				

scripts/grindV2.py

     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")        
+    #print(grindold, "grindold")  
+    skipper = 0      
     if (grindDar.positive or grindTouch.positive) and no_grind == 0:        
         if grindDar.positive:
             detectedObjects = grindDar.hitObjectList
         else:
             own['inverting'] = False
         grind_dist = .8#.6
+        skipper = 0
         #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['grinder_rot'] != None:
+                    grot = nearestObject.getAxisVect( [1, 0.0, 0.0]).x
+                    dif = (grot - own['grinder_rot'])
+                    if dif > .8 or dif < - .8:
+                        print('skipping grind, angle is', dif)
+                        skipper = 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')                    
+                    #print((grot - own['grinder_rot']), 'grinder_rot')
+                own['grinder_rot']  = nearestObject.getAxisVect([1,0,0]).x
+                if skipper != 1:
+
+                    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 

scripts/load_char.py

 
 #    # set parent
 #    armature.setParent( own, compound, ghost) 
-    
-    print('loading ai') 
+	
+	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("//")
+	own = cont.owner
+	scene = bge.logic.getCurrentScene()
+	#actu = cont.actuators['start_level']
+	actu = cont.actuators['sceneInitState']
+	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') 
+	fileName = mainDir + "characters/" + str(dict["character"]) + '.blend'    
+	
+	path = bge.logic.expandPath(fileName)
+	try:
+		bge.logic.LibLoad(path, 'Scene')  
+		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')         
+	except:
+		pass    
+	
+
 #        dict['char_loaded'] = 1
-    
-    
+	
+	
 #    fileName = mainDir + "characters/sun.blend"    
 #    
 #    path = bge.logic.expandPath(fileName)
 #    bge.logic.LibLoad(path, 'Scene')      
 
 
-    cont.activate(actu)
-    
+	cont.activate(actu)
+	

scripts/menuV3.py

     if funct == 'ambient strength':
         b = cam['ambient_strength']
         if motion == 'inc':
-            b += .05
+            b += .025
         else:
-            b -= .05    
+            b -= .025    
         cam['ambient_strength'] = round(b,2)        
         dict['ambient_strength'] = round(b,2)  
 
         if motion == 'inc':
             level = "pats"
             main_empty["level"] = "pats"
-            dict['level'] = level
+            dict['levelBlend'] = 'mini_island'
+            #dict['level'] = level
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "j_scene"
             main_empty["level"] = "j_scene"
-            dict['level'] = level
+            #dict['level'] = level
+            dict['levelBlend'] = 'j_scene'
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "lot"
             main_empty["level"] = "lot"
-            dict['level'] = level
+            #dict['level'] = level
+            dict['levelBlend'] = 'lot2'
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "train"
             main_empty["level"] = "train"
-            dict['level'] = level
+            #dict['level'] = level
+            dict['levelBlend'] = 'train'
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "spine"
             main_empty["level"] = "spine"
-            dict['level'] = level
+            #dict['level'] = level
+            dict['levelBlend'] = 'spine'
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "warehouse"
             main_empty["level"] = "warehouse"
-            dict['level'] = level
+            #dict['level'] = level
+            dict['levelBlend'] = 'warehouse'
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "shop"
             main_empty["level"] = "shop"
-            dict['level'] = level
+            #dict['level'] = level
+            dict['levelBlend'] = 'shop'
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "sc"
             main_empty["level"] = "sc"
-            dict['level'] = level
+            #dict['level'] = level
+            dict['levelBlend'] = 'sc'
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "user1"
             main_empty["level"] = "user1"
-            dict['level'] = level
+            #dict['level'] = level
+            dict['levelBlend'] = 'user1'
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 
         if motion == 'inc':
             level = "user2"
             main_empty["level"] = "user2"
-            dict['level'] = level
+            #dict['level'] = level
+            dict['levelBlend'] = 'user2'
             Settings.writeSettings()
             Settings.readSettings()
             #cont.activate(own.actuators['restart']) 

scripts/npause.py

     
     #switch pause state
     if dict['stBut'] == True and dict['last_stBut'] == False:
+        print('starting to pause')
         if pause_state == 0:
             pause_state = 1
         else:
     
     #enter pause    
     if pause_state == 1 and last_pause == 0:
+        print('pausing')
         own.suspendDynamics()
         own['pre_pause_linvel'] = [own['linvelx'], own['linVely'], 0]
         own.setLinearVelocity([0,0,0],1)  

scripts/npause_tmp.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/scene_init.py

     import bge
     #import GameLogic
     cont = bge.logic.getCurrentController()
+    scene = bge.logic.getCurrentScene()
     own = cont.owner
+    #own = scene.objects['control_cube.002']
     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  
+    if dict['scene_inited'] == False:
+
+        own['last_stBut'] = False
+        level = dict['level']
         
-    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]         
+        cam = scene.objects['Camera.003']
+        curscene = bge.logic.getCurrentScene()
+
+        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
         
-    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"])
+        for i in scenes:
+            if i.name == "fade_out":
+                print('ending fade_out', scenes)
+                scene2 = i
+                scene2.end()  
+                   
+
+         
+        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'])        
+            
         
-    if dict['bloom_on'] == 1:
-        cont.activate(cam.actuators["Bloom"])
 
-    else:
-        cont.activate(cam.actuators["bloom_off"])
+        for x in scene.objects:
+            if 'hemi' in x:
+                if 'down' in x:
+                    x.energy = dict['ambient_strength']
+                else:
+                    x.energy = dict['ambient_strength'] * .7    
+
+            if 'sun' in x:
+                x.energy = dict['sun_strength']
+        #scene.world.envLightEnergy = dict['ambient_strength']   
+        scene.world.envLightEnergy = 0
+        
+        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
+        own['grinder_rot'] = None
         
-#    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'])        
+        colors.update_shirt_tex() 
+        colors.update_truck_tex()
         
-    
-
-    for x in scene.objects:
-        if 'hemi' in x:
-            if 'down' in x:
-                x.energy = dict['ambient_strength']
-            else:
-                x.energy = dict['ambient_strength'] * .7    
-
-
-
-    #scene.world.envLightEnergy = dict['ambient_strength']   
-    scene.world.envLightEnergy = 0
-    
-    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')
+        print('scene init ran')
+        dict['scene_inited'] = True
       
-main()
+#main()

scripts/walk.py

                 else:
                     cont.deactivate(followcam.actuators["down"])                    
     #            #left
-                if lLR < -0.080:
+                #if lLR < -0.080:
+                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:         
+                #if lLR > 0.080: 
+                if lLR < -0.080:         
                     followcam.actuators["right"].dLoc = [camspeed2, 0, 0]                
                     cont.activate(followcam.actuators["right"])
                 else:

scripts/walker_load.py

+import bge
+
+
+
+
+
+
+
+def main(cont):
+    own = cont.owner
+    scene = bge.logic.getCurrentScene()
+    dict = bge.logic.globalDict
+    objList = scene.objects
+    mainDir = bge.logic.expandPath("//")
+    skater = own['chr']
+    
+    fileName = mainDir + "npc_walkers/" + str(skater) + '.blend'    
+    
+    path = bge.logic.expandPath(fileName)
+    try:
+        bge.logic.LibLoad(path, 'Scene',  load_actions=True,) 
+        print(skater, 'loaded')
+    except:
+        print('trying to load', fileName, 'twice')    
+    

scripts/walker_states.py

+import bge
+from random import randint
+from time import clock
+   
+   
+#====================================
+class Transition(object):
+	def __init__(self, toState):
+		self.toState = toState
+	def Execute(self):
+		#print('Transitioning ...', self.toState)
+		pass
+			
+   
+   
+#====================================
+State = type("State", (object,), {})
+
+class State(object):
+	def __init__(self, FSM):
+		self.FSM = FSM
+		self.timer = 0
+		self.startTime = 0
+	def Enter(self):
+		pass
+		#print('entering')
+	def Execute(self):
+		pass
+		#print('Executing')
+	def Exit(self):
+		pass
+		#print('Exiting')
+		
+class Target1(State):
+	def __init__(self,FSM):
+		super(Target1, self).__init__(FSM)    
+		
+	def Enter(self):
+		#print('Preparing to walk towards target 1.')
+		self.cont = bge.logic.getCurrentController()
+		self.FSM.stateLife = 1
+		self.own = self.cont.owner
+		self.target = 'larryTarget'
+		self.npcArm = self.own.children['npc']
+		self.scene = bge.logic.getCurrentScene()
+		self.actu = self.cont.actuators['Steering']
+
+		if 'larryTarget' in self.scene.objects:
+				self.actu.target = self.target			
+				self.actu.velocity = 1.5
+				self.actu.turnspeed = 100
+				self.actu.facingMode = True
+				self.cont.activate(self.actu)
+
+		super(Target1, self).Enter()
+		
+	def Execute(self):
+		#print('Tracking target 1.', self.FSM.stateLife)
+		self.FSM.stateLife += 1
+		duration = 1000
+		if self.FSM.stateLife > duration:
+			num = randint(1,3)
+			if num == 1:
+				self.FSM.ToTransition('toTarget2')
+			elif num ==2:
+				self.FSM.ToTransition('toTarget3')	
+			else:
+				self.FSM.ToTransition('toIdle')
+		else:	
+			self.cont.activate(self.actu)	
+			self.npcArm.playAction('g_walk2', 1,62, layer=2, play_mode=0, speed=.5)			
+			
+	def Exit(self):
+		#print('Finished target 1') 
+		self.cont.deactivate(self.actu) 
+
+class Target2(State):
+	def __init__(self,FSM):
+		super(Target2, self).__init__(FSM)    
+		
+	def Enter(self):
+		#print('Preparing to walk towards target 2.')
+		self.cont = bge.logic.getCurrentController()
+		self.FSM.stateLife = 1
+		self.own = self.cont.owner
+		self.target = 'larryTarget.001'
+		self.npcArm = self.own.children['npc']
+		self.scene = bge.logic.getCurrentScene()
+		self.actu = self.cont.actuators['Steering']
+
+		if 'larryTarget.001' in self.scene.objects:
+				self.actu.target = self.target			
+				self.actu.velocity = 1.5
+				self.actu.turnspeed = 100
+				self.actu.facingMode = True
+				self.cont.activate(self.actu)
+
+		super(Target2, self).Enter()
+		
+	def Execute(self):
+		#print('Tracking target 2.', self.FSM.stateLife)
+		self.FSM.stateLife += 1
+		duration = 1000
+		if self.FSM.stateLife > duration:
+			num = randint(1,3)
+			if num == 1:
+				self.FSM.ToTransition('toTarget1')
+			elif num ==2:
+				self.FSM.ToTransition('toTarget3')	
+			else:
+				self.FSM.ToTransition('toIdle')
+		else:		
+			self.cont.activate(self.actu)
+			self.npcArm.playAction('g_walk2', 1,62, layer=2, play_mode=0, speed=.5)			
+							
+				
+	def Exit(self):
+		#print('Finished target 2') 
+		self.cont.deactivate(self.actu)          
+		
+class Target3(State):
+	def __init__(self,FSM):
+		super(Target3, self).__init__(FSM)    
+		
+	def Enter(self):
+		#print('Preparing to walk towards target 3.')
+		self.cont = bge.logic.getCurrentController()
+		self.FSM.stateLife = 1
+		self.own = self.cont.owner
+		self.target = 'larryTarget.002'
+		self.npcArm = self.own.children['npc']
+		self.scene = bge.logic.getCurrentScene()
+		self.actu = self.cont.actuators['Steering']
+
+		if 'larryTarget.002' in self.scene.objects:
+				self.actu.target = self.target			
+				self.actu.velocity = 1.5
+				self.actu.turnspeed = 100
+				self.actu.facingMode = True
+				self.cont.activate(self.actu)
+		super(Target3, self).Enter()
+
+		
+	def Execute(self):
+		#print('Vacumming.', self.FSM.stateLife)
+		self.FSM.stateLife += 1
+		duration = 1200
+		if self.FSM.stateLife > duration:
+			if not (randint(1,3) % 2):
+				self.FSM.ToTransition('toTarget1')
+			else:
+				self.FSM.ToTransition('toIdle')
+		else:
+			cont = bge.logic.getCurrentController()
+			own = cont.owner
+			npcArm = own.children['npc']
+			npcArm.playAction('g_walk2', 1,62, layer=2, play_mode=0, speed=.5)		
+			#npcArm.playAction('npcImpatient', 2,135, layer=2, play_mode=0, speed=.25)	
+
+	def Exit(self):
+		#print('Finished target 3') 
+		self.cont.deactivate(self.actu)              
+		
+		
+class Idle(State):
+	
+	def __init__(self,FSM):
+		super(Idle, self).__init__(FSM)  
+		
+	def Enter(self):
+		#print('Starting to idle.')
+
+
+		self.cont = bge.logic.getCurrentController()
+		self.FSM.stateLife = 1
+		self.own = self.cont.owner
+		self.npcArm = self.own.children['npc']
+
+		super(Idle, self).Enter()
+		
+	def Execute(self):
+		#print('Idleing.', self.FSM.stateLife)
+		self.FSM.stateLife += 1
+		duration = 600
+		if self.FSM.stateLife > duration:
+			num = randint(1,4)
+			if num == 1:
+				self.FSM.ToTransition('toTarget1')
+			elif num == 2:
+				self.FSM.ToTransition('toTarget2')	
+			elif num == 3:
+				self.FSM.ToTransition('toTarget3')
+			elif num == 4 or num == 5 or num == 6:
+				self.FSM.ToTransition('toImpatient')										
+			else:
+				self.FSM.ToTransition('toIdle')
+		else:
+			#pass
+			self.npcArm.playAction('g_idle', 1,201, layer=2, play_mode=0, speed=.5)	
+			
+	def Exit(self):
+		pass
+		##print('Waking up from idle.') 
+
+class Impatient(State):
+	
+	def __init__(self,FSM):
+		super(Impatient, self).__init__(FSM)  
+		
+	def Enter(self):
+		#print('Starting to idle.')
+		self.FSM.stateLife = 1
+		self.cont = bge.logic.getCurrentController()
+		self.own = self.cont.owner
+		self.npcArm = self.own.children['npc']	
+		super(Impatient, self).Enter()
+		
+	def Execute(self):
+		##print('being Impatient.', self.FSM.stateLife)
+		self.FSM.stateLife += 1
+		duration = 600
+		if self.FSM.stateLife > duration:
+			self.FSM.ToTransition('toIdle')
+		else:
+			self.npcArm.playAction('npcImpatient', 1,201, layer=2, play_mode=0, speed=.5)	
+			
+	def Exit(self):
+		pass
+		#print('stopping bening impatient.') 		         
+						   
+					 
+#===================================
+						
+
+class FSM(object):
+	def __init__ (self, character):
+		self.char = character
+		self.states = {}
+		self.transitions = {}
+		self.curState = None
+		self.prevState = None
+		self.trans = None
+		self.stateLife = 0
+		
+	def AddTransition(self, transName, transition):
+		self.transitions[transName] = transition
+	
+	def AddState(self, stateName, state):
+		self.states[stateName] = state        
+		
+	def SetState(self, stateName):
+		self.prevState = self.curState
+		self.curState = self.states[stateName]
+		
+	def ToTransition(self, toTrans):
+		self.trans = self.transitions[toTrans]
+		
+	def Execute(self):
+		if (self.trans):
+			self.curState.Exit()
+			self.trans.Execute()
+			self.SetState(self.trans.toState)
+			self.curState.Enter()
+			self.trans = None        
+		self.curState.Execute()    
+				
+#====================================
+Char = type("Char",(object,),{})
+
+class Walker(Char):
+	def __init__(self):
+		self.FSM = FSM(self)
+		#cont = bge.logic.getCurrentController()
+		#own = cont.owner
+		#self.LightOn = own['state']
+		
+		##STATES
+		self.FSM.AddState("Idle", Idle(self.FSM))
+		
+		self.FSM.AddState("Impatient", Impatient(self.FSM))
+		self.FSM.AddState('Target1', Target1(self.FSM))
+		self.FSM.AddState('Target3', Target3(self.FSM))
+		self.FSM.AddState('Target2', Target2(self.FSM))
+		
+		#TRANSITIONS
+		self.FSM.AddTransition('toIdle', Transition('Idle'))
+		self.FSM.AddTransition('toImpatient', Transition('Impatient'))
+		self.FSM.AddTransition('toTarget3', Transition('Target3'))
+		self.FSM.AddTransition('toTarget1', Transition('Target1'))
+		self.FSM.AddTransition('toTarget2', Transition('Target2'))
+		
+		
+		if self.FSM.curState == None:
+			self.FSM.SetState('Idle')
+			#print('setting none')
+	
+	def Execute(self):
+		self.FSM.Execute()    
+#====================================     
+r = Walker()
+def main(cont):
+	own = cont.owner   
+	scene = bge.logic.getCurrentScene()
+	if 'inited' not in own:
+		own['inited'] = True
+		own['frame'] = 0
+		own['state'] = 'On'
+		#print('initing')
+
+	if own['frame'] == 40:
+		own.worldPosition = [0,0,50]	
+
+		ln = own['cName'] + '_loader'
+		if ln in scene.objects:
+			to = scene.objects[ln]	
+			own.worldPosition = to.worldPosition
+			own.worldPosition.z += 50
+
+
+	r.Execute()    
+	##print(r.FSM.curState)
+	
+	own['frame'] += 1			

shuvit.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:2a72807221c2e589f2152198d8bdd7b10f67153f571f7808b3ae9f456ba4931d
-size 181395308
+oid sha256:6ce5c15dce7d44d729cac00ff3d914ad1102691223ed5c67381a2a6f5e8bf8fb
+size 134865180

textures/vignette.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:04c64426511e7b9f05f944a7921e97c9b75be1e531176c8d5a4459875a80343b
+size 142546