big things

assets/bld1.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:7df19db4dd7dfda3631d980d1ba70842e84990dd32243e5c941a39b39e0cd5a9
+size 639776

assets/bld_C.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:417fca36058536259e7ef53649cb697b7dd2a253822fa57d6bc25052103b519d
+size 7554648

assets/blda.blend

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

assets/bldb.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:35ed1e774df2f3ea295a61e5dadb00ebd4fa6e2ee89369cd8ce1b2fb21a2a256
+size 861072

assets/car1.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:335091f63d4f159e1785328dcd07237c1534404184837d55ca83a9803c07042c
+size 2011016

assets/custom_shaders/custom_shader_utils.py

         shader.setUniform1f(names[1] + "[%s]"%i, light.distance)
         
         color = light.color
-        energy = light.energy / 2
+        energy = light.energy
         shader.setUniform3f(names[2] + "[%s]"%i, color[0] * energy, color[1] * energy, color[2] * energy)
         
         spotsize = cos(radians(light.spotsize) * 0.5)

assets/materials/base_m_kit.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:9a3613fd2f72fe67f6006e52509f8ce8a5308d2a8222bd1cc0808ab97c2bb695
-size 33048768
+oid sha256:4cd74693215f17375ec593ab1fb7d24dd67fa746ecc517a72275c7ba81ef939a
+size 43541408

assets/materials/textures/Curbs_N.png

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

assets/materials/textures/GarageDoor_A.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:5048c4605a259f1c3ebe817692e231df84ff1fa2748e760a80cdbd85b3698114
+size 435023

assets/materials/textures/GarageDoor_H.png

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

assets/materials/textures/GarageDoor_N.png

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

assets/materials/textures/OilDrum_A.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:34f3a21080496d8de77736c825d880103119a3f402e1ba7e439be92986975c45
+size 120998

assets/materials/textures/OilDrum_C.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:54cefd1b690d0077afbf4f619ca6dc741f0fd585ff0dc50e7617f61e9a227122
+size 441340

assets/materials/textures/OilDrum_N.png

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

assets/misc.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:537ad5e3db1bab9e69af4479e73e934c48d9e7af9f993e48a00849fa0bd6c2dd
+size 53715124

assets/roads.blend

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

assets/roads2.blend

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

assets/roads3.blend

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

assets/stop_sign.blend

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

assets/street_light.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:2466371550482abd80cd8f190c6edb73f5b2b5ba0a25171cd0bfc8e300cc31e8
+size 6767332

assets/textures/crosswalk.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:9be69046e7684c7f5ca846973779789a8375e8061180cac51fe340c08b0c3d69
+size 133349

assets/textures/double_yellow_line.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:681477ad07aeb72bd95c8fed581fc34eb0d2c867de1cad9d44f980c5da539b82
+size 59284

assets/textures/lines_d.png

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

assets/textures/road_d.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:00297155289c9b5da81fee6560f0c4b160a4606468d25b24dc3e2a6c65dfdea1
+size 2433371

assets/textures/road_d_h.png

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

assets/textures/road_d_n.png

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

assets/textures/road_d_s.png

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

assets/textures/road_h.png

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

assets/textures/road_n.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:92787108d1c58d0843be3a21b1737b40e56bf233b733ecbb69dd50e76a46ca34
+size 1594840

assets/textures/road_r.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:302d0317170cac8d3c8c2b9972abfc7ad173ffab138e9ee1aabcd24ab66e6439
+size 2414316

assets/textures/sidewalk_d.png

+version https://git-lfs.github.com/spec/v1
+oid sha256:17edc4f58c5b22dfab788090fc98bebdbd799905b1cbf6048ad3da09450e7f11
+size 1964881

assets/textures/sidewalk_h.png

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

assets/textures/sidewalk_n.png

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

assets/textures/sidewalk_r.png

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

assets/textures/white_edge.png

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

assets/user1.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:8f749d309a733ffec4b5c022bcc97efd626326c6c9ca7b8c14f5f48dbb30180f
+size 3072876

assets/user2 - Copy.blend

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

assets/user2.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:12d40b33cfb2f5e40d46a86b55ca8b89a97e209e31950ff50d1a08777a0d6c27
-size 4788020
+oid sha256:55ccbcfd7471751baddd78f3c758c42b6c531ca7bae09a608628e889fcd527dd
+size 6498608

assets/user2_old.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:30554fe681901cd13de5a5ae3380bd83a5328f2909a95a1e5dc6ab34776cc51c
+size 4777216

assets/user2_working.blend

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

assets/user2_working_b.blend

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

assets/user2bad.blend

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

assets/utils/park_creator19.blend

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

characters/annie.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:afbf98261896bf782abcdf5ce5c09ba425f4c2fc5dec3a15a6c44bfc328fa02a
-size 4288452
+oid sha256:946def328b4993b48b80a5a35306bdac0c3b9a8d321a10b60c8624bb4c57275b
+size 4212932

characters/annie.ini

 
 shirt_logo = 2
 
-shirt_color_r = 0.69
-shirt_color_g = 0.05
+shirt_color_r = 0.38
+shirt_color_g = 0.0
 shirt_color_b = 0
 
-shoe_color_r = 0.73
-shoe_color_g = 0.73
-shoe_color_b = 0.73
+shoe_color_r = 0.03
+shoe_color_g = 0.03
+shoe_color_b = 0.03
 #-----------------
 
 #deck settings

config.ini

 #######
 cam_height = -0.3
 focal_length = 16
-cam_min = 2.4
-cam_max = 5.0
-cch_targetHeight = 0.25
+cam_min = 2.2
+cam_max = 4.4
+cch_targetHeight = 0.3
 
 cam_walk_height = 0.8
 cam_walk_min = 2.4
 
 shirt_logo = 2
 
-shirt_color_r = 0.29
-shirt_color_g = 0.31
-shirt_color_b = 0.28
+shirt_color_r = 0.38
+shirt_color_g = 0.0
+shirt_color_b = 0
 
-shoe_color_r = 0.73
-shoe_color_g = 0.73
-shoe_color_b = 0.73
+shoe_color_r = 0.03
+shoe_color_g = 0.03
+shoe_color_b = 0.03
 #-----------------
 
 #deck settings
 #brightness / contrast
 bc = 1
 BC_BRIGHTNESS = 1.03
-BC_CONTRAST = 1.0
+BC_CONTRAST = 1.06
 
 #HDR
 hdr = 1
 #############
 sun_strength = 1.5
 ambient_strength = 0.57
-sun_rot_x = -0.05
+sun_rot_x = 0.05
 sun_rot_y = 0.05
 shadow_on = 0
 #------------

npc_walkers/larry.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:57e3bad63d8cfe5f046b442c98e8b04f4b0444d478716f5efc2f07a6f84cda36
-size 3686456
+oid sha256:0df1002d71bf91ba07c9afbac1aa41360803340218100d6a91a32eff732b0c4b
+size 3687104

roads.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:4fe769219c3ecc929016925b55fe2e6926287d93a921a569a61a4c45e2dbaa22
+size 82819680

scripts/Manager.py

         n = int(round(n))
         #n = 10
         #print("n: ", n, "--", valueIndex, recording_cutoff)
+        #print(valueIndex, 'valueIndex from Manager.py', dict['frame'])
         #dict = logic.globalDict #Get the global dictionary
         dict['playhead'] = n 
           

scripts/Record.py

 from mathutils import Vector
 from SortData import *
 import boneRecord
+import sound_man
 
 cont = logic.getCurrentController()
 own = cont.owner
 
 
         boneRecord.Playback(valueIndex)
+        #sound_man.Playback(valueIndex)
+        own['sndmgr'].h_Playback(valueIndex)
+        #print(valueIndex, 'valueIndex from Record.py')
+        #print('recorder', valueIndex)
 
 
         # name, skateranim = readData.returnSkaterAnim(objIndex, valueIndex)
             own["objIndex"] = lengthSrollVol-2
         name, srollVol = readData.returnSrollVol(objIndex, valueIndex)
         name, srollPitch = readData.returnSrollPitch(objIndex, valueIndex)    
