tweaks1

scripts/actionPlayer.py

 	#--------------------------------
 	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)
-
+	#print('playing', name)
 
 def get_frame(ac):
 	skater = dict['p1']
 	deck.setActionFrame(frame, layer)
 	print('setting frame', frame)
 
-def check_exit(aState, rA, ac):
+def check_exit(aState, rA, timer, ac):
 	exits = getattr(ac, 'exits')
+	force = getattr(ac, 'force_exit')
+	fe = getattr(ac, 'fef')
 	if rA in exits:
 		return rA
 	else:
 		return aState
 
+	if force != None and fe >= timer:
+		return force
+			
+
+	
+
 
 def state_timer(own):
 	if own['aState'] == own['l_aState']:
 	og_state = own['aState']
 	aState = own['aState']
 	rA = own['requestAction']
+	timer = own['stateTimer']
+	newState = own['aState']
 	
 	#-----------------------
-	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)
+	check_state = 'reg_idle'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, cl)
+
+	check_state = 'reg_idle2'	
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, cl)
+
+	check_state = 'reg_idle3'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, cl)
 	
-	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)
+	check_state = 'reg_idle4'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, cl)
+
+	check_state = 'reg_idle5'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, cl)
 	
-	elif aState == 'reg_jump':
-		actionPlayer(actionsFSMlist.reg_jump)
-		aState = check_exit(aState, rA, actionsFSMlist.reg_jump)
+	check_state = 'reg_jump'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		if own['stateTimer'] > getattr(cl, 'fef'):
+			nl = getattr(cl, 'force_exit')
+			na = getattr(actionsFSMlist, nl)
+
+			newState = check_exit(aState, rA, timer, cl)
 	
-	elif aState == 'reg_walk_air':
-		actionPlayer(actionsFSMlist.reg_walk_air)
+	check_state = 'reg_walk_air'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
 		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':
-
+			newState = 'reg_walk_air_out'
+	
+	check_state = 'reg_walk_air_out' 			
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		print(own['stateTimer'], getattr(cl, 'fef'))
+		if own['stateTimer'] > getattr(cl, 'fef'):	
+			#newState = check_exit(aState, rA, timer, actionsFSMlist.reg_idle)
+			newState = getattr(cl, 'force_exit')
+
+	check_state = 'reg_sit'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
 		if own['stateTimer'] < 19:
 			actionPlayer(actionsFSMlist.reg_sit_in)
 		else:
-			actionPlayer(actionsFSMlist.reg_sit)
-		aState = check_exit(aState, rA, actionsFSMlist.reg_sit)
+			actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, actionsFSMlist.reg_sit)
 
 	#-----------------------
-	elif aState == 'reg_walk':
-		
+	check_state = 'reg_walk'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
 		if own['l_aState'] == 'reg_walkFast':
 			print('--------------------doing last frame')
 			frame = get_frame(actionsFSMlist.reg_walkFast)
-			actionPlayer(actionsFSMlist.reg_walk)
+			actionPlayer(cl)
 			set_frame(actionsFSMlist.reg_walk, frame)
 		else:	
-			frame = actionPlayer(actionsFSMlist.reg_walk)
+			frame = actionPlayer(cl)
 		
-		aState = check_exit(aState, rA, actionsFSMlist.reg_walk)
+		newState = check_exit(aState, rA, timer, cl)
 
 	#-----------------------
-	elif aState == 'reg_walkFast':
-		
-		aState = check_exit(aState, rA, actionsFSMlist.reg_walkFast)
+	check_state = 'reg_walkFast'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		newState = check_exit(aState, rA, timer, actionsFSMlist.reg_walkFast)
 
 		if own['l_aState'] == 'reg_walk':
 			print('--------------------doing last framebbbb')
 			frame = get_frame(actionsFSMlist.reg_walk)
