Browse Source

everything

shuvit 3 years ago
parent
commit
a0d2c16437

+ 1
- 0
scripts/Startup.py View File

@@ -114,5 +114,6 @@ def main():
114 114
     dict['rp_positions'] = []
115 115
     dict['temp_list'] = []
116 116
     dict['scene_inited'] = True
117
+    dict['p1c'] = None
117 118
     
118 119
 main()

BIN
scripts/__pycache__/Manager.cpython-36.pyc View File


BIN
scripts/__pycache__/Startup.cpython-36.pyc View File


BIN
scripts/__pycache__/controller2.cpython-36.pyc View File


BIN
scripts/__pycache__/grindV2.cpython-36.pyc View File


BIN
scripts/__pycache__/scene_init.cpython-36.pyc View File


BIN
scripts/__pycache__/stance.cpython-36.pyc View File


BIN
scripts/__pycache__/walk.cpython-36.pyc View File


+ 81
- 5
scripts/actionPlayer.py View File

@@ -1,5 +1,6 @@
1 1
 import bge
2 2
 import actionsFSMlist
3
+import mathutils
3 4
 
4 5
 dict = bge.logic.globalDict
5 6
 zero_blend = False
@@ -77,8 +78,9 @@ def check_land(rA, aState, own):
77 78
 
78 79
 	#check if manualling
79 80
 	if rA in actionsFSMlist.reg_manuallist or rA in actionsFSMlist.reg_grindlist or rA in actionsFSMlist.fak_grindlist:
81
+	#if rA in actionsFSMlist.reg_manuallist or rA in actionsFSMlist.fak_grindlist:	
80 82
 		aState = rA
81
-		own['stateTimer'] = 0
83
+		#own['stateTimer'] = 0
82 84
 		own['aState'] = rA
83 85
 	#otherwise, force land, offboard or fliptrick
84 86
 	elif 'land' in rA or 'onboard' in rA or 'offboard' in rA or rA in actionsFSMlist.reg_fliplist or rA in actionsFSMlist.fak_fliplist or rA in actionsFSMlist.revertlist:
@@ -109,8 +111,8 @@ def main(cont):
109 111
 	og_state = own['aState']
110 112
 	#print(aState, 'cur aState')
111 113
 
112
-	if own['l_aState'] in actionsFSMlist.reg_fliplist:
113
-		zero_blend = True
114
+	#if own['l_aState'] in actionsFSMlist.reg_fliplist:
115
+		#zero_blend = True
114 116
 
115 117
 	#-----------------------
116 118
 	check_state = 'reg_idle'
@@ -250,6 +252,30 @@ def main(cont):
250 252
 		actionPlayer(action)
251 253
 		newState = check_exit(aState, rA, timer, action)
252 254
 
255
+	check_state = 'reg_manual_left'
256
+	if aState == check_state:
257
+		action = getattr(actionsFSMlist, check_state)
258
+		actionPlayer(action)
259
+		newState = check_exit(aState, rA, timer, action)
260
+	
261
+	check_state = 'reg_manual_right'
262
+	if aState == check_state:
263
+		action = getattr(actionsFSMlist, check_state)
264
+		actionPlayer(action)
265
+		newState = check_exit(aState, rA, timer, action)	
266
+
267
+	check_state = 'reg_nmanual_left'
268
+	if aState == check_state:
269
+		action = getattr(actionsFSMlist, check_state)
270
+		actionPlayer(action)
271
+		newState = check_exit(aState, rA, timer, action)
272
+	
273
+	check_state = 'reg_nmanual_right'
274
+	if aState == check_state:
275
+		action = getattr(actionsFSMlist, check_state)
276
+		actionPlayer(action)
277
+		newState = check_exit(aState, rA, timer, action)				
278
+
253 279
 	check_state = 'reg_opos'
254 280
 	if aState == check_state:
255 281
 		action = getattr(actionsFSMlist, check_state)
@@ -561,8 +587,13 @@ def main(cont):
561 587
 	check_state = 'reg_5050'
562 588
 	if aState == check_state:
563 589
 		action = getattr(actionsFSMlist, check_state)
564
-		actionPlayer(action)
565
-		newState = check_exit(aState, rA, timer, action)
590
+		if own['stateTimer'] < getattr(action, 'intro_frames'):	
591
+			intro = getattr(action, 'intro')
592
+			actionPlayer(getattr(actionsFSMlist, intro))
593
+			print('doing intro')	
594
+		else:
595
+			actionPlayer(action)		
596
+		newState = check_exit(aState, rA, timer, action)	
566 597
 
567 598
 	check_state = 'reg_bsboard'
568 599
 	if aState == check_state:
@@ -1010,6 +1041,30 @@ def main(cont):
1010 1041
 		actionPlayer(action)
1011 1042
 		newState = check_exit(aState, rA, timer, action)
1012 1043
 
1044
+	check_state = 'fak_manual_left'
1045
+	if aState == check_state:
1046
+		action = getattr(actionsFSMlist, check_state)
1047
+		actionPlayer(action)
1048
+		newState = check_exit(aState, rA, timer, action)
1049
+	
1050
+	check_state = 'fak_manual_right'
1051
+	if aState == check_state:
1052
+		action = getattr(actionsFSMlist, check_state)
1053
+		actionPlayer(action)
1054
+		newState = check_exit(aState, rA, timer, action)	
1055
+
1056
+	check_state = 'fak_nmanual_left'
1057
+	if aState == check_state:
1058
+		action = getattr(actionsFSMlist, check_state)
1059
+		actionPlayer(action)
1060
+		newState = check_exit(aState, rA, timer, action)
1061
+	
1062
+	check_state = 'fak_nmanual_right'
1063
+	if aState == check_state:
1064
+		action = getattr(actionsFSMlist, check_state)
1065
+		actionPlayer(action)
1066
+		newState = check_exit(aState, rA, timer, action)			
1067
+
1013 1068
 	check_state = 'fak_opos'
1014 1069
 	if aState == check_state:
1015 1070
 		action = getattr(actionsFSMlist, check_state)
@@ -1564,3 +1619,24 @@ def main(cont):
1564 1619
 	#own['l_aState'] = newState
1565 1620
 	#print(own['l_aState'], '----l_aState', own['aState'], 'rA', rA)
1566 1621
 	state_timer(own)
1622
+
1623
+	#print(own['rotz'])
1624
+	skater = dict['p1']
1625
+	
1626
+	if own['requestAction'] == 'reg_roll' and own['rotz'] < .985:
1627
+		frame = int(own['rotz'] * 70) 
1628
+		print(frame)
1629
+		#skater.stopAction(5)	
1630
+		#skater.playAction('reg_roll_tilt', frame,frame, layer=5, play_mode=1, speed=1, blendin=5)
1631
+	else:
1632
+		skater.stopAction(5)	
1633
+		#pass
1634
+
1635
+
1636
+	# skater = dict['p1']
1637
+	# skater.update()
1638
+	# #skater.stopAction(1)
1639
+	# bone = skater.channels['root']
1640
+	# v = mathutils.Vector([bone.location[0], bone.location[1], -.2])
1641
+	# #bone.location = v
1642
+	# skater.update()

+ 259
- 112
scripts/actionsFSMlist.py View File

