hangs

assets/ramps.blend

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:dac8bd740361ce271c1b6590f2a9127bd17b0e1e6320a8c457160678af7fffac
-size 44741748
+oid sha256:5395502faddbee5158b7c9ffd14807408fbb2a6b14b148db93ef53ea011a4a9b
+size 48154268

assets/user2.blend

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:71ee4f8556b82e3b8e0c7b7424152a63b31f0a1b43bf75bf64fe1e16684aea35
-size 579232
+oid sha256:ab1b42cf5d4aee552dc3f4f15e5e04b0c16882a41ce75c79726a9dceb04b1463
+size 662960

config.ini

@@ -153,10 +153,10 @@ gravity = -10.5
 fall_height = 0.5
 
 walk_force = 15
-run_force = 35
+run_force = 40
 max_walk_vel = 1.5
 max_run_vel = 5
-walk_turn_amt = .03
+walk_turn_amt = 0.03
 walk_jump_force = 1300
 
 #controller mappings

scripts/FSM.py

@@ -103,7 +103,8 @@ class PlayerFSM(Char):
         'WalkHang',
         'WalkClimb',
         'WalkHurdle',
-        'Roll']
+        'Roll',
+        'Ragdoll']
         
         for s in state_list:
             self.FSM.AddState(s, getattr(StatesPlayer, s)(self.FSM))

scripts/StatesPlayer.py

@@ -70,7 +70,7 @@ class Walk(State):
         if c.arm == None:
             
             c.arm = o.childrenRecursive['Char4']
-
+            c.deck_arm = o.childrenRecursive['deck_arm']
         self.walk_weight = 1
         self.run_weight = 1
         self.run_speed = 0.0
@@ -100,10 +100,21 @@ class Walk(State):
         #         print('request reg offboard') 
         # if self.FSM.stateLife > 5:
         #     o['requestAction'] = 'reg_idle'                 
+        c.align_walk_z()
         ground_rays = c.get_ground_ray()
+        #77777777777777777777777777777777777777777777777777777777777777777777777777777777777
+        c.get_hang_align_ray()
+        c.move_walk_cam()
+        c.check_reset_point()       
+        c.check_throw()
+
         if ground_rays[0][0] != None:
             dist = c.get_ground_dist(ground_rays)
-            c.set_walk_z(dist)
+            if dist > .7:
+                self.FSM.ToTransition('toWalkAir')
+                print('---falling')
+            else:
+                c.set_walk_z(dist)
             #print(dist, 'setting height')
 
         if self.FSM.stateLife > 4:
@@ -121,14 +132,14 @@ class Walk(State):
     def check_onboard(self):
 
         o = self.FSM.owner.obj
-        print(o['getonboard'], 'getonboard')
+        #print(o['getonboard'], 'getonboard')
 
 
 
         if dict['walk'] == 0:
             o['getonboard'] = True
             self.FSM.ToTransition('toRoll')
-            print('onboard', dict['walk'], o['getonboard'])
+            #print('onboard', dict['walk'], o['getonboard'])
 
 
 
@@ -145,14 +156,20 @@ class Walk(State):
 
     def idle_blend(self):
         arm = self.FSM.owner.arm
+        deck = self.FSM.owner.deck_arm
         arm.playAction('reg_idle1', 1,120, layer=1, play_mode=1, speed=1, blendin=10)
+        deck.playAction('b_reg_idle1', 1,120, layer=1, play_mode=1, speed=1, blendin=10)
         if self.FSM.stateLife > 20:
             frame = arm.getActionFrame(2) + .5 * self.run_speed
             if frame > 30:
                 frame = 0
             arm.stopAction(2)
+            deck.stopAction(2)
             arm.playAction('reg_nwalk3', 0,30, layer=2, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=self.walk_weight)
+            deck.playAction('b_reg_walk', 0,30, layer=2, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=self.walk_weight)
+            #b_reg_walk
             arm.setActionFrame(frame, 2)
+            deck.setActionFrame(frame, 2)
             #print(self.walk_weight, frame)
 
             
@@ -161,8 +178,12 @@ class Walk(State):
             if frame > 30:
                 frame = 0
             arm.stopAction(3)
+            deck.stopAction(3)
             arm.playAction('reg_run.003', 0,30, layer=3, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=self.run_weight)