-			actionPlayer(actionsFSMlist.reg_walkFast)
+			actionPlayer(cl)
 			set_frame(actionsFSMlist.reg_walkFast, frame)
 
 		else:
-			actionPlayer(actionsFSMlist.reg_walkFast)
+			actionPlayer(cl)
 		#print(frame)
 
 
-
-	elif aState == 'reg_onboard':
-		actionPlayer(actionsFSMlist.reg_onboard)
+	check_state = 'reg_onboard'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
 		if own['stateTimer'] > 10:
-			aState = check_exit(aState, rA, actionsFSMlist.reg_onboard)
+			newState = check_exit(aState, rA, timer, actionsFSMlist.reg_onboard)
 
-	elif aState == 'reg_offboard':
-		actionPlayer(actionsFSMlist.reg_offboard)
+	check_state = 'reg_offboard'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
 		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)
+			newState = check_exit(aState, rA, timer, actionsFSMlist.reg_offboard)			
+
+	check_state = 'reg_roll'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, cl)
+
+	check_state = 'reg_turnLeft'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, cl)
 	
-	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)
+	check_state = 'reg_turnRight'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, cl)
+
+	check_state = 'reg_opos'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, cl)		
+	
+	check_state = 'reg_nopos'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, cl)		
+
+	check_state = 'reg_pump'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, cl)		
+
+	check_state = 'reg_push'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
 		if own['stateTimer'] > 70:
-			aState = 'reg_roll'
+			newState = 'reg_roll'
 
-	elif aState == 'reg_push_goof':
-		actionPlayer(actionsFSMlist.reg_push_goof)
+	check_state = 'reg_push_goof'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
 		if own['stateTimer'] > 70:
-			aState = 'reg_roll'			
-		
-	elif aState == 'reg_powerslide':
+			newState = 'reg_roll'			
+	
+	check_state = 'reg_powerslide'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
 		if own['stateTimer'] < 20:
 			actionPlayer(actionsFSMlist.reg_powerslide_in)
 		else:
-			actionPlayer(actionsFSMlist.reg_powerslide)
+			actionPlayer(cl)
 		
 
-		aState = check_exit(aState, rA, actionsFSMlist.reg_powerslide)
+		newState = check_exit(aState, rA, timer, actionsFSMlist.reg_powerslide)
 
-	elif aState == 'reg_fs_powerslide':
+	check_state = 'reg_fs_powerslide'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
 		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)				
+			actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, actionsFSMlist.reg_fs_powerslide)				
 
-	elif aState == 'reg_manual':
-		actionPlayer(actionsFSMlist.reg_manual)
-		aState = check_exit(aState, rA, actionsFSMlist.reg_manual)
+	check_state = 'reg_manual'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, cl)
 
-	elif aState == 'reg_nmanual':
-		actionPlayer(actionsFSMlist.reg_nmanual)
-		aState = check_exit(aState, rA, actionsFSMlist.reg_nmanual)
+	check_state = 'reg_nmanual'
+	if aState == check_state:
+		cl = getattr(actionsFSMlist, check_state)
+		actionPlayer(cl)
+		newState = check_exit(aState, rA, timer, cl)
 
 
 
 
 
 	#-----------------------
-	own['aState'] = aState
-	print(own['l_aState'], '----l_aState', own['aState'])
+	#own['aState'] = aState
+	if newState != '':
+		own['aState'] = newState 
+	#print(own['l_aState'], '----l_aState', own['aState'])
 	own['l_aState'] = og_state
-	
+	print(own['l_aState'], '----l_aState', own['aState'], 'rA', rA)
 	state_timer(own)

scripts/actionsFSMlist.py

 
 
 class a_class:
-	def __init__(self, name, start, end, dname, dstart, dend, layer, speed, mode, blendin, exits):
+	def __init__(self, name, start, end, dname, dstart, dend, layer, speed, mode, blendin, exits, fe, fef):
 		self.name = name
 		self.start = start
 		self.end = end
 		self.mode = mode
 		self.blendin = blendin
 		self.exits = exits