-        if name in scene.objects:
-            try:
-                cube = scene.objects["control_cube.002"]
-                srollVol = round(srollVol, 2)
-                act = cube.actuators["sroll"]
-                if srollVol < .12:
-                    act.volume = srollVol
-                    act.pitch = srollPitch
-                act.startSound()
-            except:
-                pass
+        # if name in scene.objects:
+        #     try:
+        #         cube = scene.objects["control_cube.002"]
+        #         srollVol = round(srollVol, 2)
+        #         act = cube.actuators["sroll"]
+        #         if srollVol < .12:
+        #             act.volume = srollVol
+        #             act.pitch = srollPitch
+        #         act.startSound()
+        #     except:
+        #         pass
 ###            
 #
     #-----grind cement-----#
             own["objIndex"] = lengthSgrind_cementVol-2
         name, sgrind_cementVol = readData.returnSgrind_cementVol(objIndex, valueIndex)
         name, sgrind_cementPitch = readData.returnSgrind_cementPitch(objIndex, valueIndex)    
-        if name in scene.objects:
-            try:
-                cube = scene.objects["control_cube.002"]
-                sgrind_cementVol = round(sgrind_cementVol, 2)
-                act = cube.actuators["grind_cement"]
-                if sgrind_cementVol < .2:
-                    act.volume = sgrind_cementVol
-                    act.pitch = sgrind_cementPitch
-                act.startSound()
+        # if name in scene.objects:
+        #     try:
+        #         cube = scene.objects["control_cube.002"]
+        #         sgrind_cementVol = round(sgrind_cementVol, 2)
+        #         act = cube.actuators["grind_cement"]
+        #         if sgrind_cementVol < .2:
+        #             act.volume = sgrind_cementVol
+        #             act.pitch = sgrind_cementPitch
+        #         act.startSound()
                 
-            except:
-                pass
+        #     except:
+        #         pass
 ###    
 #
     #-----grind rail-----#
             own["objIndex"] = lengthSgrind_railVol-2
         name, sgrind_railVol = readData.returnSgrind_railVol(objIndex, valueIndex)
         name, sgrind_railPitch = readData.returnSgrind_railPitch(objIndex, valueIndex)    
-        if name in scene.objects:
-            try:
-                cube = scene.objects["control_cube.002"]
-                sgrind_railVol = round(sgrind_railVol, 2)
-                act = cube.actuators["grind_rail"]
-                if sgrind_railVol < .2:
-                    act.volume = sgrind_railVol
-                    act.pitch = sgrind_railPitch
-                act.startSound()
-                #print("grindsound = ", sgrind_railVol, sgrind_railPitch)
-            except:
-                pass
+        # if name in scene.objects:
+        #     try:
+        #         cube = scene.objects["control_cube.002"]
+        #         sgrind_railVol = round(sgrind_railVol, 2)
+        #         act = cube.actuators["grind_rail"]
+        #         if sgrind_railVol < .2:
+        #             act.volume = sgrind_railVol
+        #             act.pitch = sgrind_railPitch
+        #         act.startSound()
+        #         #print("grindsound = ", sgrind_railVol, sgrind_railPitch)
+        #     except:
+        #         pass
 ###  
 #
     #-----pop sound-----#
         if objIndex < 0:
             own["objIndex"] = lengthSpopsound-2
         name, spopsound = readData.returnSpopsound(objIndex, valueIndex)   
-        if name in scene.objects:
-            #act = sound_empty.actuators["pop"]
-            try:
-                #cube = scene.objects[sound_empty]
-                spopsound = round(spopsound, 2)
-                act = cube.actuators["pop"]
-                #act = sound_empty.actuators["pop"]
-                if spopsound == 1:
-                    #act.volume_maximum = .7
-                    #act.is3D = True
-                    #act.distance_reference = 10.0
-                    #act.distance_maximum = 50.0
-                    act.volume = .6
-                    act.startSound()
-                #print("grindsound = ", spopsound, sgrind_railPitch)
-            except:
-                print("sound passed")
-                pass
+        # if name in scene.objects:
+        #     #act = sound_empty.actuators["pop"]
+        #     try:
+        #         #cube = scene.objects[sound_empty]
+        #         spopsound = round(spopsound, 2)
+        #         act = cube.actuators["pop"]
+        #         #act = sound_empty.actuators["pop"]
+        #         if spopsound == 1:
+        #             #act.volume_maximum = .7
+        #             #act.is3D = True
+        #             #act.distance_reference = 10.0
+        #             #act.distance_maximum = 50.0
+        #             act.volume = .6
+        #             act.startSound()
+        #         #print("grindsound = ", spopsound, sgrind_railPitch)
+        #     except:
+        #         print("sound passed")
+        #         pass
 ###
 #
     #-----land sound-----#
         if name in scene.objects:
             try:
                 cube = scene.objects["control_cube.002"]
-                slandsound = round(slandsound, 2)
-                act = cube.actuators["land"]
-                if slandsound == 1:
-                    act.volume = .6
-                    act.startSound()
+                # slandsound = round(slandsound, 2)
+                # act = cube.actuators["land"]
+                # if slandsound == 1:
+                #     act.volume = .6
+                #     act.startSound()
                 #print("grindsound = ", slandsound, sgrind_railPitch)
             except:
                 pass
             try:
                 #cube = scene.objects[sound_empty]
                 srevertsound = round(srevertsound, 2)
-                act = cube.actuators["revertSound"]
-                if srevertsound == 1:
-                    act.startSound()
+                #act = cube.actuators["revertSound"]
+                #if srevertsound == 1:
+                    #act.startSound()
                 #print("grindsound = ", spopsound, sgrind_railPitch)
             except:
                 print("sound passed")
 def main(recording_cutoff, cc):
     num = 1
     obj = scene.objects["control_cube.002"]
+    #own = scene.objects["Camera.003"]
     if num == 1:
         
     #for obj in scene.objects:
         getData.savetdPosition(obj, recording_cutoff)
         getData.savetdOrientation(obj, recording_cutoff)
         getData.saveSrevertsound(obj, recording_cutoff)                                       
-        boneRecord.Record()    
+        boneRecord.Record() 
+        own['sndmgr'].Record()    
+
+        #print('recording cutoff', recording_cutoff)
          
 def breakOut():
     num = 1

scripts/Startup.py

     dict['sunz'] = 1.0 
     dict['replay_loop_start'] = 0
     dict['replay_loop_end'] = 0
-    dict['replay_record_length'] = 2400 #7300
+    dict['replay_record_length'] = 7300#240 #1200 #7300
     dict['rp_keyframes'] = []
     dict['rp_positions'] = []
     dict['temp_list'] = []

scripts/actionPlayer.py

 'fak_judo',
 'fak_frigid',
 'fak_fsonefoot',