+            deck.playAction('b_reg_run', 0,30, layer=3, play_mode=1, speed=self.run_speed, blendin=0, layer_weight=self.run_weight)
+            
             arm.setActionFrame(frame, 3)
+            deck.setActionFrame(frame, 3)
             #print(frame, 'frame')
             #print(self.run_weight, frame)
             
@@ -229,6 +250,10 @@ class Walk(State):
         self.FSM.owner.arm.stopAction(1)
         self.FSM.owner.arm.stopAction(2)
         self.FSM.owner.arm.stopAction(3)
+        self.FSM.owner.deck_arm.stopAction(0)
+        self.FSM.owner.deck_arm.stopAction(1)
+        self.FSM.owner.deck_arm.stopAction(2)
+        self.FSM.owner.deck_arm.stopAction(3)
         dict['walk'] = 0
 
 
@@ -240,35 +265,50 @@ class WalkAir(State):
         
     def Enter(self):
         self.FSM.stateLife = 1
-        #arm = self.FSM.owner.arm
-        #arm.playAction('a_jump_t', 27, 27, layer=1, play_mode=0, speed=1, blendin=5)
         super(WalkAir, self).Enter()        
         
     def Execute(self):
         self.FSM.stateLife += 1
-        #self.FSM.ToTransition('toLand')
+        self.FSM.owner.check_reset_point()  
         arm = self.FSM.owner.arm
-        arm.playAction('a_jump_t', 23, 23, layer=3, play_mode=1, speed=1, blendin=5)
-        #if self.FSM.stateLife > 50:
-            #self.FSM.ToTransition('toWalk')
-        #limit fall speed
+        deck_arm = self.FSM.owner.deck_arm
+        #arm.playAction('a_jump_t', 23, 23, layer=3, play_mode=1, speed=1, blendin=5)
+        arm.playAction('c_jump_up', 23, 23, layer=3, play_mode=1, speed=1, blendin=15)
+        deck_arm.playAction('b_walk_jump', 23, 23, layer=3, play_mode=1, speed=1, blendin=15)
+
         if self.FSM.owner.obj.linearVelocity.z < -10:
             self.FSM.owner.obj.linearVelocity.z = -10
-        #ground_rays = self.FSM.owner.get_ground_ray()    
+        moving = self.FSM.owner.walk_movement() 
         ground_rays = self.FSM.owner.get_ground_ray() 
-        if ground_rays[0][0] != None:
 
+        self.FSM.owner.check_throw()
+        if ground_rays[0][0] != None:
             dist = self.FSM.owner.get_ground_dist(ground_rays)
             if dist < .4:
-                self.FSM.ToTransition('toWalkLand')  
+                    self.FSM.ToTransition('toWalkLand')  
 
-        moving = self.FSM.owner.walk_movement()              
+
+
+            if dist > .5 and self.FSM.owner.obj.worldPosition.z < self.FSM.owner.last_pos.z: 
+                hang_ray = self.FSM.owner.get_hang_ray()           
+                hang_align_ray = self.FSM.owner.get_hang_align_ray()
+
+                if hang_ray[0] != None and hang_align_ray[0] != None and self.FSM.prevState != 'WalkHang' and dict['lUD'] < .04:
+                    hr_dist = self.FSM.owner.get_hang_dist(hang_ray)
+                    if hr_dist < .1:
+                        self.FSM.owner.obj.linearVelocity = [0,0,0]
+                        self.FSM.owner.obj.worldPosition.z = hang_ray[1].z - 1
+                        self.FSM.ToTransition('toWalkHang')
         
     def Exit(self):
         self.FSM.owner.arm.stopAction(0)
         self.FSM.owner.arm.stopAction(1)
         self.FSM.owner.arm.stopAction(2)
         self.FSM.owner.arm.stopAction(3)
+        self.FSM.owner.deck_arm.stopAction(0)
+        self.FSM.owner.deck_arm.stopAction(1)
+        self.FSM.owner.deck_arm.stopAction(2)
+        self.FSM.owner.deck_arm.stopAction(3)
 
 #==================================== 
             
@@ -280,7 +320,10 @@ class WalkJump(State):
         self.FSM.stateLife = 1
 
         arm = self.FSM.owner.arm
