new anim code1

assets/kits/ramps.blend

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8f008b26f7b7134323c616925691067886f5f4d5440047396fdad5f4f5c5fc8c
-size 88512652
+oid sha256:69486a9653ba9b6ff283d37f7361834aa4e86ca862cd0066d6eff7216528a9a2
+size 187177596

assets/user2.blend

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:77db4e46f63bbc9da04ab4df1cfc9005168aee194c61e2ce7df7f569b4319493
-size 36844116
+oid sha256:3f61eb94898eac143be19fcc213d8eb9c1249a7a6b1e0bd24c6f14afb81e7768
+size 36970420

assets/user2pit.blend

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f4e016d59bfe917ed55903681d7e7fcd61d987387ab66a7e9bbf394e94489bd
+size 22480148

config.ini

@@ -49,41 +49,41 @@ walk_focal_length = 14
 #character settings
 ###################
 
-character = annie
+character = ralph
 
-shirt_logo = 2
+shirt_logo = 4
 
-shirt_color_r = 0.44
-shirt_color_g = 0.44
-shirt_color_b = 0.44
+shirt_color_r = 0.23
+shirt_color_g = 0.03
+shirt_color_b = 0.05
 
-shoe_color_r = 0.08
-shoe_color_g = 0.03
-shoe_color_b = 0
+shoe_color_r = 0.71
+shoe_color_g = 0.71
+shoe_color_b = 0.71
 #-----------------
 
 #deck settings
 ##############
-deck_index = 5
-deck_color_r = 0.8
-deck_color_g = 0.8
-deck_color_b = 0.8
-trucks_r = 0
-trucks_g = 0
-trucks_b = 0
-
-wheel1_r = 0.21
-wheel1_g = 0.21
-wheel1_b = 0.21
-wheel2_r = 0.21
-wheel2_g = 0.21
-wheel2_b = 0.21
-wheel3_r = 0.21
-wheel3_g = 0.21
-wheel3_b = 0.21
-wheel4_r = 0.21
-wheel4_g = 0.21
-wheel4_b = 0.21
+deck_index = 6
+deck_color_r = 0.1
+deck_color_g = 0
+deck_color_b = 0
+trucks_r = 0.29
+trucks_g = 0.28
+trucks_b = 0.31
+
+wheel1_r = 0
+wheel1_g = 0.1
+wheel1_b = 0
+wheel2_r = 0
+wheel2_g = 0.1
+wheel2_b = 0
+wheel3_r = 0
+wheel3_g = 0.1
+wheel3_b = 0
+wheel4_r = 0
+wheel4_g = 0.1
+wheel4_b = 0
 #-------------------
 
 #2d filter settings
@@ -127,7 +127,7 @@ shadow_on = 0
 
 #physics
 ########
-JUMPHEIGHT = 840#800
+JUMPHEIGHT = 880#840#800
 MAX_VEL = 6.7
 SPEEDUP = 0.055
 SPEEDPUMP = 0.14#.09

scripts/Record.py

@@ -225,7 +225,7 @@ def loadData():
     skater = scene.objects["Char4"]
     deck = scene.objects["deck"]
     trucks = scene.objects["trucks"]
-    
+    bdeck = scene.objects['deck_arm']
     num = 1
     obj = scene.objects['control_cube.002']
     if num == 1:    
@@ -358,6 +358,15 @@ def loadData():
         skater.stopAction(6)
         skater.stopAction(9999)
 
+        bdeck.stopAction(0)
+        bdeck.stopAction(1)
+        bdeck.stopAction(2)
+        bdeck.stopAction(3)
+        bdeck.stopAction(4)
+        bdeck.stopAction(5)
+        bdeck.stopAction(6)
+        bdeck.stopAction(9999)        
+
 
         boneRecord.Playback(valueIndex)
 

scripts/actionPlayer.py