+		self.force_exit = fe
+		self.fef = fef
 
 reg_walk = a_class(
 	#player armature action name
 	#blendin
 	20,
 	#exits
-	['reg_walkFast', 'reg_idle', 'reg_jump', 'reg_onboard'])
-
+	['reg_walkFast', 'reg_idle', 'reg_jump', 'reg_onboard', 'reg_idle2', 'reg_idle3', 'reg_idle4', 'reg_walk_air', 'reg_walk_air_out'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 reg_walkFast = a_class(
 	#player armature action name
 	'reg_nwalk', 
 	#blendin
 	0, 
 	#exits
-	['reg_walk', 'reg_idle', 'reg_jump', 'reg_onboard'])
+	['reg_walk', 'reg_idle', 'reg_jump', 'reg_onboard'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 
 
 	#blendin
 	20,
 	#exits
-	['reg_walk', 'reg_idle2', 'reg_idle3', 'reg_idle4', 'reg_idle5', 'reg_jump', 'reg_sit', 'reg_onboard'])
+	['reg_walk', 'reg_idle2', 'reg_idle3', 'reg_idle4', 'reg_idle5', 'reg_jump', 'reg_sit', 'reg_onboard'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_idle2 = a_class(
 	#player armature action name
 	#blendin
 	20,
 	#exits
-	['reg_walk', 'reg_idle', 'reg_idle3', 'reg_idle4', 'reg_idle5', 'reg_jump', 'reg_onboard'])
+	['reg_walk', 'reg_idle', 'reg_idle3', 'reg_idle4', 'reg_idle5', 'reg_jump', 'reg_onboard'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_idle3 = a_class(
 	#player armature action name
 	#blendin
 	20,
 	#exits
-	['reg_walk', 'reg_idle2', 'reg_idle', 'reg_idle4', 'reg_idle5', 'reg_jump', 'reg_onboard'])
+	['reg_walk', 'reg_idle2', 'reg_idle', 'reg_idle4', 'reg_idle5', 'reg_jump', 'reg_onboard'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_idle4 = a_class(
 	#player armature action name
 	#blendin
 	20,
 	#exits
-	['reg_walk', 'reg_idle2', 'reg_idle3', 'reg_idle', 'reg_idle5', 'reg_jump', 'reg_onboard'])
+	['reg_walk', 'reg_idle2', 'reg_idle3', 'reg_idle', 'reg_idle5', 'reg_jump', 'reg_onboard'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_idle5 = a_class(
 	#player armature action name
 	#blendin
 	20,
 	#exits
-	['reg_walk', 'reg_idle2', 'reg_idle3', 'reg_idle4', 'reg_idle', 'reg_jump', 'reg_onboard'])
+	['reg_walk', 'reg_idle2', 'reg_idle3', 'reg_idle4', 'reg_idle', 'reg_jump', 'reg_onboard'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_jump = a_class(
 	#player armature action name
 	#speed
 	.5,
 	#mode (1 = play, 0 = loop)
-	1,
+	0,
 	#blendin
 	10,
 	#exits
-	['reg_idle', 'reg_walk_air', 'reg_onboard'])
+	['reg_idle', 'reg_walk_air', 'reg_onboard'],
+	#force exit
+	'reg_walk_air',
+	#force exit frame
+	20)
 
 reg_walk_air = a_class(
 	#player armature action name
 	#mode (1 = play, 0 = loop)
 	0,
 	#blendin
-	10,
+	5,
 	#exits
-	['reg_walk_air_out'])
+	['reg_walk_air_out'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_walk_air_out = a_class(
 	#player armature action name
 	#mode (1 = play, 0 = loop)
 	1,
 	#blendin
-	10,
+	5,
 	#exits
-	['reg_idle', 'reg_walk', 'reg_walkFast', 'reg_onboard'])
+	['reg_idle', 'reg_walk', 'reg_walkFast', 'reg_onboard'],
+	#force exit
+	'reg_idle',
+	#force exit frame
+	10)
 
 reg_sit_in = a_class(
 	#player armature action name
 	#blendin
 	20,
 	#exits
-	['reg_idle', 'reg_walk'])
+	['reg_idle', 'reg_walk'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_sit = a_class(
 	#player armature action name
 	#blendin
 	20,
 	#exits
-	['reg_idle', 'reg_walk'])
+	['reg_idle', 'reg_walk'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 #------news
 
 	#blendin
 	10,
 	#exits
-	['reg_roll'])
+	['reg_roll'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_offboard = a_class(
 	#player armature action name
 	#blendin
 	5,
 	#exits
-	['reg_idle', 'reg_walkFast', 'reg_walk'])
+	['reg_idle', 'reg_walkFast', 'reg_walk'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_roll = a_class(
 	#player armature action name
 	#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_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'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_turnLeft = a_class(
 	#player armature action name
 	#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_roll', 'reg_opos', 'reg_nopos', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_turnRight = a_class(
 	#player armature action name
 	#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_roll', 'reg_opos', 'reg_nopos', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 
 reg_opos = a_class(
 	#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_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_nopos = a_class(
 	#player armature action name
 	#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_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_pump = a_class(
 	#player armature action name
 	#blendin
 	15,
 	#exits
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'])
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_push = a_class(
 	#player armature action name
 	#blendin
 	10,
 	#exits
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'])
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_push_goof = a_class(
 	#player armature action name
 	#blendin
 	10,
 	#exits
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'])
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 
 reg_powerslide_in = a_class(
 	#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_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_fs_powerslide_in = a_class(
 	#player armature action name
 	#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_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_powerslide = a_class(
 	#player armature action name
 	#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_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 reg_fs_powerslide = a_class(
 	#player armature action name
 	#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_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 
 reg_manual = a_class(
 	#blendin
 	10,
 	#exits
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos'])
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 
 reg_nmanual = a_class(
 	#blendin
 	10,
 	#exits
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos'])
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos'],
+	#force exit
+	None,
+	#force exit frame
+	0)
 
 
 #******************(((((((((((((((((())))))))))))))))))*************

scripts/inputs.py

         dict['mTrig'] = 0
         dict['rTrig'] = 0
         dict['lTrig'] = 0
+
+        dict['last_aBut'] = 0
+        dict['last_bBut'] = 0
+        dict['last_xBut'] = 0
+        dict['last_yBut'] = 0
+        dict['last_lBump'] = 0
+        dict['last_rBump'] = 0
+        dict['last_bkBut'] = 0
+        dict['last_stBut'] = 0
+        dict['last_xbBut'] = 0
+        dict['last_ltsBut'] = 0
+        dict['last_rtsBut'] = 0
+        dict['last_ldPad'] = 0
+        dict['last_rdPad'] = 0
+        dict['last_udPad'] = 0
+        dict['last_ddPad'] = 0
+        dict['last_rUD'] = 0
+        dict['last_lUD'] = 0
+        dict['last_rLR'] = 0
+        dict['last_lLR'] = 0
+        dict['last_rmUD'] = 0
+        dict['last_lmUD'] = 0
+        dict['last_rmLR'] = 0
+        dict['last_lmLR'] = 0
+        dict['last_mTrig'] = 0
+        dict['last_rTrig'] = 0
+        dict['last_lTrig'] = 0
+
         #dict['last_joy_con'] = 0    
 
     if dict['driving_reset'] == True:

scripts/walk.py

                     own.linearVelocity.z += 5
                     own.linearVelocity.x = linvel.x
                     own.linearVelocity.y = linvel.y
-                    own['walk_jump_timer'] = 20
+                    own['walk_jump_timer'] = 6
             own['lastx'] = 1
         else:
             own['lastx'] = 0