-        arm.playAction('a_jump_t', 1, 23, layer=3, play_mode=0, speed=1, blendin=5)
+        deck = self.FSM.owner.deck_arm
+        #arm.playAction('a_jump_t', 1, 23, layer=3, play_mode=0, speed=1, blendin=5)
+        arm.playAction('c_jump_up', 1, 23, layer=3, play_mode=0, speed=1, blendin=5)
+        deck.playAction('b_walk_jump', 1, 23, layer=3, play_mode=0, speed=1, blendin=5)
             
 
         super(WalkJump, self).Enter()        
@@ -311,7 +354,10 @@ class WalkLand(State):
         
     def Enter(self):
         self.FSM.stateLife = 1
-        self.FSM.owner.arm.playAction('a_jump_t', 23, 50, layer=5, play_mode=0, speed=1, blendin=5)
+        #self.FSM.owner.arm.playAction('a_jump_t', 23, 50, layer=5, play_mode=0, speed=1, blendin=5)
+        self.FSM.owner.arm.playAction('c_land', 0, 50, layer=1, play_mode=0, speed=1, blendin=5)
+        self.FSM.owner.deck_arm.playAction('b_walk_land', 0, 50, layer=1, play_mode=0, speed=1, blendin=5)
+        #c_land
         super(WalkLand, self).Enter()        
         
     def Execute(self):
@@ -325,7 +371,7 @@ class WalkLand(State):
         #     print('stopping land')
         #     arm.stopAction(5)
         #     arm.playAction('reg_idle1', 1,120, layer=1, play_mode=1, speed=1, blendin=2)
-        if self.FSM.stateLife > 8:
+        if self.FSM.stateLife > 30:
             self.FSM.ToTransition('toWalk')
 
         ground_rays = self.FSM.owner.get_ground_ray() 
@@ -344,12 +390,56 @@ class WalkHang(State):
         
     def Enter(self):
         self.FSM.stateLife = 1
+        self.FSM.owner.arm.playAction('c_braced_hang', 0, 36, layer=2, play_mode=0, speed=1, blendin=10)
+        self.moveable = False
+        #self.FSM.owner.arm.playAction('c_braced_hang', 36, 50, layer=1, play_mode=1, speed=1, blendin=10)
         super(WalkHang, self).Enter()        
         
     def Execute(self):
         self.FSM.stateLife += 1
-        #self.FSM.ToTransition('toLand')
+        self.FSM.owner.obj.linearVelocity = [0,0,0]
+        #self.FSM.owner.arm.playAction('c_braced_hang', 0, 36, layer=2, play_mode=0, speed=1, blendin=10)
+        self.FSM.owner.arm.playAction('c_braced_hang', 36, 50, layer=1, play_mode=1, speed=1, blendin=10)
+        if dict['lUD'] > .04:
+            self.FSM.ToTransition('toWalkAir')
+           
         
+        self.FSM.owner.move_walk_cam()
+        if self.FSM.stateLife > 25:
+            self.moveable = True
+        if self.moveable:
+            if dict['lUD'] < -.04:
+                self.FSM.ToTransition('toWalkClimb') 
+            self.FSM.owner.hang_move()
+        ground_rays = self.FSM.owner.get_ground_ray() 
+        if ground_rays[0][0] != None:
+            dist = self.FSM.owner.get_ground_dist(ground_rays)
+            if dist < .4:
+                self.FSM.ToTransition('toWalkLand') 
+
+        hang_ray = self.FSM.owner.get_hang_ray()           
+        hang_align_ray = self.FSM.owner.get_hang_align_ray()
+        #print(hang_align_ray, 'hang_align_ray')
+        #self.FSM.owner.hang_move()
+
+
+
+        if hang_ray[0] != None:
+            hr_dist = self.FSM.owner.get_hang_dist(hang_ray)
+            print(hr_dist, 'hang dist')
+            if hr_dist < .5:
+                self.FSM.owner.obj.linearVelocity = [0,0,0]
+                self.FSM.owner.obj.worldPosition.z = hang_ray[1].z  - 1
+            if hang_align_ray[0] != None:
+                print(hang_align_ray[0])
+                v = hang_align_ray[2]
+                self.FSM.owner.obj.alignAxisToVect(v, 0, .5)    
+        else:
+            self.FSM.ToTransition('toWalkAir')
+        if hang_align_ray[0] == None:
+            self.FSM.ToTransition('toWalkAir')
+
+        self.FSM.owner.align_walk_z()
     def Exit(self):
         pass
 