@@ -0,0 +1,240 @@
+import bge
+import actionsFSMlist
+
+dict = bge.logic.globalDict
+
+
+def actionPlayer(ac):
+	scene = bge.logic.getCurrentScene()
+	skater = dict['p1']
+	deck = dict['p1d']
+	a = getattr(actionsFSMlist.reg_walk, 'name')
+	name = getattr(ac, 'name')
+	dname = getattr(ac, 'dname')
+	start = getattr(ac, 'start')
+	end = getattr(ac, 'end')
+	dstart = getattr(ac, 'dstart')
+	dend = getattr(ac, 'dend')
+	layer = getattr(ac, 'layer')
+	mode = getattr(ac, 'mode')
+	speed = getattr(ac, 'speed')
+	blendin = getattr(ac, 'blendin')
+	#--------------------------------
+	skater.playAction(name, start,end, layer=layer, play_mode=mode, speed=speed, blendin=blendin)
+	deck.playAction(dname, dstart,dend, layer=layer, play_mode=mode, speed=speed, blendin=blendin)
+
+
+def get_frame(ac):
+	skater = dict['p1']
+	layer = getattr(ac, 'layer')
+	print('getting frame', skater.getActionFrame(layer))
+	return skater.getActionFrame(layer)
+
+def set_frame(ac, frame):
+	skater = dict['p1']
+	deck = dict['p1d']
+	layer = getattr(ac, 'layer')
+	skater.setActionFrame(frame, layer)
+	deck.setActionFrame(frame, layer)
+	print('setting frame', frame)
+
+def check_exit(aState, rA, ac):
+	exits = getattr(ac, 'exits')
+	if rA in exits:
+		return rA
+	else:
+		return aState
+
+
+def state_timer(own):
+	if own['aState'] == own['l_aState']:
+		own['stateTimer'] += 1
+	else:
+		own['stateTimer'] = 0
+
+def main(cont):
+	own = cont.owner
+	dict = bge.logic.globalDict
+
+	#initial state
+	if 'aState' not in own:
+		own['aState'] = 'reg_idle'
+		own['l_aState'] = None
+		own['stateTimer'] = 0
+
+
+	og_state = own['aState']
+	aState = own['aState']
+	rA = own['requestAction']
+	
+	#-----------------------
+	if aState == 'reg_idle':
+		actionPlayer(actionsFSMlist.reg_idle)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_idle)
+		
+	elif aState == 'reg_idle2':
+		actionPlayer(actionsFSMlist.reg_idle2)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_idle2)
+
+	elif aState == 'reg_idle3':
+		actionPlayer(actionsFSMlist.reg_idle3)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_idle3)
+	
+	elif aState == 'reg_idle4':
+		actionPlayer(actionsFSMlist.reg_idle4)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_idle4)
+
+	elif aState == 'reg_idle5':
+		actionPlayer(actionsFSMlist.reg_idle5)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_idle5)
+	
+	elif aState == 'reg_jump':
+		actionPlayer(actionsFSMlist.reg_jump)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_jump)
+	
+	elif aState == 'reg_walk_air':
+		actionPlayer(actionsFSMlist.reg_walk_air)
+		if aState != rA:
+			aState = 'reg_walk_air_out'
+
+	elif aState == 'reg_walk_air_out':
+		actionPlayer(actionsFSMlist.reg_walk_air_out)
+		if own['stateTimer'] > 7:
+			aState = check_exit(aState, rA, actionsFSMlist.reg_walk_air_out)		
+		
+	elif aState == 'reg_sit':
+
+		if own['stateTimer'] < 19:
+			actionPlayer(actionsFSMlist.reg_sit_in)
+		else:
+			actionPlayer(actionsFSMlist.reg_sit)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_sit)
+
+	#-----------------------
+	elif aState == 'reg_walk':
+		
+		if own['l_aState'] == 'reg_walkFast':
+			print('--------------------doing last frame')
+			frame = get_frame(actionsFSMlist.reg_walkFast)
+			actionPlayer(actionsFSMlist.reg_walk)
+			set_frame(actionsFSMlist.reg_walk, frame)
+		else:	
+			frame = actionPlayer(actionsFSMlist.reg_walk)
+		
+		aState = check_exit(aState, rA, actionsFSMlist.reg_walk)
+
+	#-----------------------
+	elif aState == 'reg_walkFast':
+		
+		aState = check_exit(aState, rA, actionsFSMlist.reg_walkFast)
+
+		if own['l_aState'] == 'reg_walk':
+			print('--------------------doing last framebbbb')
+			frame = get_frame(actionsFSMlist.reg_walk)
+			actionPlayer(actionsFSMlist.reg_walkFast)
+			set_frame(actionsFSMlist.reg_walkFast, frame)
+
+		else:
+			actionPlayer(actionsFSMlist.reg_walkFast)
+		#print(frame)
+
+
+
+	elif aState == 'reg_onboard':
+		actionPlayer(actionsFSMlist.reg_onboard)
+		if own['stateTimer'] > 10:
+			aState = check_exit(aState, rA, actionsFSMlist.reg_onboard)
+
+	elif aState == 'reg_offboard':
+		actionPlayer(actionsFSMlist.reg_offboard)
+		if own['stateTimer'] > 20:
+			aState = check_exit(aState, rA, actionsFSMlist.reg_offboard)			
+
+	elif aState == 'reg_roll':
+		actionPlayer(actionsFSMlist.reg_roll)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_roll)
+
+	elif aState == 'reg_turnLeft':
+		actionPlayer(actionsFSMlist.reg_turnLeft)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_turnLeft)
+	
+	elif aState == 'reg_turnRight':
+		actionPlayer(actionsFSMlist.reg_turnRight)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_turnRight)
+
+	elif aState == 'reg_opos':
+		actionPlayer(actionsFSMlist.reg_opos)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_opos)		
+
+	elif aState == 'reg_nopos':
+		actionPlayer(actionsFSMlist.reg_nopos)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_nopos)		
+
+	elif aState == 'reg_pump':
+		actionPlayer(actionsFSMlist.reg_pump)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_pump)		
+
+	elif aState == 'reg_push':
+		actionPlayer(actionsFSMlist.reg_push)
+		if own['stateTimer'] > 70:
+			aState = 'reg_roll'
+
+	elif aState == 'reg_push_goof':
+		actionPlayer(actionsFSMlist.reg_push_goof)
+		if own['stateTimer'] > 70:
+			aState = 'reg_roll'			
+		
+	elif aState == 'reg_powerslide':
+		if own['stateTimer'] < 20:
+			actionPlayer(actionsFSMlist.reg_powerslide_in)
+		else:
+			actionPlayer(actionsFSMlist.reg_powerslide)
+		
+
+		aState = check_exit(aState, rA, actionsFSMlist.reg_powerslide)
+
+	elif aState == 'reg_fs_powerslide':
+		if own['stateTimer'] < 20:
+			actionPlayer(actionsFSMlist.reg_fs_powerslide_in)
+		else:
+			actionPlayer(actionsFSMlist.reg_fs_powerslide)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_fs_powerslide)				
+
+	elif aState == 'reg_manual':
+		actionPlayer(actionsFSMlist.reg_manual)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_manual)
+
+	elif aState == 'reg_nmanual':
+		actionPlayer(actionsFSMlist.reg_nmanual)
+		aState = check_exit(aState, rA, actionsFSMlist.reg_nmanual)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+	#-----------------------
+	own['aState'] = aState
+	print(own['l_aState'], '----l_aState', own['aState'])
+	own['l_aState'] = og_state
+	
+	state_timer(own)