-'fak_onefoot']
+'fak_onefoot',
+'reg_back_invert']
 
 state_b = ['reg_jump',
 'reg_walk_air',
 	aState = check_land(rA, aState, own)
 	newState = aState
 	og_state = own['aState']
-
+	#print(aState)
 	if aState in state_a:
 
 		action = getattr(actionsFSMlist, aState)
 			actionPlayer(getattr(actionsFSMlist, intro))	
 		else:
 			actionPlayer(action)
-		newState = check_exit(aState, rA, timer, action)		
+		newState = check_exit(aState, rA, timer, action)
+
+		if aState == 'reg_back_invert':
+			print('fffffffffffffffffffffffffffffffff')		
 
 	elif aState in state_b:
 		action = getattr(actionsFSMlist, aState)

scripts/actionsFSMlist.py

 
 reg_manuallist = ['reg_manual', 'reg_nmanual', 'fak_manual', 'fak_nmanual']
 
-reg_grindlist = ['reg_5050', 'reg_fsboard', 'reg_tailg', 'reg_tailgr', 'reg_tailgl', 'reg_noseg', 'reg_nosegr', 'reg_nosegl', 'reg_noseslide', 'reg_tailslide', 'reg_bsboard']
+reg_grindlist = ['reg_5050', 'reg_fsboard', 'reg_tailg', 'reg_tailgr', 'reg_tailgl', 'reg_noseg', 'reg_nosegr', 'reg_nosegl', 'reg_noseslide', 'reg_tailslide', 'reg_bsboard', 'reg_back_invert']
 
 fak_grindlist = ['fak_5050', 'fak_fsboard', 'fak_tailg', 'fak_tailgr', 'fak_tailgl', 'fak_noseg', 'fak_nosegr', 'fak_nosegl', 'fak_noseslide', 'fak_tailslide', 'fak_bsboard']
 
 #**********************#
 
 
+reg_back_invert_in = a_class(
+	#player armature action name, start, end frames
+	'reg_back_invert_in.001', 1, 30,
+	#deck action name, start, end frames  
+	'b_reg', 1, 30,
+	#layer, speed, mode (0 = play, 1 = loop), blendin
+	1, 1, 0, 10,
+	#intro, length
+	None, 0,
+	#exits
+	['reg_5050'],
+	#force exit, frame
+	'reg_5050', 19,
+	#opposite
+	'fak_5050')
 
+reg_back_invert = a_class(
+	#player armature action name, start, end frames
+	'reg_back_invert_in.001', 30, 30,
+	#deck action name, start, end frames  
+	'b_reg', 1, 30,
+	#layer, speed, mode (0 = play, 1 = loop), blendin
+	1, .5, 0, 10,
+	#intro, length
+	'reg_back_invert_in', 30,
+	#exits
+	['reg_air', 'reg_roll'] + reg_fliplist,
+	#force exit, frame
+	None, 0,
+	#opposite
+	'fak_5050')
 
 
 

scripts/birds.py

 
     life(own)    
     do_birds(scene, own, cont)  
-    print('birding')    
+    #print('birding')    

scripts/camFSM.py

         if self.FSM.stateLife > 60:
             dict = bge.logic.globalDict
             own = dict['p1c']
+            scene = bge.logic.getCurrentScene()
+            #dict['camera'].object = scene.objects['camobj']
             if own['grinding'] == True:
-                scene = bge.logic.getCurrentScene()
+                
                 ce = scene.objects['cam_helper2']
                 ce.worldPosition = own.worldPosition
                 ce.worldOrientation = own.worldOrientation
                 ce.applyMovement([xval,yval,0], True)
                 dict['camera'].worldPosition = dict['camera'].worldPosition.lerp(ce.worldPosition, stre)
 
-
-
-                # cont = bge.logic.getCurrentController()
-                # scene = bge.logic.getCurrentScene()
-                # camActu = cont.actuators['Camera']
-                # #camActu.object = scene.objects[cobj]
-                # camActu.damping = 0
-                # #camActu.max = cmax
-                # #camActu.height = cheight
-                # cont.activate(camActu)
-
-
-            #activate_camera('camCube', 1.5, 3, 2)
             new_state = get_request_state(self.__class__.__name__)
 
             if new_state:

scripts/camera.py

 scene = bge.logic.getCurrentScene()
 import camFSM
 import birds
+import sound_man
 
 def main(cont):
     #camFSM.main(cont)
                 if cam.height < 2:
                     cam.height = cam_height + .1
                     cam.max = cam.max - .2
-                    print('small move', cam.height, dict['cam_height'])
+                    #print('small move', cam.height, dict['cam_height'])
                 elif cam.height >= 2 and cam.height < 4:
                     cam.height = cam_height + .05
                     cam.max = cam.max - .05
-                    print('big move')
+                    #print('big move')
 
     if dict['menu_idle_timer'] > 300:
         move_len = 2048
             cam.max = new_max
         except:
             pass
+    #print(own.actuators['Camera'].object)        
     set_lens_dist()        
     get_cam_state()
     camFSM.main(cont)
-    birds.main(cont, scene)
+    birds.main(cont, scene)
+    sound_man.main(cont)

scripts/controller2.py

 from mathutils import Vector
 import mathutils
 import joytimers
+import sound_man
 
 def main():
     scene = bge.logic.getCurrentScene()
     pos = own.localPosition
     rot = own.getAxisVect([0.0, 0.0, 1.0])
     gray = cont.sensors["gRay"]
-    pop = cont.actuators["pop"]
+    #pop = cont.actuators["pop"]
     grindHit = own["grindHit"]
-    grindCement = cont.actuators["grind_cement"]
-    grindRail = cont.actuators["grind_rail"]
+    #grindCement = cont.actuators["grind_cement"]
+    #grindRail = cont.actuators["grind_rail"]
     grindSound = own["grindSound"]
     skater = scene.objects["Char4"]
     deck = scene.objects["b_deck"]
                 dist = dist * 2
                 if dist > 1:
                     dist = 1
-                own.actuators["land"].volume = dist
-                sact = own.actuators["land"]
-                sact.stopSound()
-                cont.activate(own.actuators["land"])
+                #own.actuators["land"].volume = dist
+                #sact = own.actuators["land"]                
+                #sact.stopSound()
+                #cont.activate(own.actuators["land"])
+                cam['sndmgr'].queue_sound(['land', own, cam])
                 own['land_sound'] = 1
             if grindDar == 1:
                 pass
             own['jump_timer'] = jump_timer
 
         if zvel < 7 and jump_timer == 60:
-            cont.activate(own.actuators["pop"])
+            cam['sndmgr'].queue_sound(['pop', own, cam])
+            #cont.activate(own.actuators["pop"])
             own['pop_sound'] = 1
             #print("jump")
             #
             if own["wallride"] == "R":
                 force = [0, 170, 0]
                 own.applyForce(force, True)
-                cont.activate(own.actuators["pop2"])
+                #cont.activate(own.actuators["pop2"])
+                cam['sndmgr'].queue_sound(['pop', own, cam])
                 jump_timer = 60
                 own['jump_timer'] = jump_timer
             if own["wallride"] == "L":
                 force = [0, -170, 0] #325
                 own.applyForce(force, True)
-                cont.activate(own.actuators["pop2"])
+                #cont.activate(own.actuators["pop2"])
+                cam['sndmgr'].queue_sound(['pop', own, cam])
                 jump_timer = 60
                 own['jump_timer'] = jump_timer
 
         if onGround and grindDar == 0 and own['invert_on'] == 0:
             num1 = .05
             num2 = .25
+            v = .1
+            p = 1
             if linVelocity.x <= -num1 and linVelocity.x >= num1:
-                own.actuators["sroll"].volume = .0001
-                cont.deactivate(own.actuators["sroll"])
-                own.actuators["sroll"].stopSound()
+                #own.actuators["sroll"].volume = .0001
+                #cont.deactivate(own.actuators["sroll"])
+                #own.actuators["sroll"].stopSound()
+                cam['sndmgr'].stop_sound(['roll'])
             if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):
-                own.actuators["sroll"].volume = .02
-                own.actuators["sroll"].pitch = .65
+                #own.actuators["sroll"].volume = .02
+                #own.actuators["sroll"].pitch = .65
+                v = .02
+                p = .65
             num1 = .25
             num2 = .5
             if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):
-                own.actuators["sroll"].volume = .03
-                own.actuators["sroll"].pitch = .7
+                #own.actuators["sroll"].volume = .03
+                #own.actuators["sroll"].pitch = .7
+                v = .03
+                p = .7
             num1 = .5
             num2 = .75
             if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):
-                own.actuators["sroll"].volume = .04
-                own.actuators["sroll"].pitch = .75
+                #own.actuators["sroll"].volume = .04
+                #own.actuators["sroll"].pitch = .75
+                v = .04
+                p = .75
             num1 = .75
             num2 = 1
             if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):