@@ -361,12 +451,20 @@ class WalkClimb(State):
         
     def Enter(self):
         self.FSM.stateLife = 1
+        self.FSM.owner.arm.playAction('c_wallclimb', 1, 50, layer=3, play_mode=0, speed=1, blendin=10)
         super(WalkClimb, self).Enter()        
         
     def Execute(self):
         self.FSM.stateLife += 1
         #self.FSM.ToTransition('toLand')
         
+        if self.FSM.stateLife > 25:
+            self.FSM.owner.obj.applyForce([-300, 0, 80], True)
+        else:
+            self.FSM.owner.obj.applyForce([-20, 0, 80], True)    
+        if self.FSM.stateLife > 35:
+            self.FSM.ToTransition('toWalkLand')
+        
     def Exit(self):
         pass                                
 
@@ -389,6 +487,60 @@ class WalkHurdle(State):
 
 
 #==================================== 
+
+            
+class Example(State):
+    def __init__(self,FSM):
+        super(Example, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(Example, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        #self.FSM.ToTransition('toExample')
+        
+    def Exit(self):
+        pass
+
+#==================================== 
+
+            
+class Example(State):
+    def __init__(self,FSM):
+        super(Example, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(Example, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        #self.FSM.ToTransition('toExample')
+        
+    def Exit(self):
+        pass
+
+#==================================== 
+
+            
+class Example(State):
+    def __init__(self,FSM):
+        super(Example, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(Example, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        #self.FSM.ToTransition('toExample')
+        
+    def Exit(self):
+        pass
+
+#==================================== 
             
 class Roll(State):
     def __init__(self,FSM):
@@ -397,6 +549,7 @@ class Roll(State):
     def Enter(self):
         self.FSM.stateLife = 1
         self.FSM.owner.walking = False
+        self.FSM.owner.obj['getonboard'] = False
         dict['walking'] = False
         super(Roll, self).Enter()        
         
@@ -407,6 +560,8 @@ class Roll(State):
             self.FSM.owner.obj['getoffboard'] = True
             self.FSM.ToTransition('toWalk')
             print('fsm to walk')
+        if self.FSM.owner.obj['fall'] == True:
+            self.FSM.ToTransition('toRagdoll')    
         print('rolling')
         #self.FSM.ToTransition('toLand')
         
@@ -414,3 +569,24 @@ class Roll(State):
         pass
 
 #==================================== 
+
+class Ragdoll(State):
+    def __init__(self,FSM):
+        super(Ragdoll, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        super(Ragdoll, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        print('ragdolling')
+        if dict['yBut'] == 1:
+            self.FSM.owner.obj['fall'] = False
+            self.FSM.owner.cont.activate(self.FSM.owner.cont.actuators['walk'])
+            self.FSM.ToTransition('toWalk')
+        
+    def Exit(self):
+        pass                                
+
+#==================================== 

scripts/controller2.py

@@ -4322,4 +4322,4 @@ def main():
     elif own['actionState'] in ['fak_backside_grab_out', 'fak_frontside_grab_out', 'fak_frontside_nose_grab_out', 'fak_frontside_tail_grab_out', 'fak_backside_nose_grab_out', 'fak_backside_tail_grab_out', 'fak_walk_air_out', 'fak_air-walk_air', 'fak_judo_out', 'fak_frigid_out', 'fak_fsonefoot_out', 'fak_onefoot_out'] and own['requestAction'] in  ['reg_land', 'fak_land']:
         own['requestAction'] = 'fak_land'   
 
-    print(dict['walk'], 'controller walk')
+    print(own['getonboard'], 'controller geton', '--controller running')

scripts/game.py

@@ -4,14 +4,10 @@ import requests
 import platform
 
 def phone_home():
-
-
-	#url = 'https://www.w3schools.com/python/demopage.php'
 	url = 'https://shuvit.org/phone_home.php'
 	n = platform.uname()
 	n = platform.platform()
 	myobj = {'somekey': n}
-
 	x = requests.post(url, data = myobj, timeout=3.50)
 	print('phone home response')
 	print(x.text)
@@ -20,10 +16,10 @@ def main(cont):
 	own = cont.owner
 	dict = bge.logic.globalDict
 	if 'game_inited' not in own:
+		info = bge.logic.PrintGLInfo()
 		own['game_inited'] = True
 		own['cont'] = cont
 		dict['gameFSM'] = FSM.GameFSM(own)
 		#phone_home()
 
-
 	dict['gameFSM'].Execute()

scripts/player.py

@@ -10,6 +10,11 @@ class Player:
 		self.obj = cont.owner
 		self.FSM = FSM.PlayerFSM(self)
 		self.walking = True
+		self.last_pos = self.obj.worldPosition.copy()
+		self.throw_timer = 0
+		self.throw_deck = None
+		self.throw_deck_empty = self.obj.childrenRecursive["throw_deck_empty"]
+		#self.throw_deck_obj = dict['level_scene'].objects['throw_deck']
 		dict['walking'] = True
 		#print(self.obj.childrenRecursive)
 		#self.arm = self.obj.childrenRecursive['Char4']
@@ -17,68 +22,108 @@ class Player:
 
 	def update(self):
 		self.FSM.Execute()
+		self.last_pos = self.obj.worldPosition.copy()
 
 	def get_ground_ray(self):
-
 		v = self.obj.worldOrientation.col[0]
 		tv = v.normalized()
-
 		axis = 2
-		distance = -5
+		distance = -50
 		start = self.obj.worldPosition.copy()
-		#front_start = start - 0.30 * tvfront_start = start - 0.30 * tv
 		back_start = start + 0.15 * tv
 		start.z += .1
 		end = Vector.copy(self.obj.worldPosition + (self.obj.worldOrientation.col[axis] * distance))
-		
-		ray = self.obj.rayCast(end, back_start, 0, 'ground', 1, 0, 0)
-
+		ray = self.obj.rayCast(end, back_start, 0, 'ground', 1, 0, 0, 53247)
 		v = self.obj.linearVelocity.copy()
-
 		v = self.obj.worldOrientation.col[0]
 		tv = v.normalized()
 		front_start = start - 0.30 * tv
 		start.z += .1
 		front_end = Vector(front_start + (self.obj.worldOrientation.col[axis] * distance))
 		frontray = self.obj.rayCast(front_end, front_start, 0, 'ground', 1, 1, 0, 53247)
-
-		bge.render.drawLine(front_start, front_end, [1,0,0])
-		#print(ray)
+		#bge.render.drawLine(front_start, front_end, [1,0,0])
 		return [ray, frontray]
 
+
+	def get_hang_ray(self):
+
+		v = self.obj.worldOrientation.col[0]
+		tv = v.normalized()
+
+		axis = 2
+		distance = -5
+		start = self.obj.worldPosition.copy()
+		start.z += 1.8
+		mstart = start - 0.40 * tv
+		
+		end = Vector(mstart + (self.obj.worldOrientation.col[axis] * distance))
+		ray = self.obj.rayCast(end, mstart, 0, 'ground', 1, 1, 0, 53247)
+		#ray = self.obj.rayCast(end, mstart, 0, '', 1, 1, 0, 53247)
+		#bge.render.drawLine(mstart, end, [0,0,1])
+
+		return ray
+
+	def get_hang_align_ray(self):
+
+		v = self.obj.worldOrientation.col[0]
+		tv = v.normalized()
+
+		axis = 0
+		distance = -2
+		start = self.obj.worldPosition.copy()
+		start.z += 1
+		#mstart = start - 0.40 * tv
+		#mstart = start * tv
+		mstart = start 
+
+		end = Vector(mstart + (self.obj.worldOrientation.col[axis] * distance))
+		#ray = self.obj.rayCast(end, mstart, 0, 'ground', 1, 0, 0, 53247)
+		ray = self.obj.rayCast(end, mstart, 0, '', 1, 0, 0, 53247)
+		#if ray[0] != None:
+			#print(ray[0], 'player funct')
+		#bge.render.drawLine(mstart, end, [0,1,0])
+		
+		return ray
+
+
+
 	def get_ground_dist(self, groundray):
 		gr = groundray[0]
 		fgr = groundray[1]
-		#when player is on the ground, dist is .25
 		d = None
 		
 		if gr[0] != None:
-
 			p_z = self.obj.worldPosition.z
 			g_z = gr[1].z
-
 			distance_to_ground = p_z - g_z
-
 			p2 = None
 			if fgr[0] != None:
 				p2 = p_z - fgr[1].z 
 
 				if p2 < distance_to_ground:
-					#front to ground is bigger than back to ground
-					#val = p2 - distance_to_ground
-					#val *= .1
-					print(fgr[0], 'ray hit obj')
 					distance_to_ground = p2
 
 			return distance_to_ground
 
+
+
+	def get_hang_dist(self, groundray):
+		if groundray[0] != None:
+			p_z = self.obj.worldPosition.z
+			g_z = groundray[1].z
+			distance_to_ground = p_z - g_z
+			return distance_to_ground
+
+
 	def set_walk_z(self, dist):
 		if dist < .6:
 			target_dist = .3
-			#z_targ = self.obj.worldPosition.z + (target_dist - dist)
 			self.obj.worldPosition.z += (target_dist - dist)
 			self.obj.linearVelocity.z = 0
 
+	def align_walk_z(self):
+		self.obj.alignAxisToVect([0,0,1], 2, .05)
+
 	def walk_movement(self):
 		
 		moving = False
@@ -105,7 +150,8 @@ class Player:
 
 		if dict['kb_s'] == 2 or dict['lUD'] > .06:
 			#o.applyForce([10, 0, 0], True)
-			o.linearVelocity.x -= 1
+			if o.linearVelocity.x < (dict['max_walk_vel'] / 2):
+				o.linearVelocity.x += .05
 			#print('w')
 
 		if dict['kb_a'] == 2 or dict['lLR'] < -.03:
@@ -121,6 +167,117 @@ class Player:
 
 		return moving
 
+	def move_walk_cam(self):
+		amt = -.05
+		amt2 = -.07
+		if dict['rLR'] > .04:
+			dict['camera'].applyMovement([amt, 0, 0], True)
+		elif dict['rLR'] < -.04:
+			dict['camera'].applyMovement([-amt, 0, 0], True)	
+
+		if dict['rUD'] > .04:
+			dict['camera'].applyMovement([0, -amt2, 0], True)
+		elif dict['rUD'] < -.04:
+			dict['camera'].applyMovement([0, amt2, 0], True)	
+
+	def check_reset_point(self):
+		print(dict['udPad'], dict['ddPad'])
+		if dict['udPad'] == 1:
+			print('set reset')
+		elif dict['ddPad'] == 1:
+			print('go to reset')			
+#reset
+		if dict['ddPad'] == 1:
+			spawn_pos = self.obj['spawn_pos']
+			spawn_rot = self.obj['spawn_rot']
+			spawn_cam_pos = self.obj['spawn_cam_pos']
+			spawn_cam_rot = self.obj['spawn_cam_rot']
+			try:
+				self.obj.worldPosition = (spawn_pos[0], spawn_pos[1], (spawn_pos[2] + .1))
+				self.obj.worldOrientation = [[spawn_rot[0][0], spawn_rot[0][1],spawn_rot[0][2]], [spawn_rot[1][0],spawn_rot[1][1], spawn_rot[1][2]], [0.0, 0.0, 1.0]]
+				dict['camera'].worldPosition = (spawn_cam_pos[0], spawn_cam_pos[1], (spawn_cam_pos[2]))
+				dict['camera'].worldOrientation = [[spawn_cam_rot[0][0], spawn_cam_rot[0][1], spawn_cam_rot[0][2]], [spawn_cam_rot[1][0], spawn_cam_rot[1][1], spawn_cam_rot[1][2]], [0.0, 0.0, 1.0]]
+			except:
+				self.obj.worldPosition = (0, 0, .1)
+				self.obj.worldOrientation = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]
+
+			if self.obj["spawn_stance"] == 1:
+				self.obj.setLinearVelocity([.1,0,0], 1)
+
+			else:
+				self.obj.setLinearVelocity([-.1,0,0], 1)
+
+		if dict['udPad'] == 1:
+			self.obj['spawn_pos'] = [self.obj.worldPosition[0], self.obj.worldPosition[1], self.obj.worldPosition[2]]
+			self.obj['spawn_rot'] = [[self.obj.worldOrientation[0][0], self.obj.worldOrientation[0][1],self.obj.worldOrientation[0][2]], [self.obj.worldOrientation[1][0], self.obj.worldOrientation[1][1], self.obj.worldOrientation[1][2]], self.obj.worldOrientation[2][2]]
+			self.obj['spawn_cam_pos'] = [dict['camera'].worldPosition[0], dict['camera'].worldPosition[1], dict['camera'].worldPosition[2]]
+			self.obj['spawn_cam_rot'] = [[dict['camera'].worldOrientation[0][0], dict['camera'].worldOrientation[0][1],dict['camera'].worldOrientation[0][2]], [dict['camera'].worldOrientation[1][0], dict['camera'].worldOrientation[1][1], dict['camera'].worldOrientation[1][2]], dict['camera'].worldOrientation[2][2]]
+			stance = self.obj["stance"]
+			self.obj["spawn_stance"] = stance
+
+
+	def hang_move(self):
+		if dict['lLR'] > .04:
+			#self.arm.playAction('c_hanghopleft', 0, 45, layer=3, play_mode=0, speed=.75, blendin=10)
+			self.arm.playAction('c_shimmy_l', 0, 34, layer=3, play_mode=0, speed=.75, blendin=10)
+			self.obj.applyForce([0,235,0], True)
+		if dict['lLR'] < -.04:
+			#self.arm.playAction('c_hanghopright', 0, 45, layer=3, play_mode=0, speed=.75, blendin=10)
+			self.arm.playAction('c_shimmy_r', 0, 34, layer=3, play_mode=0, speed=.75, blendin=10)
+			self.obj.applyForce([0,-235,0], True)
+
+
+	def check_throw(self):
+
+		def throw(strength):
+			print('throwing with strength', strength)
+			if self.throw_deck != None:
+				self.throw_deck.endObject()
+				self.throw_deck = None
+			self.throw_deck = dict['level_scene'].addObject('throw_deck', self.throw_deck_empty, 0)
+			self.throw_deck.worldOrientation = self.throw_deck_empty.worldOrientation
+			#self.throw_deck.applyForce([0, 0, -300], True)
+			#-z = forward +y = height
+			self.throw_deck.applyForce([0, 150, -200], True)
+			self.hide_deck()
+
+		if self.throw_deck == None:	
+			strength = self.throw_timer
+			
+			if strength > 19:
+				strength = 19
+
+			if dict['bBut'] == 0 and dict['last_bBut'] == 1:
+				self.throw_timer = 0
+				self.arm.playAction('c_throw', 19, 45, layer=7, play_mode=0, speed=.75, blendin=5)
+				self.deck_arm.playAction('b_throw', 19, 45, layer=7, play_mode=0, speed=.75, blendin=5)
+				throw(strength)
+			elif dict['bBut'] == 1:
+				self.arm.playAction('c_throw', 0, 45, layer=7, play_mode=1, speed=.75, blendin=5)
+				self.deck_arm.playAction('b_throw', 0, 45, layer=7, play_mode=1, speed=.75, blendin=5)
+				self.arm.setActionFrame(strength, 7)
+				self.deck_arm.setActionFrame(strength, 7)
+				self.throw_timer += 1
+			else:
+				self.throw_timer = 0
+		else:
+			if dict['bBut'] == 0 and dict['last_bBut'] == 1:
+				self.show_deck()
+				self.throw_deck.endObject()
+				self.throw_deck = None
+
+
+
+		#if self.throw_timer > 0:
+	def hide_deck(self):
+		for x in self.deck_arm.childrenRecursive:
+			x.visible = False
+			
+	def show_deck(self):
+		for x in self.deck_arm.childrenRecursive:
+			x.visible = True
+
+
 
 
 def update(cont):

scripts/ragdoll.py

@@ -189,6 +189,9 @@ def main():
                 own.worldPosition = scene.objects['npc_ed_arm_phys_master'].worldPosition
                 own.worldPosition.z += .4
                 cont.activate(cont.actuators['walk']) 
+                own['getonboard'] = True
+                dict['walk'] = 0
+                own['fall'] = False
 
             if dict['lUD'] < -.08 and own['rd_incer'] > 200:
                 physBody = own['rd_rb']

scripts/scene_init.py

@@ -15,6 +15,7 @@ def main():
         
         cam = scene.objects['Camera.003']
         curscene = bge.logic.getCurrentScene()
+        dict['level_scene'] = curscene
 
         dict['overlay_fadeout'] = 1
         scenes = bge.logic.getSceneList()

shuvit.blend

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8ff6a17a5eb21ea481bc3cda4b94b326bbc186b271d726331066ba550059de59
-size 128961440
+oid sha256:ed9ccab1cd84ac46d7e14d38f51a2a6c4c23d4bc182f4cb05510ee43188ef47f
+size 125585980