@@ -8,9 +8,9 @@ revertlist = ['revert1', 'revert2', 'fak_revert1', 'fak_revert2', 'revert3', 're
8 8
 
9 9
 reg_manuallist = ['reg_manual', 'reg_nmanual', 'fak_manual', 'fak_nmanual']
10 10
 
11
-reg_grindlist = ['reg_5050', 'reg_fsboard', 'reg_tailg', 'reg_tailgr', 'reg_tailgl', 'reg_noseg', 'reg_nosegr', 'reg_nosegl', 'reg_noseslide', 'reg_tailslide']
11
+reg_grindlist = ['reg_5050', 'reg_fsboard', 'reg_tailg', 'reg_tailgr', 'reg_tailgl', 'reg_noseg', 'reg_nosegr', 'reg_nosegl', 'reg_noseslide', 'reg_tailslide', 'reg_bsboard']
12 12
 
13
-fak_grindlist = ['fak_5050', 'fak_fsboard', 'fak_tailg', 'fak_tailgr', 'fak_tailgl', 'fak_noseg', 'fak_nosegr', 'fak_nosegl', 'fak_noseslide', 'fak_tailslide']
13
+fak_grindlist = ['fak_5050', 'fak_fsboard', 'fak_tailg', 'fak_tailgr', 'fak_tailgl', 'fak_noseg', 'fak_nosegr', 'fak_nosegl', 'fak_noseslide', 'fak_tailslide', 'fak_bsboard']
14 14
 
15 15
 class a_class:
16 16
 	def __init__(self, name, start, end, dname, dstart, dend, layer, speed, mode, blendin, intro, intro_frames, exits, fe, fef, opposite):
@@ -257,17 +257,19 @@ reg_sit = a_class(
257 257
 
258 258
 reg_onboard = a_class(
259 259
 	#player armature action name, start, end frames
260
-	'reg_noffboard', 20, 1,
260
+	#'reg_noffboard', 24, 1,
261
+	'reg_onboard', 1, 100,
261 262
 	#deck action name, start, end frames  
262
-	'b_reg_offboard', 20, 1,
263
+	#'b_reg_offboard', 24, 1,
264
+	'b_reg_onboard', 1, 100,
263 265
 	#layer, speed, mode (0 = play, 1 = loop), blendin
264
-	1, 1, 1, 5,
266
+	1, 2, 0, 5,
265 267
 	#intro, length
266 268
 	None, 0,
267 269
 	#exits
268 270
 	['reg_roll'],
269 271
 	#force exit, frame
270
-	'reg_roll', 18,
272
+	'reg_roll', 48,
271 273
 	#opposite
272 274
 	None)
273 275
 
@@ -297,7 +299,7 @@ reg_roll = a_class(
297 299
 	#intro, length
298 300
 	None, 0,
299 301
 	#exits
300
-	['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_air', 'reg_air_nose', 'reg_air_tail'],
302
+	['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_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
301 303
 	#force exit, frame
302 304
 	None, 0,
303 305
 	#opposite
@@ -313,7 +315,7 @@ reg_turnLeft = a_class(
313 315
 	#intro, length
314 316
 	None, 0,
315 317
 	#exits
316
-	['reg_roll', 'reg_opos', 'reg_nopos', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail'],
318
+	['reg_roll', 'reg_opos', 'reg_nopos', 'reg_pump', 'reg_pump_left', 'reg_pump_right', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
317 319
 	#force exit, frame
318 320
 	None, 0,
319 321
 	#opposite
@@ -329,24 +331,57 @@ reg_turnRight = a_class(
329 331
 	#intro, length
330 332
 	None, 0,
331 333
 	#exits
332
-	['reg_roll', 'reg_opos', 'reg_nopos', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail'],
334
+	['reg_roll', 'reg_opos', 'reg_nopos', 'reg_pump','reg_pump_left', 'reg_pump_right',  'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
335
+	#force exit, frame
336
+	None, 0,
337
+	#opposite
338
+	None)
339
+
340
+reg_manual_left = a_class(
341
+	#player armature action name, start, end frames
342
+	'reg_manual_left', 10, 90,
343
+	#deck action name, start, end frames  
344
+	'b_reg_manual_left', 10, 90,
345
+	#layer, speed, mode (0 = play, 1 = loop), blendin
346
+	1, 1, 1, 20,
347
+	#intro, length
348
+	None, 0,
349
+	#exits
350
+	['reg_roll', 'reg_opos', 'reg_nopos', 'reg_pump', 'reg_pump_left', 'reg_pump_right', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
351
+	#force exit, frame
352
+	None, 0,
353
+	#opposite
354
+	None)
355
+
356
+reg_manual_right = a_class(
357
+	#player armature action name, start, end frames
358
+	'reg_manual_right', 10, 90,
359
+	#deck action name, start, end frames  
360
+	'b_reg_manual_right', 10, 90,
361
+	#layer, speed, mode (0 = play, 1 = loop), blendin
362
+	1, 1, 1, 20,
363
+	#intro, length
364
+	None, 0,
365
+	#exits
366
+	['reg_roll', 'reg_opos', 'reg_nopos', 'reg_pump','reg_pump_left', 'reg_pump_right',  'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
333 367
 	#force exit, frame
334 368
 	None, 0,
335 369
 	#opposite
336 370
 	None)
337 371
 
338 372
 
373
+
339 374
 reg_opos = a_class(
340 375
 	#player armature action name, start, end frames
341
-	'nopos', 11, 40,
376
+	'nopos', 1, 80,
342 377
 	#deck action name, start, end frames  
343
-	'b_reg', 1, 1,
378
+	'b_reg', 1, 10,
344 379
 	#layer, speed, mode (0 = play, 1 = loop), blendin
345 380
 	1, 1, 1, 15,
346 381
 	#intro, length
347 382
 	None, 0,
348 383
 	#exits
349
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_pump', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail'],
384
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_pump', 'reg_pump_left', 'reg_pump_right', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
350 385
 	#force exit, frame
351 386
 	None, 0,
352 387
 	#opposite
@@ -370,15 +405,15 @@ reg_nopos = a_class(
370 405
 
371 406
 reg_pump = a_class(
372 407
 	#player armature action name, start, end frames
373
-	'nopos', 20, 20,
408
+	'nopos', 1, 80,
374 409
 	#deck action name, start, end frames  
375
-	'b_reg', 1, 1,
410
+	'b_reg', 1, 10,
376 411
 	#layer, speed, mode (0 = play, 1 = loop), blendin
377 412
 	1, 1, 1, 15,
378 413
 	#intro, length
379 414
 	None, 0,
380 415
 	#exits
381
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_pump_left', 'reg_pump_right', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab'],
416
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_pump_left', 'reg_pump_right', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
382 417
 	#force exit, frame
383 418
 	None, 0,
384 419
 	#opposite
@@ -388,13 +423,13 @@ reg_pump_left = a_class(
388 423
 	#player armature action name, start, end frames
389 424
 	'nreg_pump_left', 10, 30,
390 425
 	#deck action name, start, end frames  
391
-	'b_reg_left', 1, 10,
426
+	'b_reg_left', 10, 30,
392 427
 	#layer, speed, mode (0 = play, 1 = loop), blendin
393 428
 	1, .5, 1, 15,
394 429
 	#intro, length
395 430
 	None, 0,
396 431
 	#exits
397
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_pump', 'reg_pump_right', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab'],
432
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_opos', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_pump', 'reg_pump_right', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
398 433
 	#force exit, frame
399 434
 	None, 0,
400 435
 	#opposite
@@ -405,13 +440,13 @@ reg_pump_right = a_class(
405 440
 	#player armature action name, start, end frames
406 441
 	'nreg_pump_right', 10, 30,
407 442
 	#deck action name, start, end frames  
408
-	'b_reg_right', 1, 10,
443
+	'b_reg_right', 10, 30,
409 444
 	#layer, speed, mode (0 = play, 1 = loop), blendin
410 445
 	1, .5, 1, 15,
411 446
 	#intro, length
412 447
 	None, 0,
413 448
 	#exits
414
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_pump', 'reg_pump_left', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab'],
449
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_opos', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_pump', 'reg_pump_left', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
415 450
 	#force exit, frame
416 451
 	None, 0,
417 452
 	#opposite
@@ -427,7 +462,7 @@ reg_push = a_class(
427 462
 	#intro, length
428 463
 	None, 0,
429 464
 	#exits
430
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail'],
465
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right'],
431 466
 	#force exit, frame
432 467
 	None, 0,
433 468
 	#opposite
@@ -443,7 +478,7 @@ reg_push_goof = a_class(
443 478
 	#intro, length
444 479
 	None, 0,
445 480
 	#exits
446
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail'],
481
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_powerslide', 'reg_fs_powerslide', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right'],
447 482
 	#force exit, frame
448 483
 	None, 0,
449 484
 	#opposite
@@ -492,7 +527,7 @@ reg_powerslide = a_class(
492 527
 	#intro, length
493 528
 	'reg_powerslide_in', 20,
494 529
 	#exits
495
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail'],
530
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
496 531
 	#force exit, frame
497 532
 	None, 0,
498 533
 	#opposite
@@ -508,7 +543,7 @@ reg_fs_powerslide = a_class(
508 543
 	#intro, length
509 544
 	'reg_fs_powerslide_in', 20,
510 545
 	#exits
511
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail'],
546
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
512 547
 	#force exit, frame
513 548
 	None, 0,
514 549
 	#opposite
@@ -524,7 +559,7 @@ reg_brfoot = a_class(
524 559
 	#intro, length
525 560
 	None, 0,
526 561
 	#exits
527
-	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual', 'reg_nmanual', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail'],
562
+	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual', 'reg_nmanual', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
528 563
 	#force exit, frame
529 564
 	'reg_air', 20,
530 565
 	#opposite
@@ -540,7 +575,7 @@ reg_frfoot = a_class(
540 575
 	#intro, length
541 576
 	None, 0,
542 577
 	#exits
543
-	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual', 'reg_nmanual', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail'],
578
+	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual', 'reg_nmanual', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
544 579
 	#force exit, frame
545 580
 	'reg_air', 20,
546 581
 	#opposite
@@ -556,7 +591,7 @@ reg_blfoot = a_class(
556 591
 	#intro, length
557 592
 	None, 0,
558 593
 	#exits
559
-	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual', 'reg_nmanual', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail'],
594
+	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual', 'reg_nmanual', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
560 595
 	#force exit, frame
561 596
 	'reg_air', 20,
562 597
 	#opposite
@@ -573,7 +608,7 @@ reg_flfoot = a_class(
573 608
 	#intro, length
574 609
 	None, 0,
575 610
 	#exits
576
-	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual', 'reg_nmanual', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail'],
611
+	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual', 'reg_nmanual', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_manual', 'reg_nmanual', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
577 612
 	#force exit, frame
578 613
 	'reg_air', 20,
579 614
 	#opposite
@@ -582,15 +617,15 @@ reg_flfoot = a_class(
582 617
 
583 618
 reg_manual = a_class(
584 619
 	#player armature action name, start, end frames
585
-	'reg_manual', 20, 20,
620
+	'reg_manual', 10, 90,
586 621
 	#deck action name, start, end frames  
587
-	'b_reg_manual', 20, 20,
622
+	'b_reg_manual', 10, 70,
588 623
 	#layer, speed, mode (0 = play, 1 = loop), blendin
589 624
 	1, 1, 1, 10,
590 625
 	#intro, length
591 626
 	None, 0,
592 627
 	#exits
593
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail'],
628
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
594 629
 	#force exit, frame
595 630
 	None, 0,
596 631
 	#opposite
@@ -598,20 +633,53 @@ reg_manual = a_class(
598 633
 
599 634
 reg_nmanual = a_class(
600 635
 	#player armature action name, start, end frames
601
-	'reg_nmanual', 20, 20,
636
+	'reg_nmanual', 10, 90,
602 637
 	#deck action name, start, end frames  
603
-	'b_fak_manual', 20, 20,
638
+	'b_fak_manual', 10, 90,
604 639
 	#layer, speed, mode (0 = play, 1 = loop), blendin
605 640
 	1, 1, 1, 10,
606 641
 	#intro, length
607 642
 	None, 0,
608 643
 	#exits
609
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail'],
644
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
610 645
 	#force exit, frame
611 646
 	None, 0,
612 647
 	#opposite
613 648
 	None)
614 649
 
650
+reg_nmanual_left = a_class(
651
+	#player armature action name, start, end frames
652
+	'reg_nmanual_left', 10, 90,
653
+	#deck action name, start, end frames  
654
+	'b_fak_manual_right', 10, 70,
655
+	#layer, speed, mode (0 = play, 1 = loop), blendin
656
+	1, 1, 1, 10,
657
+	#intro, length
658
+	None, 0,
659
+	#exits
660
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
661
+	#force exit, frame
662
+	None, 0,
663
+	#opposite
664
+	None)
665
+
666
+reg_nmanual_right = a_class(
667
+	#player armature action name, start, end frames
668
+	'reg_nmanual_right', 10, 90,
669
+	#deck action name, start, end frames  
670
+	'b_fak_manual_left', 10, 70,
671
+	#layer, speed, mode (0 = play, 1 = loop), blendin
672
+	1, 1, 1, 10,
673
+	#intro, length
674
+	None, 0,
675
+	#exits
676
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard', 'reg_air', 'reg_air_nose', 'reg_air_tail', 'reg_manual_left', 'reg_manual_right', 'reg_nmanual_left', 'reg_nmanual_right'],
677
+	#force exit, frame
678
+	None, 0,
679
+	#opposite
680
+	None)
681
+
682
+
615 683
 reg_land = a_class(
616 684
 	#player armature action name, start, end frames
617 685
 	'reg_land', 1, 40,
@@ -622,7 +690,7 @@ reg_land = a_class(
622 690
 	#intro, length
623 691
 	None, 0,
624 692
 	#exits
625
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard'],
693
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard', 'reg_manual_left', 'reg_manual_right', 'reg_manual', 'reg_nmanual', 'reg_nmanual_left', 'reg_nmanual_right'],
626 694
 	#force exit, frame
627 695
 	'reg_roll', 20,
628 696
 	#opposite
@@ -638,7 +706,7 @@ reg_landL = a_class(
638 706
 	#intro, length
639 707
 	None, 0,
640 708
 	#exits
641
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard'],
709
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard', 'reg_manual_left', 'reg_manual_right', 'reg_manual', 'reg_nmanual', 'reg_nmanual_left', 'reg_nmanual_right'],
642 710
 	#force exit, frame
643 711
 	'reg_roll', 20,
644 712
 	#opposite
@@ -654,7 +722,7 @@ reg_landR = a_class(
654 722
 	#intro, length
655 723
 	None, 0,
656 724
 	#exits
657
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard'],
725
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard', 'reg_manual_left', 'reg_manual_right', 'reg_manual', 'reg_nmanual', 'reg_nmanual_left', 'reg_nmanual_right'],
658 726
 	#force exit, frame
659 727
 	'reg_roll', 20,
660 728
 	#opposite
@@ -670,7 +738,7 @@ reg_landLb = a_class(
670 738
 	#intro, length
671 739
 	None, 0,
672 740
 	#exits
673
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard'],
741
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard', 'reg_manual_left', 'reg_manual_right', 'reg_manual', 'reg_nmanual', 'reg_nmanual_left', 'reg_nmanual_right'],
674 742
 	#force exit, frame
675 743
 	'reg_roll', 20,
676 744
 	#opposite
@@ -686,7 +754,7 @@ reg_landRb = a_class(
686 754
 	#intro, length
687 755
 	None, 0,
688 756
 	#exits
689
-	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard'],
757
+	['reg_roll', 'reg_turnRight', 'reg_turnLeft', 'reg_push', 'reg_push_goof', 'reg_pump', 'reg_nopos', 'reg_opos', 'reg_offboard', 'reg_manual_left', 'reg_manual_right', 'reg_manual', 'reg_nmanual', 'reg_nmanual_left', 'reg_nmanual_right'],
690 758
 	#force exit, frame
691 759
 	'reg_roll', 20,
692 760
 	#opposite
@@ -694,15 +762,15 @@ reg_landRb = a_class(
694 762
 
695 763
 reg_air = a_class(
696 764
 	#player armature action name, start, end frames
697
-	'reg_air', 1, 30,
765
+	'reg_air', 1, 80,
698 766
 	#deck action name, start, end frames  
699 767
 	'b_reg', 1, 30,
700 768
 	#layer, speed, mode (0 = play, 1 = loop), blendin
701
-	1, 1, 1, 10,
769
+	1, 1, 1, 20,
702 770
 	#intro, length
703 771
 	None, 0,
704 772
 	#exits
705
-	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_air_nose', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_judo', 'reg_frigid', 'reg_onefoot', 'reg_fsonefoot', 'reg_airwalk', 'reg_wall_r', 'reg_wall_l'],
773
+	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_air_nose', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_judo', 'reg_frigid', 'reg_onefoot', 'reg_fsonefoot', 'reg_airwalk', 'reg_wall_r', 'reg_wall_l', 'reg_manual_left', 'reg_manual_right', 'reg_manual', 'reg_nmanual', 'reg_nmanual_left', 'reg_nmanual_right'],
706 774
 	#force exit, frame
707 775
 	None, 0,
708 776
 	#opposite
@@ -718,7 +786,7 @@ reg_air_nb = a_class(
718 786
 	#intro, length
719 787
 	None, 0,
720 788
 	#exits
721
-	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_air_nose', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_judo', 'reg_frigid', 'reg_onefoot', 'reg_fsonefoot', 'reg_airwalk', 'reg_wall_r', 'reg_wall_l'],
789
+	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_air_nose', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_judo', 'reg_frigid', 'reg_onefoot', 'reg_fsonefoot', 'reg_airwalk', 'reg_wall_r', 'reg_wall_l', 'reg_manual_left', 'reg_manual_right', 'reg_manual', 'reg_nmanual', 'reg_nmanual_left', 'reg_nmanual_right'],
722 790
 	#force exit, frame
723 791
 	None, 0,
724 792
 	#opposite
@@ -735,7 +803,7 @@ reg_air_nose = a_class(
735 803
 	#intro, length
736 804
 	None, 0,
737 805
 	#exits
738
-	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual', 'reg_nmanual', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_airwalk', 'reg_wall_r', 'reg_wall_l'],
806
+	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual', 'reg_nmanual', 'reg_air_tail', 'reg_ollie_north', 'reg_ollie_south', 'reg_airwalk', 'reg_wall_r', 'reg_wall_l', 'reg_manual_left', 'reg_manual_right', 'reg_manual', 'reg_nmanual', 'reg_nmanual_left', 'reg_nmanual_right'],
739 807
 	#force exit, frame
740 808
 	None, 0,
741 809
 	#opposite
@@ -751,7 +819,7 @@ reg_air_tail = a_class(
751 819
 	#intro, length
752 820
 	None, 0,
753 821
 	#exits
754
-	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual', 'reg_nmanual', 'reg_air_nose', 'reg_ollie_north', 'reg_ollie_south', 'reg_airwalk', 'reg_wall_r', 'reg_wall_l'],
822
+	['reg_offboard', 'reg_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'reg_manual', 'reg_nmanual', 'reg_air_nose', 'reg_ollie_north', 'reg_ollie_south', 'reg_airwalk', 'reg_wall_r', 'reg_wall_l', 'reg_manual_left', 'reg_manual_right', 'reg_manual', 'reg_nmanual', 'reg_nmanual_left', 'reg_nmanual_right'],
755 823
 	#force exit, frame
756 824
 	None, 0,
757 825
 	#opposite
@@ -764,6 +832,7 @@ reg_air_tail = a_class(
764 832
 #**********************#
765 833
 #**********************#
766 834
 #**********************#
835
+fliplay = 3
767 836
 
768 837
 reg_ollie = a_class(
769 838
 	#player armature action name, start, end frames
@@ -771,13 +840,13 @@ reg_ollie = a_class(
771 840
 	#deck action name, start, end frames  
772 841
 	'b_reg_ollie', 1, 20,
773 842
 	#layer, speed, mode (0 = play, 1 = loop), blendin
774
-	3, .5, 0, 10,
843
+	fliplay, .5, 0, 10,
775 844
 	#intro, length
776 845
 	None, 0,
777 846
 	#exits
778 847
 	['reg_offboard'],
779 848
 	#force exit, frame
780
-	'reg_air', 30,
849
+	'reg_air', 36,
781 850
 	#opposite
782 851
 	None)
783 852
 
@@ -788,13 +857,13 @@ reg_heelflip = a_class(
788 857
 	#deck action name, start, end frames  
789 858
 	'b_reg_heelflip', 0, 20,
790 859
 	#layer, speed, mode (0 = play, 1 = loop), blendin
791
-	3, .5, 0, 10,
860
+	fliplay, .5, 0, 10,
792 861
 	#intro, length
793 862
 	None, 0,
794 863
 	#exits
795 864
 	['reg_offboard'],
796 865
 	#force exit, frame
797
-	'reg_air_nb', 38,
866
+	'reg_air', 38,
798 867
 	#opposite
799 868
 	None)
800 869
 
@@ -805,13 +874,13 @@ reg_kickflip = a_class(
805 874
 	#deck action name, start, end frames  
806 875
 	'b_reg_kickflip', 0, 20,
807 876
 	#layer, speed, mode (0 = play, 1 = loop), blendin
808
-	3, .5, 0, 10,
877
+	fliplay, .5, 0, 10,
809 878
 	#intro, length
810 879
 	None, 0,
811 880
 	#exits
812 881
 	['reg_offboard'],
813 882
 	#force exit, frame
814
-	'reg_air_nb', 38,
883
+	'reg_air', 38,
815 884
 	#opposite
816 885
 	None)
817 886
 
@@ -821,7 +890,7 @@ reg_shuvit = a_class(
821 890
 	#deck action name, start, end frames  
822 891
 	'b_reg_shuvit', 1, 40,
823 892
 	#layer, speed, mode (0 = play, 1 = loop), blendin
824
-	3, 1, 0, 10,
893
+	fliplay, 1, 0, 10,
825 894
 	#intro, length
826 895
 	None, 0,
827 896
 	#exits
@@ -837,7 +906,7 @@ reg_shuvit360 = a_class(
837 906
 	#deck action name, start, end frames  
838 907
 	'b_reg_360shuvit', 1, 20,
839 908
 	#layer, speed, mode (0 = play, 1 = loop), blendin
840
-	3, .5, 0, 10,
909
+	fliplay, .5, 0, 10,
841 910
 	#intro, length
842 911
 	None, 0,
843 912
 	#exits
@@ -853,7 +922,7 @@ reg_fsshuvit = a_class(
853 922
 	#deck action name, start, end frames  
854 923
 	'b_reg_fsshuvit', 1, 40,
855 924
 	#layer, speed, mode (0 = play, 1 = loop), blendin
856
-	3, 1, 0, 10,
925
+	fliplay, 1, 0, 10,
857 926
 	#intro, length
858 927
 	None, 0,
859 928
 	#exits
@@ -869,7 +938,7 @@ reg_fsshuvit360 = a_class(
869 938
 	#deck action name, start, end frames  
870 939
 	'b_reg_360fsshuvit', 1, 20,
871 940
 	#layer, speed, mode (0 = play, 1 = loop), blendin
872
-	3, .5, 0, 10,
941
+	fliplay, .5, 0, 10,
873 942
 	#intro, length
874 943
 	None, 0,
875 944
 	#exits
@@ -885,13 +954,13 @@ reg_hardflip = a_class(
885 954
 	#deck action name, start, end frames  
886 955
 	'b_reg_hardflip', 1, 40,
887 956
 	#layer, speed, mode (0 = play, 1 = loop), blendin
888
-	3, 1, 0, 10,
957
+	fliplay, 1, 0, 10,
889 958
 	#intro, length
890 959
 	None, 0,
891 960
 	#exits
892 961
 	['reg_offboard'],
893 962
 	#force exit, frame
894
-	'reg_air_nb', 38,
963
+	'reg_air', 38,
895 964
 	#opposite
896 965
 	None)
897 966
 
@@ -901,13 +970,13 @@ reg_inward_heelflip = a_class(
901 970
 	#deck action name, start, end frames  
902 971
 	'b_reg_inward_heelflip', 1, 40,
903 972
 	#layer, speed, mode (0 = play, 1 = loop), blendin
904
-	3, 1, 0, 10,
973
+	fliplay, 1, 0, 10,
905 974
 	#intro, length
906 975
 	None, 0,
907 976
 	#exits
908 977
 	['reg_offboard'],
909 978
 	#force exit, frame
910
-	'reg_air_nb', 38,
979
+	'reg_air', 38,
911 980
 	#opposite
912 981
 	None)
913 982
 
@@ -917,13 +986,13 @@ reg_varial_kickflip = a_class(
917 986
 	#deck action name, start, end frames  
918 987
 	'b_reg_varialkickflip', 1, 40,
919 988
 	#layer, speed, mode (0 = play, 1 = loop), blendin
920
-	3, 1, 0, 10,
989
+	fliplay, 1, 0, 10,
921 990
 	#intro, length
922 991
 	None, 0,
923 992
 	#exits
924 993
 	['reg_offboard'],
925 994
 	#force exit, frame
926
-	'reg_air_nb', 38,
995
+	'reg_air', 38,
927 996
 	#opposite
928 997
 	None)
929 998
 
@@ -933,13 +1002,13 @@ reg_varial_heelflip = a_class(
933 1002
 	#deck action name, start, end frames  
934 1003
 	'b_reg_varialheelflip', 1, 40,
935 1004
 	#layer, speed, mode (0 = play, 1 = loop), blendin
936
-	3, 1, 0, 10,
1005
+	fliplay, 1, 0, 10,
937 1006
 	#intro, length
938 1007
 	None, 0,
939 1008
 	#exits
940 1009
 	['reg_offboard'],
941 1010
 	#force exit, frame
942
-	'reg_air_nb', 38,
1011
+	'reg_air', 38,
943 1012
 	#opposite
944 1013
 	None)
945 1014
 
@@ -1573,21 +1642,33 @@ reg_wall_l = a_class(
1573 1642
 
1574 1643
 
1575 1644
 
1576
-
1577
-
1578
-
1645
+reg_5050_in = a_class(
1646
+	#player armature action name, start, end frames
1647
+	'reg_5050', 1, 20,
1648
+	#deck action name, start, end frames  
1649
+	'b_reg', 1, 20,
1650
+	#layer, speed, mode (0 = play, 1 = loop), blendin
1651
+	1, .5, 0, 10,
1652
+	#intro, length
1653
+	None, 0,
1654
+	#exits
1655
+	['reg_5050'],
1656
+	#force exit, frame
1657
+	'reg_5050', 19,
1658
+	#opposite
1659
+	'fak_5050')
1579 1660
 
1580 1661
 reg_5050 = a_class(
1581 1662
 	#player armature action name, start, end frames
1582
-	'reg_5050', 1, 30,
1663
+	'reg_5050', 20, 50,
1583 1664
 	#deck action name, start, end frames  
1584
-	'b_reg', 1, 1,
1665
+	'b_reg', 1, 30,
1585 1666
 	#layer, speed, mode (0 = play, 1 = loop), blendin
1586
-	1, .5, 1, 10,
1667
+	1, .5, 0, 10,
1587 1668
 	#intro, length
1588
-	None, 0,
1669
+	'reg_5050_in', 20,
1589 1670
 	#exits
1590
-	['reg_air', 'reg_roll'],
1671
+	['reg_air', 'reg_roll'] + reg_fliplist,
1591 1672
 	#force exit, frame
1592 1673
 	None, 0,
1593 1674
 	#opposite
@@ -1603,7 +1684,7 @@ reg_bsboard = a_class(
1603 1684
 	#intro, length
1604 1685
 	None, 0,
1605 1686
 	#exits
1606
-	['reg_air', 'reg_roll'],
1687
+	['reg_air', 'reg_roll'] + reg_fliplist,
1607 1688
 	#force exit, frame
1608 1689
 	None, 0,
1609 1690
 	#opposite
@@ -1725,7 +1806,7 @@ reg_tailslide = a_class(
1725 1806
 	#player armature action name, start, end frames
1726 1807
 	'fak_noses', 30, 1,
1727 1808
 	#deck action name, start, end frames  
1728
-	'b_fak_noses', 1, 1,
1809
+	'b_fak_noses', 1, 30,
1729 1810
 	#layer, speed, mode (0 = play, 1 = loop), blendin
1730 1811
 	1, .5, 1, 15,
1731 1812
 	#intro, length
@@ -2192,7 +2273,7 @@ fak_roll = a_class(
2192 2273
 	#intro, length
2193 2274
 	None, 0,
2194 2275
 	#exits
2195
-	['fak_idle', 'fak_offboard', 'fak_turnLeft', 'fak_turnRight', 'fak_opos', 'fak_nopos', 'fak_pump', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2276
+	['fak_idle', 'fak_offboard', 'fak_turnLeft', 'fak_turnRight', 'fak_opos', 'fak_nopos', 'fak_pump', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2196 2277
 	#force exit, frame
2197 2278
 	None, 0,
2198 2279
 	#opposite
@@ -2208,7 +2289,7 @@ fak_turnLeft = a_class(
2208 2289
 	#intro, length
2209 2290
 	None, 0,
2210 2291
 	#exits
2211
-	['fak_roll', 'fak_opos', 'fak_nopos', 'fak_pump', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2292
+	['fak_roll', 'fak_opos', 'fak_nopos', 'fak_pump', 'fak_pump_left', 'fak_pump_right', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2212 2293
 	#force exit, frame
2213 2294
 	None, 0,
2214 2295
 	#opposite
@@ -2224,7 +2305,7 @@ fak_turnRight = a_class(
2224 2305
 	#intro, length
2225 2306
 	None, 0,
2226 2307
 	#exits
2227
-	['fak_roll', 'fak_opos', 'fak_nopos', 'fak_pump', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2308
+	['fak_roll', 'fak_opos', 'fak_nopos', 'fak_pump', 'fak_pump_left', 'fak_pump_right', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2228 2309
 	#force exit, frame
2229 2310
 	None, 0,
2230 2311
 	#opposite
@@ -2233,15 +2314,15 @@ fak_turnRight = a_class(
2233 2314
 
2234 2315
 fak_opos = a_class(
2235 2316
 	#player armature action name, start, end frames
2236
-	'nfak_pump.001', 1, 60,
2317
+	'fak_opos', 1, 80,
2237 2318
 	#deck action name, start, end frames  
2238
-	'b_reg', 1, 1,
2319
+	'b_reg', 1, 10,
2239 2320
 	#layer, speed, mode (0 = play, 1 = loop), blendin
2240 2321
 	1, 1, 1, 15,
2241 2322
 	#intro, length
2242 2323
 	None, 0,
2243 2324
 	#exits
2244
-	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_pump', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2325
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_pump', 'fak_pump_left', 'fak_pump_right', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2245 2326
 	#force exit, frame
2246 2327
 	None, 0,
2247 2328
 	#opposite
@@ -2257,7 +2338,7 @@ fak_nopos = a_class(
2257 2338
 	#intro, length
2258 2339
 	None, 0,
2259 2340
 	#exits
2260
-	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_pump', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2341
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_pump', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2261 2342
 	#force exit, frame
2262 2343
 	None, 0,
2263 2344
 	#opposite
@@ -2265,15 +2346,15 @@ fak_nopos = a_class(
2265 2346
 
2266 2347
 fak_pump = a_class(
2267 2348
 	#player armature action name, start, end frames
2268
-	'nfak_pump.001', 1, 60,
2349
+	'fak_opos', 1, 80,
2269 2350
 	#deck action name, start, end frames  
2270
-	'b_reg', 1, 1,
2351
+	'b_reg', 1, 10,
2271 2352
 	#layer, speed, mode (0 = play, 1 = loop), blendin
2272 2353
 	1, 1, 1, 15,
2273 2354
 	#intro, length
2274 2355
 	None, 0,
2275 2356
 	#exits
2276
-	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_pump_left', 'fak_pump_right', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab'],
2357
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_pump_left', 'fak_pump_right', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2277 2358
 	#force exit, frame
2278 2359
 	None, 0,
2279 2360
 	#opposite
@@ -2283,13 +2364,13 @@ fak_pump_left = a_class(
2283 2364
 	#player armature action name, start, end frames
2284 2365
 	'nfak_pump_left', 10, 30,
2285 2366
 	#deck action name, start, end frames  
2286
-	'b_reg_right', 1, 10,
2367
+	'b_reg_right', 10, 30,
2287 2368
 	#layer, speed, mode (0 = play, 1 = loop), blendin
2288 2369
 	1, .5, 1, 15,
2289 2370
 	#intro, length
2290 2371
 	None, 0,
2291 2372
 	#exits
2292
-	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_pump', 'fak_pump_right', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab'],
2373
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_opos', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_pump', 'fak_pump_right', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2293 2374
 	#force exit, frame
2294 2375
 	None, 0,
2295 2376
 	#opposite
@@ -2300,13 +2381,13 @@ fak_pump_right = a_class(
2300 2381
 	#player armature action name, start, end frames
2301 2382
 	'nfak_pump_right', 10, 30,
2302 2383
 	#deck action name, start, end frames  
2303
-	'b_reg_left', 1, 10,
2384
+	'b_reg_left', 10, 30,
2304 2385
 	#layer, speed, mode (0 = play, 1 = loop), blendin
2305 2386
 	1, .5, 1, 15,
2306 2387
 	#intro, length
2307 2388
 	None, 0,
2308 2389
 	#exits
2309
-	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_pump', 'fak_pump_left', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab'],
2390
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_opos', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_pump', 'fak_pump_left', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2310 2391
 	#force exit, frame
2311 2392
 	None, 0,
2312 2393
 	#opposite
@@ -2322,7 +2403,7 @@ fak_push = a_class(
2322 2403
 	#intro, length
2323 2404
 	None, 0,
2324 2405
 	#exits
2325
-	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2406
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2326 2407
 	#force exit, frame
2327 2408
 	None, 0,
2328 2409
 	#opposite
@@ -2338,7 +2419,7 @@ fak_push_goof = a_class(
2338 2419
 	#intro, length
2339 2420
 	None, 0,
2340 2421
 	#exits
2341
-	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2422
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_powerslide', 'fak_fs_powerslide', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2342 2423
 	#force exit, frame
2343 2424
 	None, 0,
2344 2425
 	#opposite
@@ -2355,7 +2436,7 @@ fak_powerslide_in = a_class(
2355 2436
 	#intro, length
2356 2437
 	None, 0,
2357 2438
 	#exits
2358
-	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2439
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2359 2440
 	#force exit, frame
2360 2441
 	None, 0,
2361 2442
 	#opposite
@@ -2371,7 +2452,7 @@ fak_fs_powerslide_in = a_class(
2371 2452
 	#intro, length
2372 2453
 	'None', 0,
2373 2454
 	#exits
2374
-	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2455
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2375 2456
 	#force exit, frame
2376 2457
 	None, 0,
2377 2458
 	#opposite
@@ -2387,7 +2468,7 @@ fak_powerslide = a_class(
2387 2468
 	#intro, length
2388 2469
 	'fak_powerslide_in', 20,
2389 2470
 	#exits
2390
-	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2471
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2391 2472
 	#force exit, frame
2392 2473
 	None, 0,
2393 2474
 	#opposite
@@ -2403,7 +2484,7 @@ fak_fs_powerslide = a_class(
2403 2484
 	#intro, length
2404 2485
 	'fak_fs_powerslide_in', 20,
2405 2486
 	#exits
2406
-	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2487
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2407 2488
 	#force exit, frame
2408 2489
 	None, 0,
2409 2490
 	#opposite
@@ -2419,7 +2500,7 @@ fak_brfoot = a_class(
2419 2500
 	#intro, length
2420 2501
 	None, 0,
2421 2502
 	#exits
2422
-	['fak_offboard', 'fak_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'fak_manual', 'fak_nmanual', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south', 'fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2503
+	['fak_offboard', 'fak_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'fak_manual', 'fak_nmanual', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south', 'fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2423 2504
 	#force exit, frame
2424 2505
 	'fak_air', 20,
2425 2506
 	#opposite
@@ -2435,7 +2516,7 @@ fak_frfoot = a_class(
2435 2516
 	#intro, length
2436 2517
 	None, 0,
2437 2518
 	#exits
2438
-	['fak_offboard', 'fak_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'fak_manual', 'fak_nmanual', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south', 'fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2519
+	['fak_offboard', 'fak_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'fak_manual', 'fak_nmanual', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south', 'fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2439 2520
 	#force exit, frame
2440 2521
 	'fak_air', 20,
2441 2522
 	#opposite
@@ -2451,7 +2532,7 @@ fak_blfoot = a_class(
2451 2532
 	#intro, length
2452 2533
 	None, 0,
2453 2534
 	#exits
2454
-	['fak_offboard', 'fak_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'fak_manual', 'fak_nmanual', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south', 'fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2535
+	['fak_offboard', 'fak_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'fak_manual', 'fak_nmanual', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south', 'fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2455 2536
 	#force exit, frame
2456 2537
 	'fak_air', 20,
2457 2538
 	#opposite
@@ -2468,7 +2549,7 @@ fak_flfoot = a_class(
2468 2549
 	#intro, length
2469 2550
 	None, 0,
2470 2551
 	#exits
2471
-	['fak_offboard', 'fak_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'fak_manual', 'fak_nmanual', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south', 'fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2552
+	['fak_offboard', 'fak_land', 'frontside_grab', 'backside_grab', 'frontside_nose_grab', 'backside_nose_grab', 'frontside_tail_grab', 'backside_tail_grab', 'fak_manual', 'fak_nmanual', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south', 'fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_manual', 'fak_nmanual', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2472 2553
 	#force exit, frame
2473 2554
 	'fak_air', 20,
2474 2555
 	#opposite
@@ -2477,31 +2558,97 @@ fak_flfoot = a_class(
2477 2558
 
2478 2559
 fak_manual = a_class(
2479 2560
 	#player armature action name, start, end frames
2480
-	'fak_manual', 20, 20,
2561
+	'fak_manual', 10, 90,
2562
+	#deck action name, start, end frames  
2563
+	'b_fak_manual', 10, 90,
2564
+	#layer, speed, mode (0 = play, 1 = loop), blendin
2565
+	1, 1, 1, 10,
2566
+	#intro, length
2567
+	None, 0,
2568
+	#exits
2569
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2570
+	#force exit, frame
2571
+	None, 0,
2572
+	#opposite
2573
+	None)
2574
+
2575
+fak_manual_left = a_class(
2576
+	#player armature action name, start, end frames
2577
+	'fak_manual_left', 10, 90,
2578
+	#deck action name, start, end frames  
2579
+	'b_fak_manual_left', 10, 90,
2580
+	#layer, speed, mode (0 = play, 1 = loop), blendin
2581
+	1, 1, 1, 10,
2582
+	#intro, length
2583
+	None, 0,
2584
+	#exits
2585
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2586
+	#force exit, frame
2587
+	None, 0,
2588
+	#opposite
2589
+	None)
2590
+
2591
+fak_manual_right = a_class(
2592
+	#player armature action name, start, end frames
2593
+	'fak_manual_right', 10, 90,
2481 2594
 	#deck action name, start, end frames  
2482
-	'b_fak_manual', 20, 20,
2595
+	'b_fak_manual_right', 10, 90,
2483 2596
 	#layer, speed, mode (0 = play, 1 = loop), blendin
2484 2597
 	1, 1, 1, 10,
2485 2598
 	#intro, length
2486 2599
 	None, 0,
2487 2600
 	#exits
2488
-	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2601
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2489 2602
 	#force exit, frame
2490 2603
 	None, 0,
2491 2604
 	#opposite
2492 2605
 	None)
2493 2606
 
2607
+
2608
+
2494 2609
 fak_nmanual = a_class(
2495 2610
 	#player armature action name, start, end frames
2496
-	'fak_nmanual', 20, 20,
2611
+	'fak_nmanual', 10, 90,
2612
+	#deck action name, start, end frames  
2613
+	'b_reg_manual', 10, 90,
2614
+	#layer, speed, mode (0 = play, 1 = loop), blendin
2615
+	1, 1, 1, 10,
2616
+	#intro, length
2617
+	None, 0,
2618
+	#exits
2619
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2620
+	#force exit, frame
2621
+	None, 0,
2622
+	#opposite
2623
+	None)
2624
+
2625
+fak_nmanual_left = a_class(
2626
+	#player armature action name, start, end frames
2627
+	'fak_nmanual_left', 10, 90,
2628
+	#deck action name, start, end frames  
2629
+	'b_reg_manual_right', 10, 90,
2630
+	#layer, speed, mode (0 = play, 1 = loop), blendin
2631
+	1, 1, 1, 10,
2632
+	#intro, length
2633
+	None, 0,
2634
+	#exits
2635
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2636
+	#force exit, frame
2637
+	None, 0,
2638
+	#opposite
2639
+	None)
2640
+
2641
+fak_nmanual_right = a_class(
2642
+	#player armature action name, start, end frames
2643
+	'fak_nmanual_right', 10, 90,
2497 2644
 	#deck action name, start, end frames  
2498
-	'b_reg_manual', 20, 20,
2645
+	'b_reg_manual_left', 10, 90,
2499 2646
 	#layer, speed, mode (0 = play, 1 = loop), blendin
2500 2647
 	1, 1, 1, 10,
2501 2648
 	#intro, length
2502 2649
 	None, 0,
2503 2650
 	#exits
2504
-	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail'],
2651
+	['fak_roll', 'fak_turnRight', 'fak_turnLeft', 'fak_push', 'fak_push_goof', 'fak_pump', 'fak_nopos', 'fak_opos', 'fak_offboard', 'fak_air', 'fak_air_nose', 'fak_air_tail', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2505 2652
 	#force exit, frame
2506 2653
 	None, 0,
2507 2654
 	#opposite
@@ -2509,7 +2656,7 @@ fak_nmanual = a_class(
2509 2656
 
2510 2657
 fak_land = a_class(
2511 2658
 	#player armature action name, start, end frames
2512
-	'fak_land', 1, 40,
2659
+	'fak_land', 1, 46,
2513 2660
 	#deck action name, start, end frames  
2514 2661
 	'b_reg', 1, 40,
2515 2662
 	#layer, speed, mode (0 = play, 1 = loop), blendin
@@ -2525,7 +2672,7 @@ fak_land = a_class(
2525 2672
 
2526 2673
 fak_landL = a_class(
2527 2674
 	#player armature action name, start, end frames
2528
-	'fak_landL', 1, 40,
2675
+	'fak_landL', 1, 46,
2529 2676
 	#deck action name, start, end frames  
2530 2677
 	'b_reg', 1, 40,
2531 2678
 	#layer, speed, mode (0 = play, 1 = loop), blendin
@@ -2541,7 +2688,7 @@ fak_landL = a_class(
2541 2688
 
2542 2689
 fak_landR = a_class(
2543 2690
 	#player armature action name, start, end frames
2544
-	'fak_landR', 1, 40,
2691
+	'fak_landR', 1, 46,
2545 2692
 	#deck action name, start, end frames  
2546 2693
 	'b_reg', 1, 40,
2547 2694
 	#layer, speed, mode (0 = play, 1 = loop), blendin
@@ -2557,7 +2704,7 @@ fak_landR = a_class(
2557 2704
 
2558 2705
 fak_landLb = a_class(
2559 2706
 	#player armature action name, start, end frames
2560
-	'fak_landLb', 1, 40,
2707
+	'fak_landLb', 1, 46,
2561 2708
 	#deck action name, start, end frames  
2562 2709
 	'b_reg', 1, 40,
2563 2710
 	#layer, speed, mode (0 = play, 1 = loop), blendin
@@ -2573,7 +2720,7 @@ fak_landLb = a_class(
2573 2720
 
2574 2721
 fak_landRb = a_class(
2575 2722
 	#player armature action name, start, end frames
2576
-	'fak_landRb', 1, 40,
2723
+	'fak_landRb', 1, 46,
2577 2724
 	#deck action name, start, end frames  
2578 2725
 	'b_reg', 1, 40,
2579 2726
 	#layer, speed, mode (0 = play, 1 = loop), blendin
@@ -2597,7 +2744,7 @@ fak_air = a_class(
2597 2744
 	#intro, length
2598 2745
 	None, 0,
2599 2746
 	#exits
2600
-	['fak_offboard', 'fak_land', 'fak_frontside_grab', 'fak_backside_grab', 'fak_frontside_nose_grab', 'fak_backside_nose_grab', 'fak_frontside_tail_grab', 'fak_backside_tail_grab', 'fak_air_nose', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south', 'fak_judo', 'fak_frigid', 'fak_onefoot', 'fak_fsonefoot'],
2747
+	['fak_offboard', 'fak_land', 'fak_frontside_grab', 'fak_backside_grab', 'fak_frontside_nose_grab', 'fak_backside_nose_grab', 'fak_frontside_tail_grab', 'fak_backside_tail_grab', 'fak_air_nose', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south', 'fak_judo', 'fak_frigid', 'fak_onefoot', 'fak_fsonefoot', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2601 2748
 	#force exit, frame
2602 2749
 	None, 0,
2603 2750
 	#opposite
@@ -2613,7 +2760,7 @@ fak_air_nb = a_class(
2613 2760
 	#intro, length
2614 2761
 	None, 0,
2615 2762
 	#exits
2616
-	['fak_offboard', 'fak_land', 'fak_frontside_grab', 'fak_backside_grab', 'fak_frontside_nose_grab', 'fak_backside_nose_grab', 'fak_frontside_tail_grab', 'fak_backside_tail_grab', 'fak_air_nose', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south', 'fak_judo', 'fak_frigid', 'fak_onefoot', 'fak_fsonefoot'],
2763
+	['fak_offboard', 'fak_land', 'fak_frontside_grab', 'fak_backside_grab', 'fak_frontside_nose_grab', 'fak_backside_nose_grab', 'fak_frontside_tail_grab', 'fak_backside_tail_grab', 'fak_air_nose', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south', 'fak_judo', 'fak_frigid', 'fak_onefoot', 'fak_fsonefoot', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2617 2764
 	#force exit, frame
2618 2765
 	None, 0,
2619 2766
 	#opposite
@@ -2630,7 +2777,7 @@ fak_air_nose = a_class(
2630 2777
 	#intro, length
2631 2778
 	None, 0,
2632 2779
 	#exits
2633
-	['fak_offboard', 'fak_land', 'fak_frontside_grab', 'fak_backside_grab', 'fak_frontside_nose_grab', 'fak_backside_nose_grab', 'fak_frontside_tail_grab', 'fak_backside_tail_grab', 'fak_manual', 'fak_nmanual', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south'],
2780
+	['fak_offboard', 'fak_land', 'fak_frontside_grab', 'fak_backside_grab', 'fak_frontside_nose_grab', 'fak_backside_nose_grab', 'fak_frontside_tail_grab', 'fak_backside_tail_grab', 'fak_manual', 'fak_nmanual', 'fak_air_tail', 'fak_ollie_north', 'fak_ollie_south', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2634 2781
 	#force exit, frame
2635 2782
 	None, 0,
2636 2783
 	#opposite
@@ -2646,7 +2793,7 @@ fak_air_tail = a_class(
2646 2793
 	#intro, length
2647 2794
 	None, 0,
2648 2795
 	#exits
2649
-	['fak_offboard', 'fak_land', 'fak_frontside_grab', 'fak_backside_grab', 'fak_frontside_nose_grab', 'fak_backside_nose_grab', 'fak_frontside_tail_grab', 'fak_backside_tail_grab', 'fak_manual', 'fak_nmanual', 'fak_air_nose', 'fak_ollie_north', 'fak_ollie_south'],
2796
+	['fak_offboard', 'fak_land', 'fak_frontside_grab', 'fak_backside_grab', 'fak_frontside_nose_grab', 'fak_backside_nose_grab', 'fak_frontside_tail_grab', 'fak_backside_tail_grab', 'fak_manual', 'fak_nmanual', 'fak_air_nose', 'fak_ollie_north', 'fak_ollie_south', 'fak_manual_left', 'fak_manual_right', 'fak_nmanual_left', 'fak_nmanual_right'],
2650 2797
 	#force exit, frame
2651 2798
 	None, 0,
2652 2799
 	#opposite
@@ -3425,7 +3572,7 @@ fak_fsboard = a_class(
3425 3572
 
3426 3573
 fak_noseg = a_class(
3427 3574
 	#player armature action name, start, end frames
3428
-	'fak_noseg', 11, 40,
3575
+	'fak_noseg', 1, 30,
3429 3576
 	#deck action name, start, end frames  
3430 3577
 	'b_fak_noseg', 10, 10,
3431 3578
 	#layer, speed, mode (0 = play, 1 = loop), blendin

+ 58
- 0
scripts/birds.py View File

@@ -0,0 +1,58 @@
1
+import bge
2
+import random
3
+
4
+
5
+        
6
+def bird(cont):
7
+    own = cont.owner
8
+    if 'inited' not in own:
9
+        own.worldPosition = own['start'].worldPosition
10
+        own['inited'] = True        
11
+        act = cont.actuators['Steering']
12
+        act.target = own['end']
13
+        act.velocity = 2
14
+        cont.activate(act)
15
+        #print('doing bird')
16
+    if own.getDistanceTo(own['end']) < 1:
17
+        own.endObject()
18
+        #print('kill bird') 
19
+
20
+def main(cont, scene):
21
+
22
+    def build_bird_list(scene,own):
23
+        own['bird_list'] = []
24
+        for x in scene.objects:
25
+            if 'bird_target' in x.name:
26
+                own['bird_list'].append(x)
27
+                
28
+    def do_birds(scene, own, cont):
29
+        num = random.randint(0,2)
30
+        if own['life'] % 50 == 0 and num == 1:
31
+            #print('add bird')
32
+            top = len(own['bird_list']) - 1
33
+            start = random.randint(0, top)
34
+            end = start
35
+            while end == start:
36
+                end = random.randint(0, top)
37
+            obj = scene.addObject('bird_cont', own['bird_list'][start], 0)                
38
+            obj['start'] = own['bird_list'][start]
39
+            obj['end'] = own['bird_list'][end]
40
+            obj.worldPosition = obj['start'].worldPosition
41
+            #print(obj['start'], obj['end'])
42
+            
43
+    def life(own):
44
+        if 'life' in own:
45
+            own['life'] += 1     
46
+        else:
47
+            own['life'] = 0    
48
+        
49
+  
50
+
51
+    own = cont.owner
52
+    if 'binited' not in own:
53
+        build_bird_list(scene, own)            
54
+        own['binited'] = True
55
+
56
+    life(own)    
57
+    do_birds(scene, own, cont)  
58
+    #print('birding')    

+ 2
- 2
scripts/boneRecord.py View File

@@ -17,7 +17,7 @@ def Record():
17 17
     cam = scene.objects['Camera.003']
18 18
     armature = scene.objects['Char4']
19 19
     deck = scene.objects['deck_arm']
20
-
20
+    #print('bone recording')
21 21
     if 'dataList' not in master:
22 22
         for x in bone_list:
23 23
             master['dataList'] = True
@@ -47,7 +47,7 @@ def Record():
47 47
         master[str(y) + '-rot'].append(rot)
48 48
 
49 49
         master[str(y) + '-pos'].append(pos)
50
-        master[str(y) + '-rot'].append(rot) 
50
+        master[str(y) + '-rot'].append(rot)
51 51
 
52 52
 
53 53
 

+ 62
- 10
scripts/camFSM.py View File

@@ -1,4 +1,5 @@
1 1
 import bge
2
+import math
2 3
 from random import randint
3 4
 from time import clock
4 5
 dict = bge.logic.globalDict
@@ -92,13 +93,65 @@ class RollCam(State):
92 93
     def Execute(self):
93 94
         #print('Eating Breakfast.', self.FSM.stateLife)
94 95
         self.FSM.stateLife += 1
95
-        duration = 500
96
-        #activate_camera('camCube', 1.5, 3, 2)
97
-        new_state = get_request_state(self.__class__.__name__)
98
-        if new_state:
99
-            self.FSM.ToTransition(new_state)
100
-            print('call new state') 
101
-                
96
+        #duration = 500
97
+        if self.FSM.stateLife > 60:
98
+            dict = bge.logic.globalDict
99
+            own = dict['p1c']
100
+            if own['grinding'] == True:
101
+                scene = bge.logic.getCurrentScene()
102
+                ce = scene.objects['cam_helper2']
103
+                ce.worldPosition = own.worldPosition
104
+                ce.worldOrientation = own.worldOrientation
105
+                #ce.applyMovement([-1,0,0], True)
106
+                #activate_camera('camCube', 1.5, 3, 2)
107
+                fliplist = ['reg_tailslide', 'reg_noseslide', 'reg_bsboard', 'fak_tailslide', 'fak_noseslide', 'fak_bsboard']            
108
+                #fliplist = []
109
+                stre = .02
110
+                local = own.worldOrientation.inverted() * (dict['camera'].worldPosition - own.worldPosition) 
111
+                if local.y > 0:
112
+                    rot = 'right'
113
+                else:
114
+                    rot = 'left'       
115
+                print(own['requestAction'])
116
+                yval = 0
117
+                if own['stance'] == True:
118
+                    xval = -1
119
+                else:
120
+                    xval = 1    
121
+                if rot == 'right':
122
+                    yval = 1
123
+                    if own['requestAction'] in fliplist:
124
+                        xval *= -1
125
+                        #print('flipping')
126
+                    dict['camera'].worldPosition = dict['camera'].worldPosition.lerp(ce.worldPosition, stre)
127
+                else:
128
+                    yval = -1
129
+                    if own['requestAction'] in fliplist:
130
+                        xval *= -1
131
+                        print('flipping')
132
+            
133
+                ce.applyMovement([xval,yval,0], True)
134
+                dict['camera'].worldPosition = dict['camera'].worldPosition.lerp(ce.worldPosition, stre)
135
+
136
+
137
+
138
+                # cont = bge.logic.getCurrentController()
139
+                # scene = bge.logic.getCurrentScene()
140
+                # camActu = cont.actuators['Camera']
141
+                # #camActu.object = scene.objects[cobj]
142
+                # camActu.damping = 0
143
+                # #camActu.max = cmax
144
+                # #camActu.height = cheight
145
+                # cont.activate(camActu)
146
+
147
+
148
+            #activate_camera('camCube', 1.5, 3, 2)
149
+            new_state = get_request_state(self.__class__.__name__)
150
+
151
+            if new_state:
152
+                self.FSM.ToTransition(new_state)
153
+                print('call new state') 
154
+                    
102 155
     def Exit(self):
103 156
         print('Finished RollCaming')          
104 157
         
@@ -152,7 +205,7 @@ class PauseIdleCam(State):
152 205
         
153 206
     def Enter(self):
154 207
         print('Starting to PauseIdleCam.')
155
-        super(PauseCam, self).Enter()
208
+        super(PauseIdleCam, self).Enter()
156 209
         self.FSM.stateLife = 1
157 210
         
158 211
     def Execute(self):
@@ -207,7 +260,6 @@ Char = type("Char",(object,),{})
207 260
 class CameraFSM(Char):
208 261
     def __init__(self):
209 262
         self.FSM = FSM(self)
210
-        
211 263
         ##STATES
212 264
         self.FSM.AddState('WalkCam', WalkCam(self.FSM))
213 265
         self.FSM.AddState('RollCam', RollCam(self.FSM))
@@ -232,11 +284,11 @@ class CameraFSM(Char):
232 284
 machine = CameraFSM()
233 285
 def main(cont):
234 286
     own = cont.owner   
235
-   
236 287
     if 'FSMinited' not in own:
237 288
         own['FSMinited'] = True
238 289
         #own['frame'] = 0
239 290
         #own['state'] = 'On'
291
+        
240 292
         print('FSMiniting')
241 293
 
242 294
     machine.Execute()    

+ 4
- 1
scripts/camera.py View File

@@ -4,6 +4,7 @@ import mathutils
4 4
 from mathutils import *
5 5
 scene = bge.logic.getCurrentScene()
6 6
 import camFSM
7
+import birds
7 8
 
8 9
 def main(cont):
9 10
     #camFSM.main(cont)
@@ -43,6 +44,7 @@ def main(cont):
43 44
     cam3 = scene.objects['followcam']
44 45
     camList = scene.cameras
45 46
     freecam = camList["freecam"]
47
+    dict['camera'] = cam1
46 48
 
47 49
     if 'init' not in own:
48 50
         own['init'] = 1
@@ -356,4 +358,5 @@ def main(cont):
356 358
             pass
357 359
     set_lens_dist()        
358 360
     get_cam_state()
359
-    camFSM.main(cont)
361
+    camFSM.main(cont)
362
+    birds.main(cont, scene) 

+ 140
- 26
scripts/controller2.py View File

@@ -8,6 +8,7 @@ import ctypes
8 8
 import math
9 9
 from sys import platform
10 10
 from mathutils import Vector
11
+import mathutils
11 12
 
12 13
 def main():
13 14
     scene = bge.logic.getCurrentScene()
@@ -135,6 +136,7 @@ def main():
135 136
     own['pop_sound'] = 0
136 137
     own['land_sound'] = 0
137 138
     own['revert_sound'] = 0
139
+    own['grinding'] = False
138 140
     #own['fall'] = 0
139 141
 
140 142
     #joystick location timers
@@ -201,11 +203,14 @@ def main():
201 203
     land_overRideLb = False
202 204
     land_overRideRb = False
203 205
 
206
+
207
+    #print(linVelocity, 'linvely')
208
+
204 209
     #2019 ground ray detection
205 210
     Axis = 2
206 211
     Distance = -10
207 212
     End = own.worldPosition + (own.worldOrientation.col[Axis]*Distance)
208
-    Start = own.worldPosition
213
+    Start = own.worldPosition.copy()
209 214
     if own['LAST_GRIND']:
210 215
         groundRay = own.rayCast(End, Start, 10,'ground', 1, 0, 0, 53247)
211 216
     else:
@@ -215,7 +220,6 @@ def main():
215 220
     #bge.render.drawLine(Start, End, [255,0,0])
216 221
 
217 222
     if groundRay[0]:
218
-        
219 223
 
220 224
         localHitDist = (own.worldPosition - groundRay[1]).length
221 225
         if localHitDist < .4 and own['jump_timer'] < 32:
@@ -225,14 +229,15 @@ def main():
225 229
             
226 230
             onGround = False   
227 231
             #print('jumptimer', own['jump_timer'])
228
-            #print('not on ground', localHitDist, own['jump_timer'])     
232
+            #print('not on ground', localHitDist, own['jump_timer']) 
233
+       
229 234
     else:
235
+        #if own['LAST_GRIND'] == True:
230 236
         onGround = False
231 237
         #print('not on ground', grindRay[0], own['LAST_GRIND'])
232 238
         if grindRay[0] and own['LAST_GRIND'] == True:
233 239
 
234
-            onGround = True
235
-
240
+            onGround = True    
236 241
     if onGround: 
237 242
         own['wallride_off'] = 0
238 243
     #print(linVelocity.y / linVelocity.x, 'linvels')
@@ -251,9 +256,11 @@ def main():
251 256
         if balance > sens or balance < - sens:
252 257
             #fall
253 258
             #if ground_since > -1 and ground_since < 10:
254
-            if 'land' in own['l_actionState'] and touched == False:
255
-                own['fall'] = 1
256
-                own['last_fall_frame'] = frame
259
+            #print(own['l_actionState'], touched)
260
+            if own['l_actionState'] != None:
261
+                if 'land' in own['l_actionState'] and touched == False:
262
+                    own['fall'] = 1
263
+                    own['last_fall_frame'] = frame
257 264
             #pass
258 265
         if balance > sens3:
259 266
             #print('land2!!!!!!')
@@ -599,16 +606,40 @@ def main():
599 606
             own['requestAction'] = 'reg_roll'
600 607
 
601 608
     def reg_manual_on():
602
-        own['requestAction'] = 'reg_manual'
609
+        if lLR > turnsens:
610
+            own['requestAction'] = 'reg_manual_right'
611
+        elif lLR < -turnsens:
612
+            own['requestAction'] = 'reg_manual_left'
613
+        else:
614
+            own['requestAction'] = 'reg_manual'        
603 615
 
604 616
     def fak_manual_on():
605
-        own['requestAction'] = 'fak_manual'
617
+        if lLR > turnsens:
618
+            own['requestAction'] = 'fak_manual_right'
619
+        elif lLR < -turnsens:
620
+            own['requestAction'] = 'fak_manual_left'
621
+        else:
622
+            own['requestAction'] = 'fak_manual'  
606 623
 
607 624
     def reg_nmanual_on():
608
-        own['requestAction'] = 'reg_nmanual'
625
+
626
+        if lLR > turnsens:
627
+            own['requestAction'] = 'reg_nmanual_right'
628
+        elif lLR < -turnsens:
629
+            own['requestAction'] = 'reg_nmanual_left'
630
+        else:
631
+            own['requestAction'] = 'reg_nmanual'  
632
+
609 633
 
610 634
     def fak_nmanual_on():
611
-        own['requestAction'] = 'fak_nmanual'
635
+
636
+    #def fak_manual_on():
637
+        if lLR > turnsens:
638
+            own['requestAction'] = 'fak_nmanual_right'
639
+        elif lLR < -turnsens:
640
+            own['requestAction'] = 'fak_nmanual_left'
641
+        else:
642
+            own['requestAction'] = 'fak_nmanual'          
612 643
 
613 644
     if own['l_actionState'] == 'reg_manual_revert_ccw':
614 645
         own['manual_v2_type'] = 'fak nose manual'
@@ -833,8 +864,13 @@ def main():
833 864
                     own['no_grind'] = True
834 865
                     own['no_grind_pull'] = 1
835 866
 
836
-                own.applyForce(force, local)
837 867
                 force2 = [0.0, 0, 150]
868
+                #no jump if on ramp
869
+                if rot.z < .93:
870
+                    force2 = [0,0,0]
871
+
872
+                own.applyForce(force, local)
873
+                
838 874
                 own.applyForce(force2, True)
839 875
                 #print("apply jump force1")
840 876
             if grindHit == True:
@@ -962,12 +998,27 @@ def main():
962 998
 
963 999
     def oposin():
964 1000
         if ground_since > 30:
965
-            if (onGround) and STANCE == False and own['manual'] == 0:
1001
+            if (onGround) and STANCE == False and (own['manual'] == 0 or own['requestAction'] == 'fak_roll'):
966 1002
                 if grindold == 0:
967
-                    own['requestAction'] = 'reg_opos'
968
-            elif (onGround) and STANCE == True and own['manual'] == 0:
1003
+                    #print('opos request', own['requestAction'])
1004
+                    
1005
+                    if own['requestAction'] == 'reg_turnRight':
1006
+                        own['requestAction'] = 'reg_pump_right'
1007
+                    elif own['requestAction'] == 'reg_turnLeft':
1008
+                        own['requestAction'] = 'reg_pump_left'                        
1009
+                    else:
1010
+                        own['requestAction'] = 'reg_opos'
1011
+
1012
+            elif (onGround) and STANCE == True and (own['manual'] == 0 or own['requestAction'] == 'fak_roll'):
969 1013
                 if grindold == 0:
970
-                    own['requestAction'] = 'fak_opos'
1014
+                    #print('opos request', own['requestAction'])
1015
+                    if own['requestAction'] == 'fak_turnRight':
1016
+                        own['requestAction'] = 'fak_pump_right'
1017
+                    elif own['requestAction'] == 'fak_turnLeft':
1018
+                        own['requestAction'] = 'fak_pump_left'                        
1019
+                    else:                    
1020
+                        own['requestAction'] = 'fak_opos'
1021
+            #print('result', own['requestAction'])            
971 1022
             own["last_Opos"] = True
972 1023
 
973 1024
     def noposin():
@@ -1727,9 +1778,9 @@ def main():
1727 1778
                 elif distance >= 1.75:
1728 1779
                     own.alignAxisToVect([0.0, 0.0, 1.0], 2, .03)
1729 1780
         elif onGround:
1730
-            if d2 > .4:
1731
-                own.alignAxisToVect([0.0, 0.0, 1.0], 2, .03)
1732
-            #pass
1781
+            #if d2 > .4:
1782
+               #own.alignAxisToVect([0.0, 0.0, 1.0], 2, .03)
1783
+            pass
1733 1784
     def stopAnims():
1734 1785
         pass
1735 1786
 
@@ -2166,7 +2217,7 @@ def main():
2166 2217
             own['grindstartFrame'] = own['framenum']
2167 2218
             giniter = 1
2168 2219
         if grindHit == True and own['invert_on'] == 0 and own['footplant_on'] == False and own['manual'] == 0 and lif > 40 and own['dropinTimer'] < 30 and giniter == 0:
2169
-
2220
+            own['grinding'] = True
2170 2221
             control_bottom = scene.objects['control_bottom']
2171 2222
             grindTouch = control_bottom.sensors['grindCol_bottom']
2172 2223
             edge = 0
@@ -2185,6 +2236,7 @@ def main():
2185 2236
                 tempstance = jumpstance
2186 2237
             else:
2187 2238
                 tempstance = STANCE
2239
+            #print(own['grindpos'], own['grindType'], 'pos n type111')
2188 2240
             grindpos = own['grindpos']
2189 2241
             if grindpos == "reg_5050" and own['grindType'] == "empty":
2190 2242
                 own['grindType'] = grindpos
@@ -2194,6 +2246,18 @@ def main():
2194 2246
                 else:
2195 2247
                     own['grindType'] = "fak_bsboard"
2196 2248
 
2249
+
2250
+            # if own['grindType'] == '' and grindpos == 'reg_board':
2251
+            #     if STANCE == 0:
2252
+            #         own['grindType'] = "reg_bsboard"
2253
+            #     else:
2254
+            #         own['grindType'] = "fak_bsboard"
2255
+
2256
+            # if own['grindType'] == '' and grindpos == 'reg_board':
2257
+            #     own['grindType'] = 'reg_bsboard'
2258
+
2259
+            #print(own['grindpos'], own['grindType'], 'pos n type')
2260
+
2197 2261
             if STANCE == True:
2198 2262
                 if own['grindType'] == "reg_bsboard":
2199 2263
                     own['grind_stance'] = 0
@@ -2350,7 +2414,7 @@ def main():
2350 2414
                         own['requestAction'] = 'fak_5050'
2351 2415
                         #print('5050 d')
2352 2416
 
2353
-
2417
+            #print(own['requestAction'], 'end ra', own['grindType'])
2354 2418
             if 'fak' in own['l_actionState']:
2355 2419
                 STANCE = 1
2356 2420
                 own['lg_stance'] = 1
@@ -2361,6 +2425,12 @@ def main():
2361 2425
                 lg_stance = 0
2362 2426
             own['stance'] = STANCE
2363 2427
 
2428
+            if own['requestAction'] == 'reg_5050' and own['grindpos'] == 'reg_board':
2429
+                own['requestAction'] = 'reg_bsboard'
2430
+            if own['requestAction'] == 'fak_5050' and own['grindpos'] == 'reg_board':
2431
+                own['requestAction'] = 'fak_bsboard'        
2432
+
2433
+
2364 2434
     def rotmult():
2365 2435
         if onGround:
2366 2436
             num = ((rot.z * -1) +1)
@@ -4277,7 +4347,7 @@ def main():
4277 4347
             ownpos = own.worldPosition
4278 4348
             distance = ownpos.z - objpos.z
4279 4349
         except:
4280
-            print('gray broke')
4350
+            #print('gray broke')
4281 4351
             pass
4282 4352
         if wallrideL.triggered and wallride_off == 0 and not onGround:
4283 4353
             own['jump_timer'] = 0
@@ -4428,6 +4498,28 @@ def main():
4428 4498
         if rBump == True:
4429 4499
             own.alignAxisToVect([0.0, 0.0, 1.0], 2, .06)
4430 4500
 
4501
+    def ragdoll_out():
4502
+        rdmax = 120
4503
+        if own['ragdoll_out'] > 0:
4504
+            print('deactivating ragdoll')
4505
+            stre = 1 - (own['ragdoll_out'] / rdmax)
4506
+            own['ragdoll_out'] += 1
4507
+            if own['ragdoll_out'] == rdmax:
4508
+                stre = 0
4509
+            if own['ragdoll_out'] > rdmax:
4510
+                own['ragdoll_out'] = 0
4511
+                stre = 0
4512
+                
4513
+
4514
+            armature = scene.objects['Char4']
4515
+            for const in armature.constraints:
4516
+                #print(const, 'const')
4517
+                if ('rd_cl' in str(const) or 'rd_cr' in str(const)):
4518
+                    #print(const, 'const', strength)
4519
+                    const.enforce = stre  
4520
+
4521
+
4522
+
4431 4523
     jump_Timer()
4432 4524
     check_landing()
4433 4525
     nextframe()
@@ -4449,6 +4541,7 @@ def main():
4449 4541
     dropinRotate()
4450 4542
     onboard()
4451 4543
     grind_but_align()
4544
+    #ragdoll_out()
4452 4545
     linvelx = own.getLinearVelocity(True)
4453 4546
     own["linvelx"] = linvelx.x
4454 4547
     LAST_STANCE = STANCE
@@ -4543,13 +4636,14 @@ def main():
4543 4636
             own.applyMovement((0, 0, (.295 - (localHitDist))), True)
4544 4637
             #own.applyMovement((0, 0, (.32 - (localHitDist))), True)
4545 4638
             #own.applyMovement((0, 0, (.5 - localHitDist)), True)
4546
-            #print('moving new ray a')
4639
+            print('moving new ray a')
4547 4640
             #if localRay[2] != [0, 0, -1] and grindHit == 0:
4548 4641
             if localRay[2] != [0, 0, -1]:    
4549 4642
                 #own.alignAxisToVect(localRay[2], 2, .25)
4550 4643
                 own.alignAxisToVect(localRay[2], 2, .5)
4551 4644
                 aligned = True
4552 4645
             #print('localRay')
4646
+           
4553 4647
         if localHitDist > .31 and localHitDist < 2:
4554 4648
             own.alignAxisToVect(localRay[2], 2, .05)
4555 4649
             #print('new align')
@@ -4613,11 +4707,13 @@ def main():
4613 4707
                 #if localHitDist < .8:    
4614 4708
                 if localHitDist < 1.5:        
4615 4709
                     #own.applyMovement((0,0,((.4 - (localHitDist) * .1))), True)
4616
-                    own.applyMovement((0, 0, (.3 - localHitDist)), True)
4710
+                    #own.applyMovement((0, 0, (.3 - localHitDist)), True)
4711
+                    own.applyMovement((0, 0, (.4 - localHitDist)), True)
4617 4712
                     #print('moving vert ray')
4618 4713
                     if localRay_v[2] != [0, 0, -1] and grindHit == 0:
4619 4714
                     #if localRay_v[2] != [0,0,-1]:
4620 4715
                         own.alignAxisToVect(localRay_v[2], 2, .4)
4716
+                        #own.alignAxisToVect(localRay_v[2], 2, .05)
4621 4717
                         aligned = True
4622 4718
         #print(own['lGobj'], 'lGobj')                         
4623 4719
 
@@ -4709,4 +4805,22 @@ def main():
4709 4805
         else:
4710 4806
             own['lland'] = own['requestAction']    
4711 4807
     # if own['requestAction'] in ['fak_land', 'reg_land', 'fak_landL', 'fak_landLb', 'reg_landR', 'reg_landRb', 'fak_landR' 'fak_landRb', 'reg_landL', 'reg_landLb']:
4712
-        
4808
+    #print(own['requestAction'], 'controller end request')
4809
+
4810
+
4811
+
4812
+    own['ground_since'] = ground_since
4813
+    if own['rotz'] < .97:
4814
+        if own['requestAction'] == 'reg_roll':
4815
+            own['requestAction'] = 'reg_opos'
4816
+        if own['requestAction'] == 'reg_turnLeft':
4817
+            own['requestAction'] = 'reg_pump_left'
4818
+        if own['requestAction'] == 'reg_turnRight':
4819
+            own['requestAction'] = 'reg_pump_right'
4820
+
4821
+        if own['requestAction'] == 'fak_roll':
4822
+            own['requestAction'] = 'fak_opos'
4823
+        if own['requestAction'] == 'fak_turnLeft':
4824
+            own['requestAction'] = 'fak_pump_left'
4825
+        if own['requestAction'] == 'fak_turnRight':
4826
+            own['requestAction'] = 'fak_pump_right'

+ 169
- 19
scripts/grindV2.py View File

@@ -2,6 +2,8 @@
2 2
 
3 3
 import bge
4 4
 import math
5
+import mathutils
6
+from mathutils import Vector
5 7
 
6 8
 def main():
7 9
 
@@ -71,6 +73,143 @@ def main():
71 73
     grindvect = None
72 74
     grindyvect = None
73 75
     skipcol = 0
76
+
77
+
78
+
79
+
80
+
81
+    def get_vert_rot(own, object):
82
+
83
+        if 'inited' not in object:
84
+            object['inited'] = True
85
+
86
+            for mesh in object.meshes:
87
+                red_verts = []
88
+                green_verts = []
89
+                for m_index in range(len(mesh.materials)):
90
+                    for v_index in range(mesh.getVertexArrayLength(m_index)):
91
+                        vertex = mesh.getVertex(m_index, v_index)
92
+                        if vertex.color[0] > .8:
93
+                            loc = object.worldTransform * vertex.XYZ
94
+                            red_verts.append(loc.freeze())
95
+                        if vertex.color[1] > .8:
96
+                            loc = object.worldTransform * vertex.XYZ
97
+                            green_verts.append(loc.freeze())
98
+                           
99
+            red_verts = set(red_verts)
100
+            #for v in red_verts:
101
+                #print(v, 'red_vert')
102
+            green_verts = set(green_verts)               
103
+            object['red_verts'] = red_verts
104
+            object['green_verts'] = green_verts
105
+            
106
+            size_red = len(object['red_verts'])
107
+            kd_red = mathutils.kdtree.KDTree(size_red)
108
+            size_green = len(object['green_verts'])
109
+            kd_green = mathutils.kdtree.KDTree(size_green)    
110
+
111
+            for i, v in enumerate(object['red_verts']):
112
+                kd_red.insert(v, i)
113
+            for i, v in enumerate(object['green_verts']):
114
+                kd_green.insert(v, i)
115
+
116
+            kd_red.balance()
117
+            kd_green.balance() 
118
+            object['kd_red'] = kd_red
119
+            object['kd_green'] = kd_green    
120
+            #print('kd built -------')
121
+            #print(own['kd_red'])
122
+        # Find the closest points to the player
123
+        co_find = control_bottom.worldPosition
124
+        found_red = object['kd_red'].find_n(co_find, 2)
125
+        found_green = object['kd_green'].find_n(co_find, 1)    
126
+        
127
+        primary = Vector(found_red[0][0])
128
+        secondary = Vector(found_red[1][0])
129
+
130
+        lineVector = secondary - primary
131
+        lineVector2 = primary - secondary
132
+        lv_green = Vector(found_green[0][0])
133
+            
134
+        eul = Vector((1, 0, 0)).rotation_difference(lineVector).to_euler()        
135
+        
136
+        te = scene.objects['temp_empty']
137
+        
138
+
139
+        rotation = te.worldOrientation.to_euler()
140
+        if abs(rotation.z) > 3:
141
+            te.applyRotation([0, 0, 1.570796*2], True)
142
+        #te.alignAxisToVect(worldY, 1, 1)
143
+        #print(te.worldOrientation, 'world orientation')
144
+
145
+
146
+        xyz = te.localOrientation.to_euler()
147
+        xyz[0] = math.radians(0)
148
+        te.localOrientation = xyz.to_matrix()
149
+
150
+
151
+
152
+
153
+        if lineVector == Vector([0.0, 0.0, 0.0]):
154
+            #print('vector is empty')
155
+            pass
156
+        else:
157
+            te.alignAxisToVect(lineVector, 0, 1)
158
+        
159
+        te.worldPosition = primary
160
+        
161
+        local = te.worldOrientation.inverted() * (lv_green - te.worldPosition)
162
+        if local.y < 0:
163
+            #print('flip vector')
164
+            eul = Vector((1, 0, 0)).rotation_difference(lineVector2).to_euler() 
165
+            if lineVector2 == Vector([0.0, 0.0, 0.0]):
166
+                #print('linVector2 is empty')
167
+                pass
168
+            else:
169
+                te.alignAxisToVect(lineVector2, 0, 1)
170
+            #print('align2', lineVector2)
171
+            te.worldPosition = secondary
172
+        else:
173
+            #print('align1', lineVector)  
174
+            pass
175
+
176
+
177
+        #flip z axis
178
+
179
+        #print(local, 'local')
180
+        
181
+        myhead = te.worldOrientation.col[2]
182
+        worldUp = Vector([0,0,1])
183
+        #worldY = Vector([0,1,0])
184
+        dot_p = myhead.dot(worldUp)
185
+
186
+        if dot_p > 0.9:
187
+            pass
188
+        else:
189
+            #print('flip grind object rotation')
190
+            te.applyRotation([1.570796*2, 0, 0], True)
191
+
192
+
193
+
194
+
195
+        return eul 
196
+
197
+
198
+
199
+
200
+
201
+
202
+
203
+
204
+
205
+
206
+
207
+
208
+
209
+    #print(detectedObjects)
210
+    if grindDar.positive:
211
+        get_vert_rot(own, grindDar.hitObjectList[0])
212
+
74 213
     try:
75 214
         no_grind_pull = own['no_grind_pull']
76 215
     except:
@@ -116,7 +255,7 @@ def main():
116 255
 #grindvect func
117 256
     grindvect = None
118 257
     grindyvect = None
119
-    lastobj = own["grindTouchobj"]
258
+    #lastobj = own["grindTouchobj"]
120 259
     grindpos = own["grindpos"]
121 260
     player_e = own.worldOrientation.to_euler()
122 261
     player_rotz = math.degrees(player_e[2])
@@ -248,7 +387,7 @@ def main():
248 387
         #z align
249 388
 
250 389
         stre = .15#.075#.15
251
-        player.alignAxisToVect(grinder_vectz, 2, stre)
390
+        #player.alignAxisToVect(grinder_vectz, 2, stre)
252 391
 
253 392
         if rot >= 0 and rot < 45:
254 393
             player.alignAxisToVect(grinder_vect, 0, align_strength)
@@ -393,10 +532,10 @@ def main():
393 532
             grindyvect = 0
394 533
         grindvect = own['grindvect']
395 534
 
396
-        if 'rail' in obj:
397
-            own["grindSound"] = "rail"
398
-        else:
399
-            own["grindSound"] = "concrete"
535
+        # if 'rail' in obj:
536
+        #     own["grindSound"] = "rail"
537
+        # else:
538
+        #     own["grindSound"] = "concrete"
400 539
         own['lGobj'] = obj
401 540
 
402 541
         grinding = 1
@@ -430,7 +569,7 @@ def main():
430 569
                 if 'edge' in obj:
431 570
                     edge = 1
432 571
                 #print('grind on', grindside, edge)
433
-                if (delta[2] > .00001 or delta[2] < -.00001) and (delta[2] < .8 or delta[2] < -.8):
572
+                if (delta[2] > .00001 or delta[2] < -.00001) and (delta[2] < 1.8 or delta[2] < -1.8):
434 573
                     rotation = own.worldOrientation[2] - obj.worldOrientation[2]
435 574
                     player_e = own.worldOrientation.to_euler()
436 575
                     player_rotz = math.degrees(player_e[2])
@@ -483,6 +622,11 @@ def main():
483 622
                 newvelx = velo.x * grindspeed_cement
484 623
                 newvely = velo.y * grindspeed_cement
485 624
             player.setLinearVelocity([newvelx, newvely, velo.z], 1)
625
+            
626
+
627
+
628
+
629
+
486 630
             player_rot = own.worldOrientation[2]
487 631
             grinder_rot = touchobj.worldOrientation[2]
488 632
             player_rot = own.getAxisVect([0.0, 0.0, 1.0])
@@ -508,9 +652,9 @@ def main():
508 652
             own.linearVelocity.x = 0
509 653
             own.linearVelocity.y = 0
510 654
 
511
-    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:
655
+    #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:
512 656
         #print("touching, no dar")
513
-        pass
657
+        #pass
514 658
     #print(grindold, "grindold")
515 659
     skipper = 0
516 660
     if (grindDar.positive or grindTouch.positive) and no_grind == 0:
@@ -518,14 +662,17 @@ def main():
518 662
             detectedObjects = grindDar.hitObjectList
519 663
             dist = 0.0
520 664
             for obj in detectedObjects:
521
-                dist = own.getDistanceTo(obj)
665
+                #dist = own.getDistanceTo(obj)
522 666
                 if (minDist is None or dist < minDist):
523
-                    nearestObject = obj
667
+                    #nearestObject = obj
524 668
                     minDist = dist
525
-        elif grindTouch.positive:
526
-            nearestObject = grindTouch.hitObject
527
-            dist = .7
669
+        #elif grindTouch.positive:
670
+            #nearestObject = grindTouch.hitObject
671
+            #dist = .7
528 672
             #print('using touch object')
673
+        
674
+        nearestObject = scene.objects['temp_empty']
675
+        dist = own.getDistanceTo(nearestObject)    
529 676
 
530 677
 #@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
531 678
         #init grind
@@ -563,12 +710,15 @@ def main():
563 710
                     own['grindnew_timer'] += 1
564 711
                     if own['grindnew_timer'] < 1:
565 712
                         if grindTouch.triggered:
566
-                            nearpos = nearestObject.worldPosition
713
+                            nearpos = nearestObject.worldPosition.copy
714
+                            nearpos.z += .2975
567 715
                             if hitNormal != None:
568 716
                                 stre = .15
569
-                                own.alignAxisToVect(hitNormal, 2, stre)
570
-
571
-
717
+                                #own.alignAxisToVect(hitNormal, 2, stre)
718
+                            #own.worldPosition = [nearpos.x, nearpos.y, nearpos.z + .2975]
719
+                            own.worldPosition.lerp(own.worldPosition, nearpos, .1)
720
+                            print('new moving world')
721
+                    
572 722
     else:
573 723
         own['grindold_timer'] += 1
574 724
         own["grindHit"] = False
@@ -682,7 +832,7 @@ def main():
682 832
     timer()
683 833
     aligntimer()
684 834
     stop_bounce()
685
-    #slow_roty()
835
+    slow_roty()
686 836
 
687 837
 
688 838
     own['grindOld'] = grindold

+ 53
- 19
scripts/ragdoll.py View File

@@ -15,12 +15,20 @@ def zero_constraints(own, scene):
15 15
         
16 16
         if 'rd_cl' in str(const):
17 17
             const.enforce = 0
18
-            print(const)
18
+            #print(const)
19 19
         if 'rd_cr' in str(const):
20 20
             const.enforce = 0   
21 21
     for x in own['rd_rb'].groupMembers:
22 22
         x.suspendDynamics(True)
23 23
 
24
+def set_influence(own, scene, strength):
25
+    armature = scene.objects['Char4']
26
+    for const in armature.constraints:
27
+        #print(const, 'const')
28
+        if ('rd_cl' in str(const) or 'rd_cr' in str(const)):
29
+            #print(const, 'const', strength)
30
+            const.enforce = strength  
31
+
24 32
     
25 33
 def update_rb(physBody, scene):
26 34
     #print('updating rigid body positions')
@@ -90,8 +98,10 @@ def main():
90 98
         own['rd_set_vel'] = False
91 99
         own['rd_vel'] = None
92 100
         own['rd_incer'] = 0
93
-        zero_constraints(own, scene)    
101
+        own['rd_life'] = 0
102
+        zero_constraints(own, scene) 
94 103
 
104
+    #print(own['rd_life'], 'ragdoll incer')
95 105
     #if (sens.positive) or (dict['aBut'] == 1 and dict['bBut'] == 1) or own['fall'] == True:
96 106
     if (sens.positive) or own['fall'] == True:
97 107
         #print('option1')
@@ -100,6 +110,7 @@ def main():
100 110
             #own['fall'] = 1
101 111
             own['fall'] = True
102 112
             print('do ragdoll')
113
+            own['rd_life'] = 0
103 114
             incer = -1
104 115
             update_rb(own['rd_rb'], scene)   
105 116
             while incer < 20:
@@ -122,7 +133,7 @@ def main():
122 133
             cont.actuators['Camera'].height = 2.0
123 134
             #cont.actuators['Camera'].min = 14.0
124 135
             #cont.actuators['Camera'].max = 18.0
125
-            cont.actuators['Camera'].damping = .000001
136
+            cont.actuators['Camera'].damping = 0.001
126 137
             cont.activate(cont.actuators['Camera']) 
127 138
                         
128 139
             #own.suspendDynamics()
@@ -131,17 +142,20 @@ def main():
131 142
 
132 143
         if own['ragdoll_active'] == True:
133 144
             #pass
134
-            scene.objects[armature].stopAction(2)
135
-            scene.objects[armature].stopAction(7)
136
-            scene.objects[armature].update()
137
-            cont.actuators['Camera'].object = scene.objects['ragdoll_parent']
145
+            own['rd_life'] += 1
146
+            #scene.objects[armature].stopAction(2)
147
+            #scene.objects[armature].stopAction(7)
148
+            #scene.objects[armature].update()
149
+            #cont.actuators['Camera'].object = scene.objects['ragdoll_parent']
150
+            own.worldPosition = scene.objects['ragdoll_parent'].worldPosition
151
+            #cont.actuators['Camera'].object = own
138 152
             wp = scene.objects['camCube'].worldPosition - scene.objects['ragdoll_parent'].worldPosition
139 153
             wp = wp * .9
140
-            cont.actuators['Camera'].height = 2.0
154
+            cont.actuators['Camera'].height = 1.7
141 155
             cont.actuators['Camera'].min = 4.0
142
-            cont.actuators['Camera'].max = 8.0
156
+            cont.actuators['Camera'].max = 7.0
143 157
             #cont.actuators['Camera'].damping = .000001
144
-            cont.actuators['Camera'].damping = .99
158
+            cont.actuators['Camera'].damping = .006#.99
145 159
             cont.activate(cont.actuators['Camera']) 
146 160
             #print(own['rd_set_vel'], 'vel setter')
147 161
             if own['rd_set_vel'] == True:
@@ -157,7 +171,7 @@ def main():
157 171
                     #scene.objects['npc_ed_arm_phys_master'].worldLinearVelocity.x = 100
158 172
                     #scene.objects['npc_ed_arm_phys_master'].applyForce([5000,0,0], False)
159 173
                     for pB in own['rd_rb'].groupMembers:
160
-                        print('setting', pB, own['rd_vel'])
174
+                        #print('setting', pB, own['rd_vel'])
161 175
                         
162 176
                         try:
163 177
                             #pass
@@ -165,14 +179,15 @@ def main():
165 179
                             #pB.worldLinearVelocity.x = 100
166 180
                             #pB.worldLinearVelocity = own['rd_vel']
167 181
                             pB.setLinearVelocity(own['rd_vel'], False)
168
-                            print('adding force to', pB, pB.worldLinearVelocity)
182
+                            #print('adding force to', pB, pB.worldLinearVelocity)
169 183
                         except:
170
-                            print('cant add force to ', pB)
184
+                            #print('cant add force to ', pB)
185
+                            pass
171 186
                 else:
172 187
                     own['rd_incer'] = 0
173 188
                     own['rd_set_vel'] = False
174 189
             
175
-            if dict['yBut'] == 1:                
190
+            if dict['last_yBut'] == 1 and dict['yBut'] == 0:                
176 191
                 print('turn off ragdoll')
177 192
                 zero_constraints(own, scene)
178 193
                 scene.objects[armature].setParent(own, False, True)
@@ -180,20 +195,24 @@ def main():
180 195
                 for x in own['rd_rb'].groupMembers:
181 196
                     x.suspendDynamics(True)
182 197
                 own['ragdoll_active'] = False    
183
-                print(scene.objects[armature].parent, 'parent')
198
+                own['rd_life'] = 0
199
+                #print(scene.objects[armature].parent, 'parent')
184 200
                 cont.actuators['Camera'].object = scene.objects['camCube']
185 201
                 cont.activate(cont.actuators['Camera']) 
186 202
                 own.worldPosition = scene.objects['npc_ed_arm_phys_master'].worldPosition
187 203
                 own.worldPosition.z += .4
204
+                own['requestAction'] = 'reg_onboard'
205
+                own['ragdoll_out'] = 1
188 206
                 cont.activate(cont.actuators['walk']) 
207
+                
189 208
 
190 209
 
191
-            if dict['lUD'] < -.08:
210
+            if dict['lUD'] < -.08 and own['rd_life'] > 360:
192 211
                 physBody = own['rd_rb']
193 212
                 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']
194 213
                 #excludes = []
195 214
                 for x in physBody.groupMembers:
196
-                    print(x.name)
215
+                    #print(x.name)
197 216
                                     
198 217
                     if x.name not in excludes:
199 218
                         pass
@@ -213,8 +232,23 @@ def main():
213 232
                 scene.objects['npc_ed_arm_phys_clavicle.L'].applyForce([0,0,200], False)
214 233
                 scene.objects['npc_ed_arm_phys_clavicle.R'].applyForce([0,0,200], False)
215 234
 
216
-            if dict['rUD'] > .08:
235
+            if dict['rUD'] > .08 and own['rd_life'] > 360:
217 236
                 scene.objects['npc_ed_arm_phys_master'].applyForce([0,600,0], True)
237
+
238
+            blendamt = 20
239
+            if own['rd_life'] < blendamt:
240
+                dif = own['rd_life'] / blendamt
241
+            else:
242
+                dif = 1
243
+            set_influence(own, scene, dif)
244
+             
245
+            # scene.objects[armature].stopAction(1)
246
+            # scene.objects[armature].stopAction(2)
247
+            # scene.objects[armature].stopAction(3)
248
+            # scene.objects[armature].stopAction(4)
249
+            # scene.objects[armature].update()
250
+ 
218 251
         else:
219 252
             update_rb(own['rd_rb'], scene)   
220
-            #pass
253
+            #pass
254
+        scene.objects[armature].update()    

+ 13
- 0
scripts/scene_init.py View File

@@ -9,6 +9,12 @@ def main():
9 9
     own = cont.owner
10 10
     #own = scene.objects['control_cube.002']
11 11
     dict = bge.logic.globalDict
12
+
13
+
14
+
15
+
16
+
17
+
12 18
     if dict['scene_inited'] == False:
13 19
 
14 20
         own['last_stBut'] = False
@@ -30,6 +36,7 @@ def main():
30 36
         compound = True
31 37
         obj = scene.objects['Char4']
32 38
         deck_obj = scene.objects['deck_arm']
39
+        dict['p1c'] = own
33 40
         dict['p1'] = obj
34 41
         dict['p1d'] = deck_obj
35 42
         # child is solid
@@ -149,7 +156,10 @@ def main():
149 156
         own['last_vert_frame'] = 0
150 157
         own['ragdoll_active'] = False
151 158
         own['rd_to_delete'] = None
159
+        own['ragdoll_out'] = 0
152 160
         own['lland'] = ''
161
+        own['grinding'] = False
162
+        own['ground_since'] = 100
153 163
         
154 164
         colors.update_shirt_tex() 
155 165
         colors.update_truck_tex()
@@ -157,4 +167,7 @@ def main():
157 167
         print('scene init ran')
158 168
         dict['scene_inited'] = True
159 169
       
170
+             
171
+
172
+    
160 173
 #main()

+ 1
- 0
scripts/stance.py View File

@@ -12,6 +12,7 @@ def main(cont):
12 12
     try:
13 13
         #stance detection   
14 14
         if own['ground'] == True and (own['grindpos'] != 'reg_board' or own['grindOld'] == False) and own['invert_on'] == False:
15
+        #if own['ground'] == True and (own['grindOld'] == False) and own['invert_on'] == False:            
15 16
             #print("detect stance") 
16 17
             LVX = own.localLinearVelocity.x
17 18
             if LVX > STANCE_SENS:

+ 3
- 2
scripts/walk.py View File

@@ -438,7 +438,8 @@ def main(cont):
438 438
             if grindDar.hitObjectList != None:
439 439
                 for x in grindDar.hitObjectList:
440 440
                     to_grinder = (x.worldPosition - own.worldPosition).length
441
-                    if 'coping' in x and to_grinder < .36:
441
+                    #if 'coping' in x and to_grinder < .36:
442
+                    if 'coping' in x:    
442 443
                         dar = 1
443 444
             if dropinCol.positive == True or dar == 1: 
444 445
                 nearestObject = None
@@ -483,7 +484,7 @@ def main(cont):
483 484
                 #         own.applyMovement(move, True)                    
484 485
                 #     except:
485 486
                 #         pass 
486
-
487
+                print('dropin')
487 488
                 if STANCE == 0: 
488 489
                     own['requestAction'] ='reg_dropin_pos' 
489 490
                     own['dropinTimer'] = 60                                     

Loading…
Cancel
Save