-                own.actuators["sroll"].volume = .05
-                own.actuators["sroll"].pitch = .8
+                #own.actuators["sroll"].volume = .05
+                #own.actuators["sroll"].pitch = .8
+                v = .05
+                p = .8
             num1 = 1
             num2 = 1.5
             if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):
-                own.actuators["sroll"].volume = .06
-                own.actuators["sroll"].pitch = .85
+                #own.actuators["sroll"].volume = .06
+                #own.actuators["sroll"].pitch = .85
+                v = .06
+                p = .85
             num1 = 1.5
             num2 = 2
             if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):
-                own.actuators["sroll"].volume = .07
-                own.actuators["sroll"].pitch = .9
+                #own.actuators["sroll"].volume = .07
+                #own.actuators["sroll"].pitch = .9
+                v = .07
+                p = .9
             num1 = 2
             num2 = 3
             if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):
-                own.actuators["sroll"].volume = .08
-                own.actuators["sroll"].pitch = .95
+                #own.actuators["sroll"].volume = .08
+                #own.actuators["sroll"].pitch = .95
+                v = .08
+                p = .95
             num1 = 3
             num2 = 4
             if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):
-                own.actuators["sroll"].volume = .09
-                own.actuators["sroll"].pitch = 1
+                #own.actuators["sroll"].volume = .09
+                #own.actuators["sroll"].pitch = 1
+                v = .09
+                p = 1.0
             num1 = 4
             num2 = 5
             if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):
-                own.actuators["sroll"].volume = .11
-                own.actuators["sroll"].pitch = 1.05
+                #own.actuators["sroll"].volume = .11
+                #own.actuators["sroll"].pitch = 1.05
+                v = .11
+                p = 1.05
             num1 = 5
             num2 = 6
             if (linVelocity.x > num1 and linVelocity.x < num2) or (linVelocity.x < -num1 and linVelocity.x > -num2):
-                own.actuators["sroll"].volume = .1
-                own.actuators["sroll"].pitch = 1.1
-            own.actuators['sroll'].mode = 2
-            cont.activate(own.actuators["sroll"])
+                #own.actuators["sroll"].volume = .1
+                #own.actuators["sroll"].pitch = 1.1
+                v = .1
+                p = 1.1
+            #own.actuators['sroll'].mode = 2
+            #cont.activate(own.actuators["sroll"])
+            v = v * 2
+            cam['sndmgr'].queue_sound(['roll', own, cam, v, p])    
+
         if grindDar == 1 or own['invert_on'] == 1:
-            own.actuators["sroll"].volume = .0001
-            cont.deactivate(own.actuators["sroll"])
-            own.actuators["sroll"].stopSound()
+            #own.actuators["sroll"].volume = .0001
+            #cont.deactivate(own.actuators["sroll"])
+            #own.actuators["sroll"].stopSound()
+            cam['sndmgr'].stop_sound(['roll'])
+
         #in air
         if not onGround:
-            own.actuators["sroll"].volume = .0001
-            cont.deactivate(own.actuators["sroll"])
-            own.actuators["sroll"].stopSound()
-        act = cont.actuators["sroll"]
-        own['sroll_vol'] = act.volume
-        own['sroll_pitch'] = act.pitch
+            #own.actuators["sroll"].volume = .0001
+            #cont.deactivate(own.actuators["sroll"])
+            #own.actuators["sroll"].stopSound()
+            cam['sndmgr'].stop_sound(['roll'])
+        
+        #act = cont.actuators["sroll"]
+        #own['sroll_vol'] = act.volume
+        #own['sroll_pitch'] = act.pitch
 
     def wheelroll():
         #still
     
             local = True # use world axis
             own.applyRotation( rotation, local)
-            print('rotation = ', rotation)
+            #print('rotation = ', rotation)
             if onGround:
                 #print("med turn")
                 if STANCE == 0:
                 vel = linVelocity.y
             else:
                 vel = 0
-            if grindSound == "rail":
-                cont.deactivate(own.actuators['grind_cement'])
-                num1 = .000
-                num2 = .05
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_rail"].volume = .0001
-                    own.actuators["grind_rail"].pitch = .6
-                num1 = .05
-                num2 = .25
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_rail"].volume = .05
-                    own.actuators["grind_rail"].pitch = .7
-
-                num1 = .25
-                num2 = .5
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_rail"].volume = .1
-                    own.actuators["grind_rail"].pitch = .75
-                num1 = .5
-                num2 = .75
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_rail"].volume = .14
-                    own.actuators["grind_rail"].pitch = .8
-                num1 = .75
-                num2 = 1
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_rail"].volume = .17
-                    own.actuators["grind_rail"].pitch = .85
-                num1 = 1
-                num2 = 1.25
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_rail"].volume = .18
-                    own.actuators["grind_rail"].pitch = .9
-                num1 = 1.25
-                num2 = 2
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_rail"].volume = .19
-                    own.actuators["grind_rail"].pitch = .95
-                num1 = 2
-                num2 = 40
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_rail"].volume = .19
-                    own.actuators["grind_rail"].pitch = 1
-                cont.activate(own.actuators['grind_rail'])
-
-            if grindSound == "concrete":
-            #play sound
-                cont.deactivate(own.actuators['grind_rail'])
-                num1 = .000
-                num2 = .05
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_cement"].volume = .01
-                    own.actuators["grind_cement"].pitch = .6
-                num1 = .05
-                num2 = .25
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_cement"].volume = .05
-                    own.actuators["grind_cement"].pitch = .7
-
-                num1 = .25
-                num2 = .5
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_cement"].volume = .1
-                    own.actuators["grind_cement"].pitch = .75
-                num1 = .5
-                num2 = .75
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_cement"].volume = .14
-                    own.actuators["grind_cement"].pitch = .8
-                num1 = .75
-                num2 = 1
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_cement"].volume = .17
-                    own.actuators["grind_cement"].pitch = .85
-                num1 = 1
-                num2 = 1.25
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_cement"].volume = .18
-                    own.actuators["grind_cement"].pitch = .9
-                num1 = 1.25
-                num2 = 2
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_cement"].volume = .19
-                    own.actuators["grind_cement"].pitch = .95
-                num1 = 2
-                num2 = 40
-                if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
-                    own.actuators["grind_cement"].volume = .19
-                    own.actuators["grind_cement"].pitch = 1
-                cont.activate(own.actuators['grind_cement'])
+            v = .0001
+            p = 1.0
+            #if grindSound == "rail":
+                #cont.deactivate(own.actuators['grind_cement'])
+            num1 = .000
+            num2 = .05
+            if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+                #own.actuators["grind_rail"].volume = .0001
+                #own.actuators["grind_rail"].pitch = .6
+                v = .00001
+                p = .6
+            num1 = .05
+            num2 = .25
+            if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+                #own.actuators["grind_rail"].volume = .05
+                #own.actuators["grind_rail"].pitch = .7
+                v = .05
+                p = .7
+            num1 = .25
+            num2 = .5
+            if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+                #own.actuators["grind_rail"].volume = .1
+                #own.actuators["grind_rail"].pitch = .75
+                v = .1
+                p = .75
+            num1 = .5
+            num2 = .75
+            if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+                #own.actuators["grind_rail"].volume = .14
+                #own.actuators["grind_rail"].pitch = .8
+                v = .14
+                p = .8
+            num1 = .75
+            num2 = 1
+            if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+                #own.actuators["grind_rail"].volume = .17
+                #own.actuators["grind_rail"].pitch = .85
+                v = .17
+                p = .85
+            num1 = 1
+            num2 = 1.25
+            if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+                #own.actuators["grind_rail"].volume = .18
+                #own.actuators["grind_rail"].pitch = .9
+                v = .18
+                p = .9
+            num1 = 1.25
+            num2 = 2
+            if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+                #own.actuators["grind_rail"].volume = .19
+                #own.actuators["grind_rail"].pitch = .95
+                v = .19
+                p = .95
+            num1 = 2
+            num2 = 40
+            if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+                #own.actuators["grind_rail"].volume = .19
+                #own.actuators["grind_rail"].pitch = 1
+                v = .19
+                p = 1.0
+            #cont.activate(own.actuators['grind_rail'])
+
+            if grindSound == 'rail':
+                cam['sndmgr'].queue_sound(['grind_rail', own, cam, v, p]) 
+            elif grindSound == 'cement':
+                cam['sndmgr'].queue_sound(['grind_cement', own, cam, v, p])     
+
+            # if grindSound == "concrete":
+            # #play sound
+            #     cont.deactivate(own.actuators['grind_rail'])
+            #     num1 = .000
+            #     num2 = .05
+            #     if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+            #         own.actuators["grind_cement"].volume = .01
+            #         own.actuators["grind_cement"].pitch = .6
+            #     num1 = .05
+            #     num2 = .25
+            #     if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+            #         own.actuators["grind_cement"].volume = .05
+            #         own.actuators["grind_cement"].pitch = .7
+
+            #     num1 = .25
+            #     num2 = .5
+            #     if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+            #         own.actuators["grind_cement"].volume = .1
+            #         own.actuators["grind_cement"].pitch = .75
+            #     num1 = .5
+            #     num2 = .75
+            #     if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+            #         own.actuators["grind_cement"].volume = .14
+            #         own.actuators["grind_cement"].pitch = .8
+            #     num1 = .75
+            #     num2 = 1
+            #     if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+            #         own.actuators["grind_cement"].volume = .17
+            #         own.actuators["grind_cement"].pitch = .85
+            #     num1 = 1
+            #     num2 = 1.25
+            #     if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+            #         own.actuators["grind_cement"].volume = .18
+            #         own.actuators["grind_cement"].pitch = .9
+            #     num1 = 1.25
+            #     num2 = 2
+            #     if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+            #         own.actuators["grind_cement"].volume = .19
+            #         own.actuators["grind_cement"].pitch = .95
+            #     num1 = 2
+            #     num2 = 40
+            #     if (vel > num1 and vel < num2) or (vel < -num1 and vel > -num2):
+            #         own.actuators["grind_cement"].volume = .19
+            #         own.actuators["grind_cement"].pitch = 1
+            #     cont.activate(own.actuators['grind_cement'])
         else:
-            cont.deactivate(own.actuators['grind_cement'])
-            cont.deactivate(own.actuators['grind_rail'])
+            #cont.deactivate(own.actuators['grind_cement'])
+            #cont.deactivate(own.actuators['grind_rail'])
+            cam['sndmgr'].stop_sound(['grind_rail']) 
+            cam['sndmgr'].stop_sound(['grind_cement']) 
 
     def record_grindsound():
-        dropin = own['dropinTimer']
-        lif = own['last_invert_frame']
-        if grindHit == True and dropin == 0 and own['invert_on'] == 0 and own["LAST_GRIND"] == True and own["nogrindsound"] == 0 and (frame - lif > 13):
-            if grindSound == "concrete":
-                act = own.actuators["grind_cement"]
-                own['grindcement_vol'] = act.volume
-                own['grindcement_pitch'] = act.pitch
-            elif grindSound == "rail":
-                act = own.actuators["grind_rail"]
-                own['grindrail_vol'] = act.volume
-                own['grindrail_pitch'] = act.pitch
-        if own["LAST_GRIND"] == False:
-            own['grindcement_vol'] = 0
-            own['grindcement_pitch'] = 0
-            own['grindrail_vol'] = 0
-            own['grindrail_pitch'] = 0
+        pass
+        # dropin = own['dropinTimer']
+        # lif = own['last_invert_frame']
+        # if grindHit == True and dropin == 0 and own['invert_on'] == 0 and own["LAST_GRIND"] == True and own["nogrindsound"] == 0 and (frame - lif > 13):
+        #     if grindSound == "concrete":
+        #         act = own.actuators["grind_cement"]
+        #         own['grindcement_vol'] = act.volume
+        #         own['grindcement_pitch'] = act.pitch
+        #     elif grindSound == "rail":
+        #         act = own.actuators["grind_rail"]
+        #         own['grindrail_vol'] = act.volume
+        #         own['grindrail_pitch'] = act.pitch
+        # if own["LAST_GRIND"] == False:
+        #     own['grindcement_vol'] = 0
+        #     own['grindcement_pitch'] = 0
+        #     own['grindrail_vol'] = 0
+        #     own['grindrail_pitch'] = 0
 
     def grind():
         grindsound()
         wheel2.stopAction(2)
         wheel3.stopAction(2)
         wheel4.stopAction(2)
-        cont.deactivate(own.actuators["sroll"])
-        sact = own.actuators["sroll"]
-        sact.volume = .0001
-        own.actuators["sroll"].stopSound()
+        #cont.deactivate(own.actuators["sroll"])
+        #sact = own.actuators["sroll"]
+        #sact.volume = .0001
+        #own.actuators["sroll"].stopSound()
+        cam['sndmgr'].stop_sound(['roll'])
         own['offboard_vel'] = own.linearVelocity
         own['walk_timer'] = 0
 
             else:
                 own['requestAction'] = 'fak_revert1'
         own['revert_timer'] = 20
-        cont.activate(own.actuators["revertSound"])
+        #cont.activate(own.actuators["revertSound"])
+        cam['sndmgr'].queue_sound(['revert', own, cam])
         own['revert_sound'] = 1
         dict['trick_string'] = 'Revert'
 
             else:
                 own['requestAction'] = 'fak_revert2'
         own['revert_timer'] = 20
-        cont.activate(own.actuators["revertSound"])
+        #cont.activate(own.actuators["revertSound"])
+        cam['sndmgr'].queue_sound(['revert', own, cam])
         own['revert_sound'] = 1
         dict['trick_string'] = 'Revert'
 
             else:
                 own['requestAction'] = 'fak_revert1'
         own['revert_timer'] = 20
-        cont.activate(own.actuators["revertSound"])
+        #cont.activate(own.actuators["revertSound"])
+        cam['sndmgr'].queue_sound(['revert', own, cam])
         own['revert_sound'] = 1
         dict['trick_string'] = 'Revert'
 
             else:
                 own['requestAction'] = 'fak_revert2'
         own['revert_timer'] = 20
-        cont.activate(own.actuators["revertSound"])
+        #cont.activate(own.actuators["revertSound"])
+        cam['sndmgr'].queue_sound(['revert', own, cam])
         own['revert_sound'] = 1
         dict['trick_string'] = 'Revert'
 
 
     #start button
     if stBut == True:
-        own.actuators["sroll"].volume = .0001
-        cont.deactivate(own.actuators["sroll"])
-        own.actuators["sroll"].stopSound()
+        #own.actuators["sroll"].volume = .0001
+        #cont.deactivate(own.actuators["sroll"])
+        #own.actuators["sroll"].stopSound()
+        cam['sndmgr'].stop_sound(['roll'])
     if (stBut == False and dict['last_stBut'] == True) or dict['kb_en'] == 1:
         if own['pause_on'] == True:
             own['pause_on'] = False

scripts/grindV2.py

         no_grind = 0
     if dict['lBump'] and dict['rBump']:
         no_grind = 1
-    elif dict['lBump']:
-        no_grind = 0        
+    elif (dict['lBump'] and not dict['rBump']) or (dict['rBump'] and not dict['lBump']):
+        no_grind = 0       
 #---------###########___###########-----------
 #start new                     #######
 ##----------##############----------############
         rot *= 100
 
         #print(own['inverting'])
-        if frames_grinding > 20 and own['inverting'] == False:
+        #if frames_grinding > 20 and own['inverting'] == False:
+        if frames_grinding > 20:    
             #print("setting stance")
             if (rot == 90 or rot == -270) and STANCE == True:
                 #print("90 fak stance")
     def invertpos(detectedObjects):
         minDist = None
         nearestObject = None