scripts/actionsFSMlist.py

@@ -6,126 +6,698 @@ fak_fliplist = ['fak_ollie', 'fak_nollie', 'fak_nollie', 'fak_kickflip', 'fak_va
 
 
 class a_class:
-    pass
-#------------------------------
-reg_roll = a_class()
-reg_roll.name = 'reg_roll'
-reg_roll.parent = []
-#reg_roll.siblings['fak_roll']
-reg_roll.s_action = 'nreg'
-reg_roll.s_se = [1, 60]
-reg_roll.d_action = 'a_reg'
-reg_roll.d_se = [0, 10]
-reg_roll.t_action = 'a_reg'
-reg_roll.t_se = [0, 10]
-reg_roll.stateLife = 1
-reg_roll.layer = MAIN_LAYER
-reg_roll.speed = 1
-reg_roll.mode = 0
-#------------------------------
-reg_opos = a_class()
-reg_opos.name = 'reg_opos'
-reg_opos.parent = ['reg_roll']
-reg_opos.parentTrans = 'toreg_opos_to_roll'
-reg_opos.requestAction = 'reg_opos'
-#reg_roll.siblings['']
-reg_opos.s_action = 'nopos'
-reg_opos.s_se = [1, 40]
-reg_opos.d_action = 'a_reg'
-reg_opos.d_se = [0, 10]
-reg_opos.t_action = 'a_reg'
-reg_opos.t_se = [0, 10]
-reg_opos.stateLife = 1
-reg_opos.layer = MAIN_LAYER
-reg_opos.speed = 1
-reg_opos.mode = 0
-#------------------------------
-reg_left = a_class()
-reg_left.name = 'reg_left'
-reg_left.parent = ['reg_roll']
-reg_left.parentTrans = 'toreg_left_to_roll'
-reg_left.requestAction = 'reg_turnLeft'
-reg_left.s_action = 'nreg_left'
-reg_left.s_se = [10, 10]
-reg_left.d_action = 'a_reg_left'
-reg_left.d_se = [0, 10]
-reg_left.t_action = 'a_reg'
-reg_left.t_se = [0, 10]
-reg_left.stateLife = 1
-reg_left.layer = MAIN_LAYER
-reg_left.speed = 1
-reg_left.mode = 0
-#------------------------------
-reg_roll_to_opos = a_class()
-reg_roll_to_opos.name = 'reg_roll_to_opos'
-reg_roll_to_opos.parent = ['reg_roll']
-reg_roll_to_opos.parentTrans = 'toreg_opos'
-reg_roll_to_opos.s_action = 'noposin'
-reg_roll_to_opos.s_se = [1, 20]
-reg_roll_to_opos.d_action = 'a_reg'
-reg_roll_to_opos.d_se = [0, 10]
-reg_roll_to_opos.t_action = 'a_reg'
-reg_roll_to_opos.t_se = [0, 10]
-reg_roll_to_opos.stateLife = 1
-reg_roll_to_opos.layer = TRANS_LAYER
-reg_roll_to_opos.speed = 1
-reg_roll_to_opos.mode = 0
-#------------------------------
-reg_opos_to_roll = a_class()
-reg_opos_to_roll.name = 'reg_opos_to_roll'
-reg_opos_to_roll.parent = ['reg_roll']
-reg_opos_to_roll.s_action = 'noposin'
-reg_opos_to_roll.s_se = [20, 1]
-reg_opos_to_roll.d_action = 'a_reg'
-reg_opos_to_roll.d_se = [0, 10]
-reg_opos_to_roll.t_action = 'a_reg'
-reg_opos_to_roll.t_se = [0, 10]
-reg_opos_to_roll.stateLife = 1
-reg_opos_to_roll.layer = TRANS_LAYER
-reg_opos_to_roll.speed = 1
-reg_opos_to_roll.mode = 0
-#------------------------------
-reg_roll_to_left = a_class()
-reg_roll_to_left.name = 'reg_roll_to_left'
-reg_roll_to_left.parent = ['reg_roll']
-reg_roll_to_left.s_action = 'nreg_left'
-reg_roll_to_left.s_se = [1, 10]
-reg_roll_to_left.d_action = 'a_reg'
-reg_roll_to_left.d_se = [0, 10]
-reg_roll_to_left.t_action = 'a_reg'
-reg_roll_to_left.t_se = [0, 10]
-reg_roll_to_left.stateLife = 1
-reg_roll_to_left.layer = TRANS_LAYER
-reg_roll_to_left.speed = .5
-reg_roll_to_left.mode = 0
-#------------------------------
-reg_left_to_roll = a_class()
-reg_left_to_roll.name = 'reg_left_to_roll'
-reg_left_to_roll.parent = ['reg_roll']
-reg_left_to_roll.s_action = 'nreg_left'
-reg_left_to_roll.s_se = [10, 1]
-reg_left_to_roll.d_action = 'a_reg'
-reg_left_to_roll.d_se = [0, 10]
-reg_left_to_roll.t_action = 'a_reg'
-reg_left_to_roll.t_se = [0, 10]
-reg_left_to_roll.stateLife = 1
-reg_left_to_roll.layer = TRANS_LAYER
-reg_left_to_roll.speed = .5
-reg_left_to_roll.mode = 0
-#------------------------------
-reg_left_to_roll = a_class()
-reg_left_to_roll.name = 'reg_ollie'
-reg_left_to_roll.parent = ['reg_roll']
-reg_left_to_roll.s_action = 'reg_ollie'
-reg_left_to_roll.s_se = [1, 20]
-reg_left_to_roll.d_action = 'a_reg_ollie'
-reg_left_to_roll.d_se = [1, 20]
-reg_left_to_roll.t_action = 't_reg_ollie'
-reg_left_to_roll.t_se = [1, 20]
-reg_left_to_roll.stateLife = 1
-reg_left_to_roll.layer = TRANS_LAYER
-reg_left_to_roll.speed = .5
-reg_left_to_roll.mode = 0
-#------------------------------
-
-#reg_ollie
+	def __init__(self, name, start, end, dname, dstart, dend, layer, speed, mode, blendin, exits):
+		self.name = name
+		self.start = start
+		self.end = end
+		self.dname = dname
+		self.dstart = dstart
+		self.dend = dend
+		self.layer = layer
+		self.speed = speed
+		self.mode = mode
+		self.blendin = blendin
+		self.exits = exits
+
+reg_walk = a_class(
+	#player armature action name
+	'reg_nwalk', 
+	#start frame
+	0,           
+	#end frame
+	35,
+	#deck action name 
+	'b_reg_walk', 
+	#deck start frame
+	0, 
+	#deck end frame
+	35,
+	#layer
+	1,
+	#speed
+	.5,
+	#mode (1 = play, 0 = loop)
+	0,
+	#blendin
+	20,
+	#exits
+	['reg_walkFast', 'reg_idle', 'reg_jump', 'reg_onboard'])
+
+reg_walkFast = a_class(
+	#player armature action name
+	'reg_nwalk', 
+	#start frame
+	0,           
+	#end frame
+	35,
+	#deck action name 
+	'b_reg_walk', 
+	#deck start frame
+	0, 
+	#deck end frame
+	35,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	0,
+	#blendin
+	0, 
+	#exits
+	['reg_walk', 'reg_idle', 'reg_jump', 'reg_onboard'])
+
+
+
+reg_idle = a_class(
+	#player armature action name
+	'reg_idle1', 
+	#start frame
+	1,           
+	#end frame
+	120,
+	#deck action name 
+	'b_reg_walk', 
+	#deck start frame
+	1, 
+	#deck end frame
+	1,
+	#layer
+	1,
+	#speed
+	.5,
+	#mode (1 = play, 0 = loop)
+	0,
+	#blendin
+	20,
+	#exits
+	['reg_walk', 'reg_idle2', 'reg_idle3', 'reg_idle4', 'reg_idle5', 'reg_jump', 'reg_sit', 'reg_onboard'])
+
+reg_idle2 = a_class(
+	#player armature action name
+	'reg_idle2', 
+	#start frame
+	1,           
+	#end frame
+	120,
+	#deck action name 
+	'b_reg_walk', 
+	#deck start frame
+	1, 
+	#deck end frame
+	1,
+	#layer
+	1,
+	#speed
+	.5,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	20,
+	#exits
+	['reg_walk', 'reg_idle', 'reg_idle3', 'reg_idle4', 'reg_idle5', 'reg_jump', 'reg_onboard'])
+
+reg_idle3 = a_class(
+	#player armature action name
+	'reg_idle3', 
+	#start frame
+	1,           
+	#end frame
+	120,
+	#deck action name 
+	'b_reg_walk', 
+	#deck start frame
+	1, 
+	#deck end frame
+	1,
+	#layer
+	1,
+	#speed
+	.5,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	20,
+	#exits
+	['reg_walk', 'reg_idle2', 'reg_idle', 'reg_idle4', 'reg_idle5', 'reg_jump', 'reg_onboard'])
+
+reg_idle4 = a_class(
+	#player armature action name
+	'reg_idle4', 
+	#start frame
+	1,           
+	#end frame
+	120,
+	#deck action name 
+	'b_reg_walk', 
+	#deck start frame
+	1, 
+	#deck end frame
+	1,
+	#layer
+	1,
+	#speed
+	.5,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	20,
+	#exits
+	['reg_walk', 'reg_idle2', 'reg_idle3', 'reg_idle', 'reg_idle5', 'reg_jump', 'reg_onboard'])
+
+reg_idle5 = a_class(
+	#player armature action name
+	'reg_idle5', 
+	#start frame
+	1,           
+	#end frame
+	120,
+	#deck action name 
+	'b_reg_walk', 
+	#deck start frame
+	1, 
+	#deck end frame
+	1,
+	#layer
+	1,
+	#speed
+	.5,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	20,
+	#exits
+	['reg_walk', 'reg_idle2', 'reg_idle3', 'reg_idle4', 'reg_idle', 'reg_jump', 'reg_onboard'])
+
+reg_jump = a_class(
+	#player armature action name
+	'reg_jump', 
+	#start frame
+	1,           
+	#end frame
+	10,
+	#deck action name 
+	'b_reg_jump', 
+	#deck start frame
+	1, 
+	#deck end frame
+	10,
+	#layer
+	1,
+	#speed
+	.5,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	10,
+	#exits
+	['reg_idle', 'reg_walk_air', 'reg_onboard'])
+
+reg_walk_air = a_class(
+	#player armature action name
+	'reg_walk_air', 
+	#start frame
+	10,           
+	#end frame
+	10,
+	#deck action name 
+	'b_reg_jump', 
+	#deck start frame
+	10, 
+	#deck end frame
+	10,
+	#layer
+	1,
+	#speed
+	.5,
+	#mode (1 = play, 0 = loop)
+	0,
+	#blendin
+	10,
+	#exits
+	['reg_walk_air_out'])
+
+reg_walk_air_out = a_class(
+	#player armature action name
+	'reg_walk_air', 
+	#start frame
+	10,           
+	#end frame
+	40,
+	#deck action name 
+	'b_reg_jump', 
+	#deck start frame
+	10, 
+	#deck end frame
+	10,
+	#layer
+	1,
+	#speed
+	1.5,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	10,
+	#exits
+	['reg_idle', 'reg_walk', 'reg_walkFast', 'reg_onboard'])
+
+reg_sit_in = a_class(
+	#player armature action name
+	'reg_sit', 
+	#start frame
+	1,           
+	#end frame
+	65,
+	#deck action name 
+	'b_reg_jump', 
+	#deck start frame
+	1, 
+	#deck end frame
+	65,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	20,
+	#exits
+	['reg_idle', 'reg_walk'])
+
+reg_sit = a_class(
+	#player armature action name
+	'reg_sit', 
+	#start frame
+	65,           
+	#end frame
+	65,
+	#deck action name 
+	'b_reg_jump', 
+	#deck start frame
+	65, 
+	#deck end frame
+	65,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	20,
+	#exits
+	['reg_idle', 'reg_walk'])
+
+#------news
+
+reg_onboard = a_class(
+	#player armature action name
+	'reg_noffboard', 
+	#start frame
+	20,           
+	#end frame
+	1,
+	#deck action name 
+	'b_reg_offboard', 
+	#deck start frame
+	20, 
+	#deck end frame
+	1,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	10,
+	#exits
+	['reg_roll'])
+
+reg_offboard = a_class(
+	#player armature action name
+	'reg_noffboard', 
+	#start frame
+	1,           
+	#end frame
+	40,
+	#deck action name 
+	'b_reg_offboard', 
+	#deck start frame
+	1, 
+	#deck end frame
+	40,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	5,
+	#exits
+	['reg_idle', 'reg_walkFast', 'reg_walk'])
+
+reg_roll = a_class(
+	#player armature action name
+	'nreg', 
+	#start frame
+	1,           
+	#end frame
+	60,
+	#deck action name 
+	'b_reg', 
+	#deck start frame
+	1, 
+	#deck end frame
+	60,
+	#layer
+	1,
+	#speed
+	.5,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	10,
+	#exits
+	['reg_idle', 'reg_offboard', 'reg_turnLeft', 'reg_turnRight', 'reg_opos', 'reg_nopos', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'])
+
+reg_turnLeft = a_class(
+	#player armature action name
+	'nreg_left', 
+	#start frame
+	10,           
+	#end frame
+	30,
+	#deck action name 
+	'b_reg_left', 
+	#deck start frame
+	10, 
+	#deck end frame
+	30,
+	#layer
+	1,
+	#speed
+	.5,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	20,
+	#exits
+	['reg_roll', 'reg_opos', 'reg_nopos', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'])
+
+reg_turnRight = a_class(
+	#player armature action name
+	'nreg_right', 
+	#start frame
+	10,           
+	#end frame
+	30,
+	#deck action name 
+	'b_reg_right', 
+	#deck start frame
+	10, 
+	#deck end frame
+	30,
+	#layer
+	1,
+	#speed
+	.5,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	20,
+	#exits
+	['reg_roll', 'reg_opos', 'reg_nopos', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'])
+
+
+reg_opos = a_class(
+	#player armature action name
+	'nopos', 
+	#start frame
+	11,           
+	#end frame
+	40,
+	#deck action name 
+	'b_reg', 
+	#deck start frame
+	1, 
+	#deck end frame
+	1,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	15,
+	#exits
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'])
+
+reg_nopos = a_class(
+	#player armature action name
+	'nnopos', 
+	#start frame
+	20,           
+	#end frame
+	20,
+	#deck action name 
+	'b_reg', 
+	#deck start frame
+	1, 
+	#deck end frame
+	1,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	15,
+	#exits
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'])
+
+reg_pump = a_class(
+	#player armature action name
+	'nopos', 
+	#start frame
+	20,           
+	#end frame
+	20,
+	#deck action name 
+	'b_reg', 
+	#deck start frame
+	1, 
+	#deck end frame
+	1,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	15,
+	#exits
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'])
+
+reg_push = a_class(
+	#player armature action name
+	'reg_push', 
+	#start frame
+	1,           
+	#end frame
+	35,
+	#deck action name 
+	'b_reg', 
+	#deck start frame
+	1, 
+	#deck end frame
+	1,
+	#layer
+	1,
+	#speed
+	.5,
+	#mode (1 = play, 0 = loop)
+	0,
+	#blendin
+	10,
+	#exits
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'])
+
+reg_push_goof = a_class(
+	#player armature action name
+	'reg_push_goof', 
+	#start frame
+	1,           
+	#end frame
+	35,
+	#deck action name 
+	'b_reg', 
+	#deck start frame
+	1, 
+	#deck end frame
+	1,
+	#layer
+	1,
+	#speed
+	.5,
+	#mode (1 = play, 0 = loop)
+	0,
+	#blendin
+	10,
+	#exits
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'])
+
+
+reg_powerslide_in = a_class(
+	#player armature action name
+	'nreg_powerslide2', 
+	#start frame
+	0,           
+	#end frame
+	20,
+	#deck action name 
+	'b_reg_powerslide2', 
+	#deck start frame
+	0, 
+	#deck end frame
+	20,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	10,
+	#exits
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual'])
+
+reg_fs_powerslide_in = a_class(
+	#player armature action name
+	'nreg_powerslide', 
+	#start frame
+	0,           
+	#end frame
+	20,
+	#deck action name 
+	'b_reg_powerslide', 
+	#deck start frame
+	0, 
+	#deck end frame
+	20,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	10,
+	#exits
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual'])
+
+reg_powerslide = a_class(
+	#player armature action name
+	'nreg_powerslide2', 
+	#start frame
+	20,           
+	#end frame
+	20,
+	#deck action name 
+	'b_reg_powerslide2', 
+	#deck start frame
+	20, 
+	#deck end frame
+	20,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	10,
+	#exits
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual'])
+
+reg_fs_powerslide = a_class(
+	#player armature action name
+	'nreg_powerslide', 
+	#start frame
+	20,           
+	#end frame
+	20,
+	#deck action name 
+	'b_reg_powerslide', 
+	#deck start frame
+	20, 
+	#deck end frame
+	20,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	10,
+	#exits
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual'])
+
+
+reg_manual = a_class(
+	#player armature action name
+	'reg_manual', 
+	#start frame
+	20,           
+	#end frame
+	20,
+	#deck action name 
+	'b_reg_manual', 
+	#deck start frame
+	20, 
+	#deck end frame
+	20,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	10,
+	#exits
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos'])
+
+
+reg_nmanual = a_class(
+	#player armature action name
+	'reg_nmanual', 
+	#start frame
+	20,           
+	#end frame
+	20,
+	#deck action name 
+	'b_fak_manual', 
+	#deck start frame
+	20, 
+	#deck end frame
+	20,
+	#layer
+	1,
+	#speed
+	1,
+	#mode (1 = play, 0 = loop)
+	1,
+	#blendin
+	10,
+	#exits
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos'])
+
+
+#******************(((((((((((((((((())))))))))))))))))*************

scripts/boneRecord.py

@@ -4,7 +4,11 @@ from mathutils import Vector
 dict = bge.logic.globalDict
 dict['replay_record_length']
 
-bone_list = ["foot.ik.R", "foot.ik.L", "hips", "root", "spine", "spine-1", "chest", "chest-1", "clavicle.L", "clavicle.R", "deltoid.L", "deltoid.R", "upper_arm.fk.L", "upper_arm.fk.R",  "forearm.fk.L", "forearm.fk.R", "hand.fk.L", "hand.fk.R", "neck", "head", "master"]
+bone_list = ["foot.ik.R", "foot.ik.L", "knee.pt.ik.R", "knee.pt.ik.L", "hips", "root", "spine", "spine-1", "chest", "chest-1", "clavicle.L", "clavicle.R", "deltoid.L", "deltoid.R", "upper_arm.fk.L", "upper_arm.fk.R",  "forearm.fk.L", "forearm.fk.R", "hand.fk.L", "hand.fk.R", "neck", "head", "master"]
+
+deck_list = ['main', 'turn']
+
+#bone_list = ['root', 'head']
 
 def Record():    
     scene = bge.logic.getCurrentScene()
@@ -12,64 +16,94 @@ def Record():
     master = scene.objects['control_cube.002']
     cam = scene.objects['Camera.003']
     armature = scene.objects['Char4']
+    deck = scene.objects['deck_arm']
 
     if 'dataList' not in master:
         for x in bone_list:
             master['dataList'] = True
             master[str(x) + '-pos'] = []
             master[str(x) + '-rot'] = []
+        for x in deck_list:
+            master['dataList'] = True
+            master[str(x) + '-pos'] = []
+            master[str(x) + '-rot'] = []            
 
     for y in bone_list:
         x = armature.channels[y]
-        #print('bone_name: ', x) 
+        pos = x.location
+        if x.rotation_mode == 0:
+            rot = x.rotation_quaternion
+        else:
+            rot = Vector(x.channel_matrix.to_euler()) 
+
+        if len(master[str(y) + '-pos']) > dict['replay_record_length']:
+            master[str(y) + '-pos'].pop(0)
+            master[str(y) + '-rot'].pop(0)            
+
+            master[str(y) + '-pos'].pop(0)
+            master[str(y) + '-rot'].pop(0)            
+
+        master[str(y) + '-pos'].append(pos)
+        master[str(y) + '-rot'].append(rot)
+
+        master[str(y) + '-pos'].append(pos)
+        master[str(y) + '-rot'].append(rot)   
+
 
-        #pos = (x.pose_head)+master.worldPosition
-        pos = (x.pose_head)
-        rot = Vector(x.channel_matrix.to_euler()) 
-        #rot = x.rotation_euler  
+    for y in deck_list:
+        x = deck.channels[y]
+        pos = x.location   
+        rot = x.rotation_quaternion
 
+            
         if len(master[str(y) + '-pos']) > dict['replay_record_length']:
             master[str(y) + '-pos'].pop(0)
             master[str(y) + '-rot'].pop(0)            
 
+            master[str(y) + '-pos'].pop(0)
+            master[str(y) + '-rot'].pop(0)            
+
         master[str(y) + '-pos'].append(pos)
         master[str(y) + '-rot'].append(rot)
 
+        master[str(y) + '-pos'].append(pos)
+        master[str(y) + '-rot'].append(rot) 
+
+
 def Playback(valueIndex):
     scene = bge.logic.getCurrentScene()
     #own = cont.owner
     master = scene.objects['control_cube.002']
     cam = scene.objects['Camera.003']
     armature = scene.objects['Char4']
-    #armature.removeParent()
-
-
-
-    #print(master['foot.ik.R-pos'], 'fooot rot')
-
-
+    deck = scene.objects['deck_arm']
 
     for y in bone_list:
         x = armature.channels[y]
-        #x.location = [1,0,1]
-        
-
         pl = master[str(y) + '-pos'] 
         rl = master[str(y) + '-rot'] 
-        #print(valueIndex)
-        #print(rl)
-        #print(pl)
-        #x.rotation_euler = rl[20]
         try:
-            x.rotation_mode = 1
-            x.location = pl[valueIndex]
-            x.rotation_euler = rl[valueIndex]
-            
-            #x.rotation_euler = [1,1,1]
-
-            print(x.rotation_mode, 'mode')
+            if x.rotation_mode == 0:
+                x.rotation_quaternion = rl[valueIndex]
+            else:    
+                x.rotation_euler = rl[valueIndex]
+            x.location = pl[valueIndex]    
+            #print(x.rotation_mode, pl[valueIndex],  'mode', valueIndex)
         except:
             print('index out of range')
+        
+
 
-        armature.update()
-        #print('trying')
+    for z in deck_list:
+        x = deck.channels[z]
+        pl = master[str(z) + '-pos'] 
+        rl = master[str(z) + '-rot'] 
+        try:
+            x.rotation_quaternion = rl[valueIndex]
+            x.location = pl[valueIndex]    
+
+            #print(x.rotation_mode, pl[valueIndex],  'mode', valueIndex, x.name)
+        except:
+            print('index out of range')
+    armature.update()        
+    deck.update()        

scripts/camFSM.py

@@ -14,15 +14,14 @@ def get_request_state(cur_state):
 
 #camera - (Target Object, Min Distance, Max Distance, Height)
 def activate_camera(cobj, cmin, cmax, cheight):
-    pass
-    # cont = bge.logic.getCurrentController()
-    # scene = bge.logic.getCurrentScene()
-    # camActu = cont.actuators['Camera']
-    # camActu.object = scene.objects[cobj]
-    # camActu.min = cmin
-    # camActu.max = cmax
-    # camActu.height = cheight
-    # cont.activate(camActu)
+    cont = bge.logic.getCurrentController()
+    scene = bge.logic.getCurrentScene()
+    camActu = cont.actuators['Camera']
+    camActu.object = scene.objects[cobj]
+    camActu.min = cmin
+    camActu.max = cmax
+    camActu.height = cheight
+    cont.activate(camActu)
 
 
 

scripts/colors.py

@@ -51,7 +51,7 @@ def main():
     #shirt.color = shirtC
     #print(dict['shirt_color'])
     scol = [dict['shirt_color_r'], dict['shirt_color_g'], dict['shirt_color_b'], 1]
-    deckC = [dict['deck_color_r'], dict['deck_color_g'], dict['deck_color_b'], 1]
+    deckC = [dict['deck_color_r'], dict['deck_color_g'], dict['deck_color_b'], 0]
     #print(scol)
     shirt.color = scol
     deck.color = deckC
@@ -62,14 +62,14 @@ def main():
     shoeR.color = shoesC
     shoeL.color = shoesC
     
-    trucks.color = [dict['trucks_r'], dict['trucks_g'], dict['trucks_b'], 1]
-    throw_deck_trucks.color = [dict['trucks_r'], dict['trucks_g'], dict['trucks_b'], 1]
+    trucks.color = [dict['trucks_r'], dict['trucks_g'], dict['trucks_b'], 0]
+    throw_deck_trucks.color = [dict['trucks_r'], dict['trucks_g'], dict['trucks_b'], 0]
     focus_deckA_trucks.color = [dict['trucks_r'], dict['trucks_g'], dict['trucks_b'], 1]
     focus_deckB_trucks.color = [dict['trucks_r'], dict['trucks_g'], dict['trucks_b'], 1]
-    wheel1.color = [dict['wheel1_r'], dict['wheel1_g'], dict['wheel1_b'], 1]
-    wheel2.color = [dict['wheel2_r'], dict['wheel2_g'], dict['wheel2_b'], 1]
-    wheel3.color = [dict['wheel3_r'], dict['wheel3_g'], dict['wheel3_b'], 1]
-    wheel4.color = [dict['wheel4_r'], dict['wheel4_g'], dict['wheel4_b'], 1]
+    wheel1.color = [dict['wheel1_r'], dict['wheel1_g'], dict['wheel1_b'], 0]
+    wheel2.color = [dict['wheel2_r'], dict['wheel2_g'], dict['wheel2_b'], 0]
+    wheel3.color = [dict['wheel3_r'], dict['wheel3_g'], dict['wheel3_b'], 0]
+    wheel4.color = [dict['wheel4_r'], dict['wheel4_g'], dict['wheel4_b'], 0]
     throw_deck_wheel1.color = [dict['wheel1_r'], dict['wheel1_g'], dict['wheel1_b'], 1]
     throw_deck_wheel2.color = [dict['wheel2_r'], dict['wheel2_g'], dict['wheel2_b'], 1]
     throw_deck_wheel3.color = [dict['wheel3_r'], dict['wheel3_g'], dict['wheel3_b'], 1]

scripts/controller2.py

@@ -361,7 +361,7 @@ def main():
         if skater.isPlayingAction(fliplay):
             playing_frame = skater.getActionFrame(fliplay)
         #if onGround and skater.isPlayingAction(fliplay) and own['jump_timer'] < 40 and playing_frame < 14 and playing_frame > 3:
-        if onGround and skater.isPlayingAction(fliplay) and own['jump_timer'] < 45 and playing_frame < 17 and playing_frame > 3:    
+        if onGround and skater.isPlayingAction(fliplay) and own['jump_timer'] < 45 and playing_frame < 16 and playing_frame > 3:    
             hitDistance = own.worldPosition[2] - r_ground.hitPosition[2]
             if hitDistance < dict['fall_height']:
                 own['fall'] = 1
@@ -4547,8 +4547,9 @@ def main():
                 own.alignAxisToVect(localRay[2], 2, .5)
                 aligned = True
             #print('localRay')
-
-
+        if localHitDist > .31 and localHitDist < 2:
+            own.alignAxisToVect(localRay[2], 2, .05)
+            print('new align')
     #else:
         #print('no localRay')
         else:
@@ -4590,20 +4591,31 @@ def main():
         if localRay_v[0] and own['LAST_GRIND'] == False and rBump == 0 and lBump == 0 and ((own['framenum'] - own['last_transition_frame'] < 10) or (own['framenum'] - own['last_vert_frame'] < 10)):
             own['vert'] = 1
             #print('vert hit')
-            own['last_vert_frame'] = own['framenum']
-            localHitDist = Vector.copy(Start - localRay_v[1]).length
-            own.linearVelocity.x *= .98
-            own.linearVelocity.z = .1
-            #if localHitDist < .8 and (dict['lUD'] < .04 or dict['lUD'] > -.04):
-            #if localHitDist < .8:    
-            if localHitDist < 1.5:        
-                #own.applyMovement((0,0,((.4 - (localHitDist) * .1))), True)
-                own.applyMovement((0, 0, (.3 - localHitDist)), True)
-                #print('moving vert ray')
-                if localRay_v[2] != [0, 0, -1] and grindHit == 0:
-                #if localRay_v[2] != [0,0,-1]:
-                    own.alignAxisToVect(localRay_v[2], 2, .4)
-                    aligned = True
+
+            if 'spine' in localRay_v[0] and lUD < -.04:
+                print('spine hit!!!!!', lUD)
+                
+                #print('roting')
+                if STANCE == True:
+                    own.applyRotation([0,.15,0], True)
+                else:    
+                    own.applyRotation([0,-.15,0], True)
+                own.linearVelocity.x *= .97    
+            elif lUD > -.04: 
+                own['last_vert_frame'] = own['framenum']
+                localHitDist = Vector.copy(Start - localRay_v[1]).length
+                own.linearVelocity.x *= .98
+                own.linearVelocity.z = .1
+                #if localHitDist < .8 and (dict['lUD'] < .04 or dict['lUD'] > -.04):
+                #if localHitDist < .8:    
+                if localHitDist < 1.5:        
+                    #own.applyMovement((0,0,((.4 - (localHitDist) * .1))), True)
+                    own.applyMovement((0, 0, (.3 - localHitDist)), True)
+                    #print('moving vert ray')
+                    if localRay_v[2] != [0, 0, -1] and grindHit == 0:
+                    #if localRay_v[2] != [0,0,-1]:
+                        own.alignAxisToVect(localRay_v[2], 2, .4)
+                        aligned = True
         #print(own['lGobj'], 'lGobj')                         
 
 

scripts/ragdoll.py

@@ -81,8 +81,8 @@ def main():
     sens = cont.sensors['rd_key']
     dict = bge.logic.globalDict
     
-    if 'inited' not in own:
-        own['inited'] = True
+    if 'rdinited' not in own:
+        own['rdinited'] = True
         own['ragdoll_active'] = False
         pB = scene.objectsInactive["npc_ed_arm_physBody"]  
         own['rd_rb'] = scene.addObject(pB)

scripts/scene_init.py

@@ -29,6 +29,9 @@ def main():
         # combine child's shape with parent's
         compound = True
         obj = scene.objects['Char4']
+        deck_obj = scene.objects['deck_arm']
+        dict['p1'] = obj
+        dict['p1d'] = deck_obj
         # child is solid
         ghost = False
         # set parent

scripts/walk.py

@@ -504,18 +504,18 @@ def main(cont):
             wheel2act = wheel2.actuators["Visibility"]
             wheel3act = wheel3.actuators["Visibility"]
             wheel4act = wheel4.actuators["Visibility"]        
-            deckact.visibility = True
+            #deckact.visibility = True
             trucksact.visibility = True
             wheel1act.visibility = True
             wheel2act.visibility = True
             wheel3act.visibility = True
             wheel4act.visibility = True  
-            cont.activate(deck.actuators['Visibility'])
-            cont.activate(trucks.actuators['Visibility'])
-            cont.activate(wheel1.actuators['Visibility'])
-            cont.activate(wheel2.actuators['Visibility'])
-            cont.activate(wheel3.actuators['Visibility'])
-            cont.activate(wheel4.actuators['Visibility']) 
+            #cont.activate(deck.actuators['Visibility'])
+            #cont.activate(trucks.actuators['Visibility'])
+            #cont.activate(wheel1.actuators['Visibility'])
+            #cont.activate(wheel2.actuators['Visibility'])
+            #cont.activate(wheel3.actuators['Visibility'])
+            #cont.activate(wheel4.actuators['Visibility']) 
             own['throw_deck'] = False 
             throw_deck_empty = scene.objects["throw_deck_empty"]
             throw_deck_empty['kill_deck'] = 1 

shuvit.blend

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9382a5e4ed4156584de823b3e48974f6ffd0be28c07c3ae9d57bb04c1ca8f896
-size 141395864
+oid sha256:9a38a3c66688c3eacb95254792badf529b3590acaad52269bd3353d2c9dbdd36
+size 146559260