-        for obj in detectedObjects:
-            dist = own.getDistanceTo(obj)
-            if (minDist is None or dist < minDist):
-                nearestObject = obj
-                minDist = dist
-        if nearestObject != None:
-            own.linearVelocity.x = 0
-            own.linearVelocity.y = 0
+        # for obj in detectedObjects:
+        #     dist = own.getDistanceTo(obj)
+        #     if (minDist is None or dist < minDist):
+        #         nearestObject = obj
+        #         minDist = dist
+        # if nearestObject != None:
+        #     own.linearVelocity.x = 0
+        #     own.linearVelocity.y = 0
 
     #if grindDar.positive == False and grindTouch.triggered and grindold == 0 and dropin == 0 and grind_jump == 0 and own["grindoutturn"] == 0 and gt_cd == 0 and manual == 0 and no_grind == 0 and nearestObject != lastObject and own['grindjumpturn'] == 0 and own['gt_cd2'] == 0 and own['air_mover'] == False:
         #print("touching, no dar")
 #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
         #init grind
 
+        #print('invert on', invert_on)
         if invert_on:
             invertpos(detectedObjects)
             own['inverting'] = True
         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 or dict['rBump'] == 1 or dict['lBump'] == 1):
+        #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 or dict['rBump'] == 1 or dict['lBump'] == 1):
+        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 own['air_mover'] == False and no_grind_pull == 0 and own['grindjumpturn'] == 0 and grind_jump == 0 and (own['airup'] == 0 or dict['rBump'] == 1 or dict['lBump'] == 1):            
             #print("grinding")
             grind_height_dif = (own.worldPosition[2] - nearestObject.worldPosition[2]) - .287
 
         minDist = None
         nearestObject = None
         print('doing invert funct')
-        for obj in invertObjs:
-            dist = own.getDistanceTo(obj)
-            if (minDist is None or dist < minDist):
-                nearestObject = obj
-                minDist = dist
-        vect = nearestObject.getAxisVect([1.0, 0.0, 0.0])
-        own.worldPosition = [nearestObject.worldPosition.x, nearestObject.worldPosition.y, nearestObject.worldPosition.z +.1]
+        # for obj in invertObjs:
+        #     dist = own.getDistanceTo(obj)
+        #     if (minDist is None or dist < minDist):
+        #         nearestObject = obj
+        #         minDist = dist
+        # vect = nearestObject.getAxisVect([1.0, 0.0, 0.0])
+        # own.worldPosition = [nearestObject.worldPosition.x, nearestObject.worldPosition.y, nearestObject.worldPosition.z +.1]
 
     def set_pregrind_vel():
         if grindDar.triggered == False and ray.triggered == False:

scripts/ragdoll.py

             scene.objects[armature].stopAction(2)
             scene.objects[armature].stopAction(7)
             scene.objects[armature].update()
-            cont.actuators['Camera'].object = scene.objects['ragdoll_parent']
+            
+            #cont.actuators['Camera'].object = scene.objects['ragdoll_parent']
+            #scene.objects['control_cube.002'].worldPosition = scene.objects['control_cube.002'].worldPosition.lerp(scene.objects['ragdoll_parent'].worldPosition, .01)
+            scene.objects['control_cube.002'].worldPosition = scene.objects['ragdoll_parent'].worldPosition
+
+
+
             wp = scene.objects['camCube'].worldPosition - scene.objects['ragdoll_parent'].worldPosition
             wp = wp * .9
             cont.actuators['Camera'].height = 2.0
                 own.worldPosition.z += .4
                 cont.activate(cont.actuators['walk']) 
 
-            if dict['lUD'] < -.08:
+            if dict['lUD'] < -.08 and own['rd_incer'] > 200:
                 physBody = own['rd_rb']
                 excludes = ['npc_ed_arm_phys_hand.R', 'npc_ed_arm_phys_hand.L', 'npc_ed_arm_phys_forearm.fk.L', 'npc_ed_arm_phys_forearm.fk.R', 'npc_ed_arm_phys_upper_arm.fk.L', 'npc_ed_arm_phys_upper_arm.fk.R']
                 #excludes = []
                 scene.objects['npc_ed_arm_phys_clavicle.L'].applyForce([0,0,200], False)
                 scene.objects['npc_ed_arm_phys_clavicle.R'].applyForce([0,0,200], False)
 
-            if dict['rUD'] > .08:
+            if dict['rUD'] > .08 and own['rd_incer'] > 200:
                 scene.objects['npc_ed_arm_phys_master'].applyForce([0,600,0], True)
         else:
             update_rb(own['rd_rb'], scene)   

scripts/sound_man.py

+#sound_man.py
+#shuvit sound effects manager
+
+import bge
+import aud
+
+def init_sounds(self):
+	#pop
+
+	self.pop = sounds('pop')
+	self.land = sounds('land')
+	self.roll = sounds('roll')
+	self.revert = sounds('revert')
+	self.roll.loop = True
+	self.grind_cement = sounds('grind_cement')
+	self.grind_cement.loop = True
+	self.grind_cement.pingpong = True
+	self.grind_rail = sounds('grind_rail')
+	self.grind_rail.loop = True
+	self.grind_rail.pingpong = True
+	#self.pop.name = 'pop'
+
+
+
+class sound_manager:
+	def __init__(self):
+		self.queue = []
+		self.history = []
+		self.h_queue = []
+		self.gd = bge.logic.globalDict
+		init_sounds(self)
+		#self.pop = sounds()
+
+	def queue_sound(self, sound):
+		self.queue.append(sound)
+
+	def remove_sound(self, sound):
+		self.queue.remove(sound)
+
+	def play_queue(self):
+		if self.queue is not []:
+			#pass
+			self.h_queue = self.queue.copy()
+			#print('og', self.h_queue, self.queue)
+			for ev in self.queue:
+				#get function from string at position 0 of event
+				result = getattr(self, ev[0])
+				#print(result)
+				#print(result.name)
+				if result.loop:
+					result.loop_play(ev[1], ev[2], ev[3], ev[4])
+				else:
+					result.play(ev[1], ev[2])
+
+				self.queue.remove(ev)
+			
+
+			self.queue = []	
+
+	def play_hist(self):
+		if self.h_queue is not []:
+			#pass
+			
+			for ev in self.h_queue:
+				#get function from string at position 0 of event
+				result = getattr(self, ev[0])
+				#print(result)
+				#print(result.name)
+				if result.name == 'roll':
+				#if result.loop:
+					result.loop_play(ev[1], ev[2], ev[3], ev[4])
+				else:
+					result.play(ev[1], ev[2])
+
+				#self.queue.remove(ev)				
+
+	def update(self):
+		self.play_queue()
+		#print('queued sounds', self.queue)
+
+	def stop_sound(self, sound):
+		c = getattr(self, sound[0])
+		if c.handle_buffered:
+			c.handle_buffered.stop()
+
+	def Record(self):
+		self.history.append(self.h_queue)
+		#self.history.insert(0, self.h_queue)
+		
+		#print(self.h_queue, 'appended to history')
+		#self.history.append(self.h_queue)
+		#print('appending', self.h_queue)
+		l = len(self.history)
+		if l > ((self.gd['replay_record_length'])):
+
+			self.history.pop(0)
+			#self.history.pop(self.gd['replay_record_length'])
+			#self.history.pop(0)
+		#print(l, 'history length', ((self.gd['replay_record_length']) -1))
+
+	def h_Playback(self, frame):
+		#frame *= 2
+		#frame = int(frame /2)
+		try:	
+			self.h_queue = self.history[frame]
+			#self.h_queue2 = self.history[frame-1]
+			#print(self.history[frame], self.queue, frame, 'replay queue')
+		except:
+			print('replay audio not playing', frame, len(self.history))
+		#print('h_queue', self.h_queue, frame)
+		if self.h_queue is not []:
+			for ev in self.h_queue:
+				result = getattr(self, ev[0])
+				#print('ev0', ev[0])
+				if result.loop:
+					#result.loop_play(ev[1], ev[2], ev[3], ev[4])
+					pass
+				else:
+					result.play(ev[1], ev[2])
+					#print('... playing', result.name, frame, len(self.history))
+		# if self.h_queue2 is not []:
+		# 	for ev in self.h_queue2:
+		# 		result = getattr(self, ev[0])
+		# 		if result.loop:
+		# 			result.loop_play(ev[1], ev[2], ev[3], ev[4])
+		# 		else:
+		# 			result.play(ev[1], ev[2])					
+
+
+		#print(self.history)
+
+class sounds(sound_manager):
+	def __init__(self, name):
+		self.name = name
+		self.obj = None
+		self.loop = False
+		self.pingpong = False
+		self.listener_obj = None
+		self.pitch = 1.0	
+		self.volume = 0.9
+		self.device = aud.device()
+		self.path = bge.logic.expandPath('//sounds')
+		self.factory = aud.Factory(self.path + '/' + self.name + '.wav')
+		self.factory_buffered = aud.Factory.buffer(self.factory)
+		self.handle_buffered = None
+		#self.handle = self.device.play(factory)
+
+	def play(self, obj, listener):
+		
+		scene = bge.logic.getCurrentScene()
+
+		self.device.distance_model = aud.AUD_DISTANCE_MODEL_LINEAR
+		self.device.listener_location = obj.worldPosition
+		self.device.listener_velocity = obj.getLinearVelocity()
+		self.device.volume = self.volume
+
+		handle_buffered = self.device.play(self.factory_buffered)
+		handle_buffered.relative = False
+		handle_buffered.location = listener.worldPosition
+		handle_buffered.velocity = listener.getLinearVelocity()
+		handle_buffered.distance_maximum = 50
+		handle_buffered.distance_reference = .1
+
+
+	def loop_play(self, obj, listener, v, p):
+		
+		scene = bge.logic.getCurrentScene()
+
+		self.device.distance_model = aud.AUD_DISTANCE_MODEL_LINEAR
+		self.device.listener_location = obj.worldPosition
+		self.device.listener_velocity = obj.getLinearVelocity()
+		#self.device.volume = self.volume
+		
+		if not self.handle_buffered or not self.handle_buffered.status:
+			self.handle_buffered = self.device.play(self.factory_buffered)
+		#print(self.handle_buffered.status)
+		self.factory_buffered.loop(-1)
+		
+		if self.pingpong:
+			self.factory_buffered.pingpong()
+		
+		self.handle_buffered.volume = v
+		self.handle_buffered.pitch = p
+		self.handle_buffered.relative = False
+		self.handle_buffered.location = listener.worldPosition
+		self.handle_buffered.velocity = listener.getLinearVelocity()
+		self.handle_buffered.distance_maximum = 50
+		self.handle_buffered.distance_reference = .1	
+		
+
+
+def main(cont):
+	own = cont.owner
+	if 'sound_man_inited' not in own:
+		own['sound_man_inited'] = True
+
+		sm = sound_manager()
+		own['sndmgr'] = sm
+
+	dict = bge.logic.globalDict
+	
+	#if not dict['playback']:
+		#own['sndmgr'].Record()
+	if not dict['playback']:
+		own['sndmgr'].update()
+
+	#if dict['playback']:
+		#own['sndmgr'].Playback()	
+	

scripts/walk.py

             print("start walking")
             own['walk_idling'] = 0
             if own['framenum'] > 100 and own['fall'] == False:
-                cont.activate(own.actuators['pop'])
+                #cont.activate(own.actuators['pop'])
+                camobj['sndmgr'].queue_sound(['pop', cube, camobj])
             own['getoffboard'] = False
             own["walk_idle_frame"] = own["framenum"]
             own['grindcement_vol'] = 0
             own['grindrail_vol'] = 0
             own['grindrail_pitch'] = 0 
             own['sroll_vol'] = 0
-            own['sroll_pitch'] = 0   
+            own['sroll_pitch'] = 0 
+
             
             #camobj.worldPosition.z += 4              
             try:
     #printplaying() 
 
     own.alignAxisToVect([0.0,0.0,1.0], 2, .03)
-    own.actuators["sroll"].stopSound() 
+    #own.actuators["sroll"].stopSound() 
+    camobj['sndmgr'].stop_sound(['roll'])
     wheel1 = scene.objects["wheel1"]
     wheel2 = scene.objects["wheel2"]
     wheel3 = scene.objects["wheel3"]

scripts/walker_states.py

 		self.target = 'larryTarget'
 		self.npcArm = self.own.children['npc']
 		self.scene = bge.logic.getCurrentScene()
-		self.actu = self.cont.actuators['Steering']
+		
 
 		nm = self.own['navMesh']
-		pt = nm.findPath(self.own.worldPosition, self.scene.objects[self.target].worldPosition)
-		print('path is', pt)		
-
-		if 'larryTarget' in self.scene.objects:
-				self.actu.target = self.target			
-				self.actu.velocity = 1.5
-				self.actu.turnspeed = 20
-				self.actu.facingMode = False
-				self.actu.navmesh = self.own['navMesh']
-				self.cont.activate(self.actu)
-
+		self.pt = nm.findPath(self.own.worldPosition, self.scene.objects[self.target].worldPosition)
+		
+		print('target1')
 		super(Target1, self).Enter()
 		
 	def Execute(self):
 		#print('Tracking target 1.', self.npcFSM.stateLife)
 		self.npcFSM.stateLife += 1
-		duration = 500
+		duration = 50000
+		#print('path', self.pt)
+
+		if len(self.pt) > 0:
+			target = self.pt[0]
+			vg = self.own.getVectTo(target)
+			dist = vg[0]
+			v = vg[1]
+			self.own.alignAxisToVect(v, 0, .5)
+			self.own.alignAxisToVect([0,0,1], 2, 1)
+			#print(dist)
+			if dist > 1.5:
+				x = 10
+				max_vel = 1.5
+				if self.own.linearVelocity.x < max_vel:
+					self.own.applyForce([x, 0, 5], True)
+			else:
+				self.pt.remove(self.pt[0])
+		else:
+			print('goal reached')	
+			self.npcFSM.ToTransition('toTarget2')	
+
+
+
+
 		if self.npcFSM.stateLife > duration:
 			num = randint(1,2)
-			if num == 1:
-				self.npcFSM.ToTransition('toTarget2')
-			elif num ==2:
-				self.npcFSM.ToTransition('toTarget3')	
-			else:
-				self.npcFSM.ToTransition('toIdle')
+			# if num == 1:
+			# 	self.npcFSM.ToTransition('toTarget2')
+			# elif num ==2:
+			# 	self.npcFSM.ToTransition('toTarget2')	
+			# else:
+			# 	self.npcFSM.ToTransition('toIdle')
 		else:	
-			self.cont.activate(self.actu)	
+			#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) 
+		#self.cont.deactivate(self.actu) 
+		pass	
 
 class Target2(State):
 	def __init__(self,npcFSM):
 		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 = 20
-				#self.actu.facingMode = False
-				#self.actu.navmesh = self.own['navMesh']
-				#self.cont.activate(self.actu)
-
+		
+		nm = self.own['navMesh']
+		self.pt = nm.findPath(self.own.worldPosition, self.scene.objects[self.target].worldPosition)
+		print('target2')
 		super(Target2, self).Enter()
 		
 	def Execute(self):
 		#print('Tracking target 2.', self.npcFSM.stateLife)
 		self.npcFSM.stateLife += 1
-		duration = 1000
+		duration = 10000
+
+
+
+		if len(self.pt) > 0:
+			target = self.pt[0]
+			vg = self.own.getVectTo(target)
+			dist = vg[0]
+			v = vg[1]
+			self.own.alignAxisToVect(v, 0, .5)
+			self.own.alignAxisToVect([0,0,1], 2, 1)
+			#print(dist)
+			if dist > 1.5:
+				x = 10
+				max_vel = 1.5
+				if self.own.linearVelocity.x < max_vel:
+					self.own.applyForce([x, 0, 5], True)
+			else:
+				self.pt.remove(self.pt[0])
+		else:
+			print('goal reached')	
+			self.npcFSM.ToTransition('toTarget3')
+
 		if self.npcFSM.stateLife > duration:
 			num = randint(1,3)
-			if num == 1:
-				self.npcFSM.ToTransition('toTarget1')
-			elif num ==2:
-				self.npcFSM.ToTransition('toTarget3')	
-			else:
-				self.npcFSM.ToTransition('toIdle')
+			# if num == 1:
+			# 	self.npcFSM.ToTransition('toTarget3')
+			# elif num ==2:
+			# 	self.npcFSM.ToTransition('toTarget3')	
+			# else:
+			# 	self.npcFSM.ToTransition('toIdle')
 		else:		
-			self.cont.activate(self.actu)
+			#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)          
+		#self.cont.deactivate(self.actu)          
+		pass
 		
 class Target3(State):
 	def __init__(self,npcFSM):
 		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 = 20
-				#self.actu.facingMode = False
-				#self.actu.navmesh = self.own['navMesh']
-				self.cont.activate(self.actu)
+		
+		nm = self.own['navMesh']
+		self.pt = nm.findPath(self.own.worldPosition, self.scene.objects[self.target].worldPosition)
+		
+		print('target3')
 		super(Target3, self).Enter()
 
 		
 	def Execute(self):
 		self.npcFSM.stateLife += 1
-		duration = 1200
-		if self.npcFSM.stateLife > duration:
-			if not (randint(1,3) % 2):
-				self.npcFSM.ToTransition('toTarget1')
+		duration = 12000
+
+		if len(self.pt) > 0:
+			target = self.pt[0]
+			vg = self.own.getVectTo(target)
+			dist = vg[0]
+			v = vg[1]
+			self.own.alignAxisToVect(v, 0, .5)
+			self.own.alignAxisToVect([0,0,1], 2, 1)
+			#print(dist)
+			if dist > 1.5:
+				x = 10
+				max_vel = 1.5
+				if self.own.linearVelocity.x < max_vel:
+					self.own.applyForce([x, 0, 5], True)
 			else:
-				self.npcFSM.ToTransition('toTarget2')
+				self.pt.remove(self.pt[0])
+		else:
+			print('goal reached')	
+			self.npcFSM.ToTransition('toTarget1')	
+
+		if self.npcFSM.stateLife > duration:
+			
+			self.npcFSM.ToTransition('toTarget1')
+			
 		else:
 			cont = bge.logic.getCurrentController()
 			own = cont.owner
 
 	def Exit(self):
 		#print('Finished target 3') 
-		self.cont.deactivate(self.actu)              
+		#self.cont.deactivate(self.actu)              
+		pass
 		
 		
 class Idle(State):
 		self.npcFSM.stateLife += 1
 		duration = 300
 		if self.npcFSM.stateLife > duration:
-			#num = randint(1,4)
-			self.npcFSM.ToTransition('toImpatient')
+			num = randint(1,4)
+			#self.npcFSM.ToTransition('toImpatient')
+			self.npcFSM.ToTransition('toTarget1')
 			# if num == 1:
 			# 	self.npcFSM.ToTransition('toTarget1')
 			# elif num == 2:
 		self.npcFSM.AddState("Startup", Startup(self.npcFSM))
 		self.npcFSM.AddState("Idle", Idle(self.npcFSM))
 		self.npcFSM.AddState("Impatient", Impatient(self.npcFSM))
-		#self.npcFSM.AddState('Target1', Target1(self.npcFSM))
-		#self.npcFSM.AddState('Target3', Target3(self.npcFSM))
-		#self.npcFSM.AddState('Target2', Target2(self.npcFSM))
+		self.npcFSM.AddState('Target1', Target1(self.npcFSM))
+		self.npcFSM.AddState('Target3', Target3(self.npcFSM))
+		self.npcFSM.AddState('Target2', Target2(self.npcFSM))
 		
 		#TRANSITIONS
 		self.npcFSM.AddTransition('toStartup', Transition('Startup'))
 		self.npcFSM.AddTransition('toIdle', Transition('Idle'))
 		self.npcFSM.AddTransition('toImpatient', Transition('Impatient'))
-		#self.npcFSM.AddTransition('toTarget3', Transition('Target3'))
-		#self.npcFSM.AddTransition('toTarget1', Transition('Target1'))
-		#self.npcFSM.AddTransition('toTarget2', Transition('Target2'))
+		self.npcFSM.AddTransition('toTarget3', Transition('Target3'))
+		self.npcFSM.AddTransition('toTarget1', Transition('Target1'))
+		self.npcFSM.AddTransition('toTarget2', Transition('Target2'))
 		
 		
 		if self.npcFSM.curState == None:

scripts/water.py

+import bge
+
+
+def update(cont):
+    cont = bge.logic.getCurrentController()
+    own = cont.owner
+    tex = own.meshes[0].materials[0].textures[1]
+    tex2 = own.meshes[0].materials[0].textures[0]    
+    tex3 = own.meshes[0].materials[0].textures[2]        
+    tex.uvOffset.x += .0001
+    tex2.uvOffset.x -= .0002
+    tex3.uvOffset.x -= .00015

shuvit.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:b3d5a65ea5461f9fceb52ab49abace2b97f04065a1335d25ee9db1e8569d2f60
-size 138363804
+oid sha256:ddb30969c1abc34cdc454af5523e5a0a8cbd2d7c613ac143844b072ce482925a
+size 135574672

sounds/grind_cement.wav

+version https://git-lfs.github.com/spec/v1
+oid sha256:807390bd2ebd1be6926ccd5c834021a7f4cd0cfa79f06ab605caba34f5fcf7fe
+size 76080

sounds/grind_cement_s.wav

+version https://git-lfs.github.com/spec/v1
+oid sha256:944c5f123c22eb80b8d8b634d669d114556fb0b2b92b3d1b3d1d83544bab12a9
+size 228152

sounds/grind_rail.wav

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

sounds/grind_rail_s.wav

+version https://git-lfs.github.com/spec/v1
+oid sha256:2dd9e26e9f4ffda056eb653123900a576994ec5f5a8a83024d05a680a54e29a0
+size 254912

sounds/land.wav

 version https://git-lfs.github.com/spec/v1
-oid sha256:a19c3f7b6571f66d18a8827d6768967e2c4c342397a4bc2bd7f0ec85dfaed498
-size 137708
+oid sha256:3e33c74a93e9f1c36e7d1e61e7435baab5d5ee818a5f3e6eddd2fa09032aeb03
+size 68876

sounds/land_s.wav

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

sounds/pop.wav

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

sounds/pop_s.wav

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

sounds/revert.wav

 version https://git-lfs.github.com/spec/v1
-oid sha256:ea86a92f9b681c48b70145466cd26343fa254f2598afe9fe9c893af77ddcf3b4
-size 174924
+oid sha256:0f49e512e7cead24cc73149341f98aafff83cb76a86b545cbd0f75d87ec20dd9
+size 60872

sounds/revert2.wav

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

sounds/revert3.wav

-version https://git-lfs.github.com/spec/v1
-oid sha256:be61e23e2b8a8551ee22a7a565437da3e8de735395b87396cd25eddc32dea249
-size 121700

sounds/roll.wav

+version https://git-lfs.github.com/spec/v1
+oid sha256:03b2e10dbf993b98ce081d1d722f8e58ac35ac3881366ea60dd1520eb941522d
+size 978398

sounds/roll_s.wav

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