cars

assets/car1.blend

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8ebbd1f8f77a69ff03711a8286c0e0a8ade60e2a6dc327c9ab7457cf5dca857b
-size 2010100
+oid sha256:362449558c4995c81c9ab8593a98b97477cb436e5d2432a0be8351ed7a3f583a
+size 1999844

assets/roads.blend

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:784809674b518a6435240657168d882fc30d0dace8f4fdd643ecc4dc0189b4e4
-size 83642732
+oid sha256:7bca54bebf1841f270accc171b67350ad904324a6d4ab2f0dbb6b26988ad2531
+size 19632312

assets/roads1.blend

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

assets/roads4.blend

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

assets/user2.blend

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:55ccbcfd7471751baddd78f3c758c42b6c531ca7bae09a608628e889fcd527dd
-size 6498608
+oid sha256:646ea4d4c0554f2a357c06b54bab13bd8ab1926a692cb7d1da60b03c7fce6b28
+size 6393344

assets/user2_working.blend

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

scripts/FSM.py

@@ -2,6 +2,7 @@ import bge
 
 import StatesNpcPed
 import StatesCamera
+import StatesCar
    
 #====================================
 class Transition(object):
@@ -94,3 +95,30 @@ class CameraFSM(Char):
     
     def Execute(self):
         self.FSM.Execute(self.owner)    
+
+#=================================== 
+
+class CarFSM(Char):
+    def __init__(self, owner):
+        self.FSM = FSM(self, owner)
+        self.owner = owner
+
+        
+        state_list = [
+        'Example',
+        'Activate',
+        'ExitParallelPark',
+        'EnterParallelPark',
+        'NavigateToTarget']
+
+        
+        for s in state_list:
+            self.FSM.AddState(s, getattr(StatesCar, s)(self.FSM))
+            t = 'to' + s
+            self.FSM.AddTransition(t, Transition(s))
+        
+        if self.FSM.curState == None:
+            self.FSM.SetState('Example')
+    
+    def Execute(self):
+        self.FSM.Execute(self.owner)    

scripts/StatesCar.py

@@ -0,0 +1,432 @@
+import utils
+import bge
+import random
+from mathutils import Vector
+
+#====================================     
+
+def mark_path(path, y):
+    iter_ = 0
+
+    for x in path:
+        pm = bge.logic.getCurrentScene().addObject('path_marker', y.obj, 0)
+        pm.worldPosition = path[iter_]    
+        iter_ += 1
+        if iter_ == 1:
+            pm.color = [0,1,0,.4]
+        if iter_ == (len(path) ):
+            pm.color = [1,0,0,.4]
+        if iter_ == (len(path) +1):
+            pm.color = [1,0,1,.4]    
+        y.path_display.append(pm)
+
+def clear_markers(self):
+    # for x in bge.logic.getCurrentScene().objects:
+    #     if 'path_marker' in x.name:
+    #         x.endObject()
+    for x in self.FSM.owner.path_display:
+        try:
+            x.endObject()
+        except:
+            pass
+def get_ground_ray(self):
+    Axis = 2
+    Distance = -10
+    end = self.obj.worldPosition + (self.obj.worldOrientation.col[Axis]*Distance)
+    start = self.obj.worldPosition.copy()
+    ground_ray = self.obj.rayCast(end, start, 6,'', 1, 0)
+    return ground_ray
+
+def set_height(self):
+    ground_ray = get_ground_ray(self)
+    target_height = 0.9
+    hitpoint = ground_ray[1]
+    try:
+        dist = self.obj.getDistanceTo(hitpoint)
+        if dist < target_height:
+            self.obj.worldPosition.z += target_height - dist
+            self.obj.linearVelocity.z = 0
+        self.obj.linearVelocity.y *= .1
+    except:
+        pass
+
+def align_to_road(self):
+    ground_ray = get_ground_ray(self)
+    try:
+        self.obj.alignAxisToVect(ground_ray[2], 2, .15)
+    except:
+        pass
+    
+def find_new_parking(self):
+    potentials = []
+    for x in self.manager.parking_spots:
+        if x.status == 'available':
+            potentials.append(x)
+    for x in potentials:
+        min_dist = 100
+        dist = self.obj.getDistanceTo(x.obj)
+        if dist < min_dist:
+            potentials.remove(x)
+            print('----removing potential')
+    if len(potentials) > 0:
+
+        new_parking = random.choice(potentials)
+        path = self.manager.navmesh.findPath(self.start_empty.obj.worldPosition, new_parking.obj.worldPosition)
+        print('parking added at', new_parking.obj.worldPosition)
+
+        mark_path(path, self)
+        return new_parking, path
+    else:
+        self.FSM.FSM.ToTransition('toEnterParallelPark')
+def get_lane_point(self):
+
+
+    self.point = self.path[self.path_index]
+    #print(self.path_index, 'path index')
+
+    v = Vector([self.last_lane_point.x - self.point.x, self.last_lane_point.y - self.point.y, 0])
+    tv = v.normalized()
+    nv = Vector([-tv.y, tv.x, 0]) #rotate 90 degrees
+    self.last_lane_point = self.lane_point
+    self.lane_point = self.point + self.manager.lane_position * nv
+
+
+
+def update_point(self):
+    
+    if self.path_index >= (len(self.path) ):
+        self.FSM.FSM.ToTransition('toEnterParallelPark')
+    else:
+        dist = self.obj.getDistanceTo(self.lane_point)
+        #print(dist, self.path_index)
+        self.point = self.path[self.path_index]
+        if dist < 2.5:
+            get_lane_point(self)   
+            if self.path_index > (len(self.path)):
+                pass
+            else:
+                
+                self.path_index += 1
+            
+
+         
+def align_to_point(self):
+    v = self.obj.getVectTo(self.lane_point)[1]
+    v.z = 0
+    self.obj.alignAxisToVect(v, 0, .1)
+
+def delta_to_vect(self):
+    v = self.obj.getVectTo(self.lane_point)[1]
+    #vt = Vector([self.last_lane_point.x - self.lane_point.x, self.last_lane_point.y - self.lane_point.y, 0])
+
+    delta = self.last_lane_point - self.lane_point
+    delta = delta.cross(v)
+    delta_mult = -.1
+    mult = 1.0
+    deltamove = delta[2] * delta_mult
+    self.obj.applyMovement([0, deltamove, 0], True)
+            
+              
+def apply_gas(self):
+    if self.obj.linearVelocity.x < self.speed_targ:
+        self.obj.applyForce([self.speed_inc, 0, 0], True)
+
+#====================================     
+
+State = type("State", (object,), {})
+#====================================     
+class State(object):
+    def __init__(self, FSM):
+        self.FSM = FSM
+        self.timer = 0
+        self.startTime = 0
+    def Enter(self):
+        self.timer = 0
+        self.startTime = 0
+    def Execute(self):
+        print('Executing')
+    def Exit(self):
+        print('Exiting')
+#==================================== 
+            
+class Example(State):
+    def __init__(self,FSM):
+        super(Example, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        self.FSM.owner.resumePhysics()
+        self.FSM.owner.resumeDynamics()
+        print('physics resumed')
+        super(Example, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        print('doing example')
+        #o = self.FSM.owner
+        #g = o.me['game']
+        #self.FSM.ToTransition('toActivate')
+        #print(self.FSM.owner)
+        #self.FSM.owner.applyRotation([0,0,.01], True)
+        #self.FSM.owner.worldPosition.z = 0
+        #self.FSM.owner.worldPosition.z += 0.1
+        #self.FSM.owner.worldPosition.x += 1.1
+        #print(self.FSM.owner.children)
+
+    def Exit(self):
+        pass
+
+class ExitParallelPark(State):
+    def __init__(self,FSM):
+        super(ExitParallelPark, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        self.FSM.owner.obj.restorePhysics()
+        self.FSM.owner.obj.restoreDynamics()
+        self.FSM.owner.obj.linearVelocity = [0,0,0]
+        self.FSM.owner.target, self.FSM.owner.path = find_new_parking(self.FSM.owner)
+        self.FSM.owner.path_index = 0
+        self.FSM.owner.point = self.FSM.owner.path[self.FSM.owner.path_index]
+        self.FSM.owner.target.status = 'targetted'
+        self.FSM.owner.start_empty.status = 'available'
+        
+        #print('target is', self.FSM.owner.target)
+        print('physics resumed')
+        super(ExitParallelPark, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        #print('doing ExitParallelPark')
+        v = self.FSM.owner.obj.getVectTo(self.FSM.owner.path[0])
+        #v.z = 0
+        self.FSM.owner.obj.alignAxisToVect(v[1], 0, .01)
+        self.FSM.owner.obj.alignAxisToVect([0,0,1], 2, 1)
+        if self.FSM.stateLife > 220:
+            self.FSM.ToTransition('toNavigateToTarget')
+        #self.FSM.owner.obj.applyForce([6, 0, 0], True)
+
+    def Exit(self):
+        pass        
+
+#====================================  
+            
+class EnterParallelPark(State):
+    def __init__(self,FSM):
+        
+        super(EnterParallelPark, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        print('entering parallel park')
+        self.FSM.owner.obj.worldPosition = self.FSM.owner.target.obj.worldPosition
+        self.FSM.owner.obj.worldOrientation = self.FSM.owner.target.obj.worldOrientation
+        self.FSM.owner.obj.applyMovement([0, -6, 0], True)
+        self.FSM.owner.target.status = 'in_use'
+        self.FSM.owner.obj.worldPosition.z += .9
+        self.FSM.owner.obj.suspendDynamics()
+        self.FSM.owner.obj.suspendPhysics()
+        self.FSM.owner.manager.cars_active.remove(self.FSM.owner)
+        self.FSM.owner.active = False
+        self.FSM.owner.start_empty = self.FSM.owner.target
+        self.FSM.owner.last_point = self.FSM.owner.obj.worldPosition
+        self.FSM.owner.point = self.FSM.owner.obj.worldPosition
+        clear_markers(self)
+        super(EnterParallelPark, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+    
+        #self.FSM.ToTransition('toActivate')
+        
+
+    def Exit(self):
+        pass
+
+#==================================== 
+
+class NavigateToTarget(State):
+    def __init__(self,FSM):
+        super(NavigateToTarget, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        
+        super(NavigateToTarget, self).Enter()        
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+        update_point(self.FSM.owner)
+
+        align_to_point(self.FSM.owner)
+        align_to_road(self.FSM.owner)
+        set_height(self.FSM.owner)
+        delta_to_vect(self.FSM.owner)
+        apply_gas(self.FSM.owner)
+        #print('target', self.FSM.owner.target.obj.worldPosition)
+
+        #emergency exit
+        if self.FSM.stateLife > 60 * 90:
+            self.FSM.ToTransition('toEnterParallelPark')
+
+        #print('doing NavigateToTarget')
+
+        #self.FSM.owner.obj.applyForce([6, 0, 0], True)
+
+    def Exit(self):
+        pass        
+
+#====================================  
+
+class Activate(State):
+    def __init__(self,FSM):
+        super(Activate, self).__init__(FSM)    
+        
+    def Enter(self):
+        self.FSM.stateLife = 1
+        # self.FSM.owner.restorePhysics()
+        # self.FSM.owner.restoreDynamics()
+        # self.FSM.owner.worldPosition.z = 2
+        # self.FSM.curTarget = None
+        # self.FSM.last_target = None
+        # #self.FSM.path = None
+        # self.point = None
+        # self.last_point = self.FSM.owner.worldPosition.copy()
+        # self.last_pos = self.FSM.owner.worldPosition.copy()
+        # self.backup = 0
+        # self.lane_point = None
+        # self.last_lane_point = self.last_pos
+        # self.lane_position = 1.75
+        # self.pos_his = []
+        # self.max_speed = 5.0
+        # self.FSM.path = None
+        # print('physics resumed')
+        super(Activate, self).Enter()        
+        
+    def find_target(self):
+        pass
+        # if self.FSM.curTarget == None:
+        #     choices = self.FSM.owner['manager'].targets
+        #     if self.FSM.last_target in choices:
+        #         choices.remove(self.FSM.last_target)
+        #     if choices:    
+        #         self.FSM.curTarget = random.choice(choices)
+        #         self.FSM.path = self.FSM.owner['manager'].navmesh.findPath(self.FSM.owner.worldPosition, self.FSM.curTarget.worldPosition)
+        #         self.FSM.path.remove(self.FSM.path[0])
+        #         self.point = self.FSM.path[0]
+        #         vt = Vector([self.last_point.x - self.point.x, self.last_point.y - self.point.y, 0])
+        #         tv = vt.normalized()
+        #         #rotate 90 degrees
+        #         nv = Vector([-tv.y, tv.x, 0])
+        #         distance = 3.5
+        #         self.lane_point = self.point + self.lane_position * nv
+        #     else:
+        #         print('no fucking choices')
+        #     return False
+        # else:
+        #     return True  
+
+    def drive_to_point(self):
+        if self.FSM.path:
+            ground_ray = get_ground_ray(self)
+            if ground_ray[0]:
+                set_height(self, ground_ray)
+                align_to_road(self, ground_ray) 
+
+            v = self.FSM.owner.getVectTo(self.lane_point)               
+            speed_force = 800.0
+            max_speed = 5.0
+            behind = False
+            local = self.FSM.owner.worldOrientation.inverted() * (self.lane_point - self.FSM.owner.worldPosition) 
+            v2 = v[1].copy()
+            v2.z = 0
+            delta = self.last_lane_point - self.lane_point
+            delta = delta.cross(v[1])
+            delta_mult = -.1
+            mult = 1.0
+            backup_time = 20
+
+            #change max speed
+            if self.FSM.stateLife % 180 == 0:
+                print('change speed force')
+                self.speed_force = random.choice([max_speed * 1.3, max_speed * 1.6, max_speed * .8, max_speed * .6, max_speed])
+
+            if local.x > 0 and self.backup == 0:
+
+                if self.FSM.owner.linearVelocity.x < self.max_speed:
+                    self.FSM.owner.applyForce([speed_force, 0, 0], True)
+
+                deltamove = delta[2] * delta_mult
+                #self.FSM.owner.applyMovement([0, deltamove, 0], True)
+
+                f = deltamove * 5000
+                self.FSM.owner.applyForce([0, f, 0], True)
+                v = self.FSM.owner.getVectTo(self.lane_point)
+                v2 = v[1].copy()
+                v2.z = 0
+                self.FSM.owner.alignAxisToVect(v2, 0, .05)
+
+
+            else:
+                if local.x < 0:
+                    self.backup = backup_time   
+
+                if self.backup > 0:
+                    print('backing up')
+                    v = self.FSM.owner.getVectTo(self.FSM.path[0])
+                    v2 = v[1].copy()
+                    v2.z = 0
+                    self.FSM.owner.alignAxisToVect(v2, 0, .02)
+                    if self.FSM.owner.linearVelocity.x > -max_speed / 2:
+                        self.FSM.owner.applyForce([-speed_force * .8, 0, 0], True)
+                    self.backup -= 1
+
+            dist = self.FSM.owner.getDistanceTo(self.lane_point)
+
+            if dist < 2.5 and (len(self.FSM.path) > 0):    
+                #print(self.FSM.path,'this is the path')
+                #print('navmesh point removed')
+                self.last_point = self.point
+                self.last_lane_point = self.lane_point
+                self.FSM.path.remove(self.FSM.path[0])
+
+                if len(self.FSM.path) > 0:
+                    self.point = self.FSM.path[0]
+                    v = Vector([self.last_point.x - self.point.x, self.last_point.y - self.point.y, 0])
+                    tv = v.normalized()
+                    nv = Vector([-tv.y, tv.x, 0]) #rotate 90 degrees
+                    self.lane_point = self.point + self.lane_position * nv
+
+                else:
+                    self.point = None
+
+            if self.FSM.path == []:
+                self.FSM.curTarget = None          
+
+            #progress
+            self.pos_his.append(self.FSM.owner.worldPosition.copy())
+            pos_his_len = len(self.pos_his)
+            if pos_his_len > 200:
+                #sum_ = abs(self.FSM.owner.worldPosition.x) + abs(self.pos_his[-1][0]) + abs(self.FSM.owner.worldPosition.y) + abs(self.pos_his[-1][1]) 
+                sum_ = abs(self.FSM.owner.worldPosition.x - self.pos_his[0][0]) + abs(self.FSM.owner.worldPosition.y - self.pos_his[0][1])
+                #print(sum_, 'sum')
+                if sum_ < .05:
+                    self.backup = backup_time
+                    print('progress stopped')
+                del self.pos_his[0]
+            
+
+    def Execute(self):
+        self.FSM.stateLife += 1
+
+        #if self.find_target():
+            #self.drive_to_point()
+
+        #self.FSM.owner.linearVelocity.y = 0
+        #self.last_pos = self.FSM.owner.worldPosition.copy()
+        #self.FSM.owner['manager'].target_loc.worldPosition = self.lane_point
+
+    def Exit(self):
+        pass
+
+#====================================  

scripts/actionPlayer.py

@@ -140,13 +140,17 @@ state_a = ['reg_idle',
 'fak_frigid',
 'fak_fsonefoot',
 'fak_onefoot',
-'reg_back_invert']
+'reg_back_invert',
+'reg_onboard', 
+'reg_offboard',
+'fak_onboard', 
+'fak_offboard']
 
 state_b = ['reg_jump',
 'reg_walk_air',
 'reg_walk_air_out',
-'reg_onboard',
-'reg_offboard',
+#'reg_onboard',
+#'reg_offboard',
 'reg_brfoot',
 'reg_frfoot',
 'reg_blfoot',
@@ -165,8 +169,8 @@ state_b = ['reg_jump',
 'fak_jump',
 'fak_walk_air',
 'fak_walk_air_out',
-'fak_onboard',
-'fak_offboard',
+#'fak_onboard',
+#'fak_offboard',
 'fak_brfoot',
 'fak_frfoot',
 'fak_blfoot',
@@ -239,7 +243,7 @@ def check_exit(aState, rA, timer, ac):
 		rv = aState
 
 	if force != None and fe >= timer:
-		print('doing exit timer')
+		print('doing exit timer', force)
 		rv = force
 
 	return rv
@@ -295,6 +299,8 @@ def main(cont):
 		else:
 			actionPlayer(action)
 		newState = check_exit(aState, rA, timer, action)
+		if aState == 'reg_onboard':
+			print('onboarding..')
 
 		if aState == 'reg_back_invert':
 			print('fffffffffffffffffffffffffffffffff')		

scripts/actionsFSMlist.py

@@ -33,7 +33,7 @@ class a_class:
 
 reg_walk = a_class(
 	#player armature action name, start, end frames
-	'reg_nwalk', 0, 35,
+	'reg_nwalk2', 0, 30,
 	#deck action name, start, end frames  
 	'b_reg_walk', 0, 35,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
@@ -49,11 +49,11 @@ reg_walk = a_class(
 
 reg_walkFast = a_class(
 	#player armature action name, start, end frames, start, end frames
-	'reg_nwalk', 0, 35,
+	'reg_run', 0, 30,
 	#deck action name, start, end frames  
 	'b_reg_walk', 0, 35,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
-	1, 1, 0, 0, 
+	1, 1, 0, 10, 
 	#intro, length
 	None, 0,
 	#exits
@@ -73,7 +73,7 @@ reg_idle = a_class(
 	#intro, length
 	None, 0,
 	#exits
-	['reg_walk', 'reg_idle2', 'reg_idle3', 'reg_idle4', 'reg_idle5', 'reg_idle6', 'reg_idle7', 'reg_jump', 'reg_sit', 'reg_onboard'],
+	['reg_walk', 'reg_walkFast', 'reg_idle2', 'reg_idle3', 'reg_idle4', 'reg_idle5', 'reg_idle6', 'reg_idle7', 'reg_jump', 'reg_sit', 'reg_onboard'],
 	#force exit, frame
 	None, 0,
 	#opposite
@@ -201,7 +201,7 @@ reg_walk_air = a_class(
 	#intro, length
 	None, 0,
 	#exits
-	['reg_walk_air_out', 'reg_onboard'],
+	['reg_walk_air_out', 'reg_onboard', 'reg_walk', 'reg_walkFast'],
 	#force exit, frame
 	None, 0,
 	#opposite
@@ -263,13 +263,13 @@ reg_onboard = a_class(
 	#'b_reg_offboard', 24, 1,
 	'b_reg_onboard', 1, 100,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
-	1, 2, 0, 5,
+	4, 2, 0, 5,
 	#intro, length
 	None, 0,
 	#exits
 	['reg_roll'],
 	#force exit, frame
-	'reg_roll', 48,
+	'reg_roll', 98,
 	#opposite
 	None)
 
@@ -279,13 +279,13 @@ reg_offboard = a_class(
 	#deck action name, start, end frames  
 	'b_reg_offboard', 1, 40,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
-	1, 1, 1, 5,
+	4, 1, 0, 5,
 	#intro, length
 	None, 0,
 	#exits
 	['reg_idle', 'reg_walkFast', 'reg_walk', 'reg_onboard'],
 	#force exit, frame
-	None, 0,
+	'reg_idle', 39,
 	#opposite
 	None)
 
@@ -454,11 +454,11 @@ reg_pump_right = a_class(
 
 reg_push = a_class(
 	#player armature action name, start, end frames
-	'reg_push', 1, 35,
+	'reg_push2', 1, 70,
 	#deck action name, start, end frames  
 	'b_reg', 1, 1,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
-	1, .5, 0, 10,
+	1, 1, 0, 10,
 	#intro, length
 	None, 0,
 	#exits
@@ -2267,7 +2267,7 @@ fak_onboard = a_class(
 	#deck action name, start, end frames  
 	'b_fak_offboard', 10, 1,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
-	1, .5, 0, 5,
+	4, .5, 0, 5,
 	#intro, length
 	None, 0,
 	#exits
@@ -2283,13 +2283,13 @@ fak_offboard = a_class(
 	#deck action name, start, end frames  
 	'b_fak_offboard', 1, 30,
 	#layer, speed, mode (0 = play, 1 = loop), blendin
-	1, .5, 0, 5,
+	4, .5, 0, 5,
 	#intro, length
 	None, 0,
 	#exits
 	['fak_idle', 'fak_walkFast', 'fak_walk', 'fak_onboard'],
 	#force exit, frame
-	None, 0,
+	'fak_idle', 28,
 	#opposite
 	None)
 

scripts/camera.py

@@ -7,6 +7,7 @@ import camFSM
 import birds
 import sound_man
 import FSM
+import cars
 
 def main(cont):
     #camFSM.main(cont)
@@ -66,6 +67,7 @@ def main(cont):
         dict['camera'] = cam1
         own['NpcPedFSM'] = FSM.NpcPed(own)
         own['CamFSM'] = FSM.CameraFSM(own)
+        own['life'] = 0
     acam = scene.active_camera
 
     def get_cam_state():
@@ -369,5 +371,11 @@ def main(cont):
     camFSM.main(cont)
     birds.main(cont, scene)
     sound_man.main(cont)
-    own['NpcPedFSM'].Execute()
-    own['CamFSM'].Execute()
+    
+    #own['NpcPedFSM'].Execute()
+    if own['life'] % 2 == 1:
+        cars.Execute(cont)
+        own['CamFSM'].Execute()
+
+
+    own['life'] += 1

scripts/cars.py

@@ -0,0 +1,206 @@
+import bge
+import random
+import FSM
+
+car_colors = [[.2,.01,.01,1], [.5,.5,.4,1], [.005,.01,.015,1], [.005, .1, 0.003, 1], [.1, .1, .1, 1]]
+
+def car_run_check(self):
+	output = False
+	for x in bge.logic.getCurrentScene().objects:
+		if 'car_park_empty' in x.name:
+			self.parking_spots.append(x)
+			x['in_use'] = False
+			print('this is a parking spot')
+			output = True
+	
+	return output
+			
+
+def get_parking_spots():
+	op = []
+	for obj in bge.logic.getCurrentScene().objects:
+		if 'parking' in obj:
+			ps = ParkingSpot(obj, 'available')
+			op.append(ps)
+	return op
+
+def get_intersections():
+	op = []
+	for obj in bge.logic.getCurrentScene().objects:
+		if 'intersection' in obj:
+			op.append(obj)
+	return op		
+
+def add_car(self, x):
+	print('put car here', x.obj.worldPosition)
+	car = bge.logic.getCurrentScene().addObject('car_collider', x.obj, 0)
+	car.worldOrientation = x.obj.worldOrientation
+	car.worldPosition.z += .8
+	car.applyMovement([0, -6, 0], True)
+	car.suspendDynamics()
+	car.suspendPhysics()	
+
+	car.name = 'lcar' + str(len(self.manager.cars))
+	color = random.choice(car_colors)
+	car.color = color
+	for y in car.children:
+		y.color = color
+	print('setting car color to ', car.color)
+	x.status = 'in_use'
+
+
+	return car
+
+#====================================  
+
+class ParkingSpot:
+	def __init__(self, obj, status):
+		self.obj = obj
+		self.status = status
+
+class Car:
+	def __init__(self, own, start_empty):
+		self.manager = own
+		self.life = 0
+		self.start_empty = start_empty
+		self.obj = add_car(self, self.start_empty)
+		self.speed_targ = self.manager.default_speed
+		self.speed_inc = 800
+		self.FSM = FSM.CarFSM(self)
+		self.active = False
+		self.target = None
+		self.lane_point = self.obj.worldPosition
+		self.last_lane_point = self.obj.worldPosition
+		self.path = None
+		self.path_index = 0
+		self.path_display = []
+
+	def Execute(self):
+		self.FSM.Execute()
+		self.life += 1
+
+class CarManager:
+	def __init__(self, own):
+		self.parent = own
+		self.navmesh =None
+		self.cars = []
+		self.max_cars = 15
+		self.max_active = 7
+		self.targets = []
+		self.target_loc = None
+		self.parking_spots = get_parking_spots()
+		self.intersections = get_intersections()
+		#self.active = car_run_check(self)
+		self.active = True
+		self.cars_active = []
+		self.cars_loaded = False
+		#self.max_active = 5
+		self.life = 0
+		self.default_speed = 5.0
+		self.lane_position = 2.5#1.75
+
+
+	def load_cars(self):
+		iter_ = 0
+		#look for car in scene
+		if 'car_collider' in bge.logic.getCurrentScene().objectsInactive:
+
+			start_choices = self.parking_spots.copy()
+			while len(self.cars) < self.max_cars:
+				#get starting position
+				start_choice = random.choice(start_choices)
+				start_choices.remove(start_choice)
+
+				#add_car(self, start_choice.worldPosition)
+				car_ = Car(self, start_choice)
+				self.cars.append(car_)
+
+			for x in self.parking_spots:
+			
+				
+				# print('put car here', x.worldPosition)
+				# car = bge.logic.getCurrentScene().addObject('car_collider', x, 0)
+				# car.worldOrientation = x.worldOrientation
+				# car.worldPosition.z += 1
+				# car.suspendDynamics()
+				# car.suspendPhysics()
+
+				# car['FSM'] = FSM.CarFSM(car)
+				# car['manager'] = self
+				# self.cars.append(car)
+				# car.name = 'lcar' + str(iter_)
+				# color = random.choice(car_colors)
+				# car.color = color
+				# for x in car.children:
+				# 	x.color = color
+				# print('setting car color to ', car.color)
+				iter_ += 1
+
+			for x in bge.logic.getCurrentScene().objects:
+				if 'carNavmesh' in x:
+					self.navmesh = x
+				# if 'car_target' in x:
+				# 	self.targets.append(x)	
+				# 	print('adding target', x)
+				# if 'target_loc' in x:
+				# 	self.target_loc = x		
+
+			self.cars_loaded = True	
+
+		else:
+			mainDir = bge.logic.expandPath("//")
+			car = 'car1'
+			fileName = mainDir + "assets/" + str(car) + '.blend'    
+			
+			path = bge.logic.expandPath(fileName)
+			print('loading car')
+			try:
+				bge.logic.LibLoad(path, 'Scene') 
+			except:
+				print('loading', fileName, 'failed')   
+
+	def activator_check(self):
+		if len(self.cars_active) < self.max_active:
+			l = []
+			for c in self.cars:
+				if not c.active:
+					l.append(c)
+			car = random.choice(l)
+			self.cars_active.append(car)
+			car.active = True
+			car.FSM.FSM.ToTransition('toExitParallelPark')
+			#state
+			print('activate car', car)
+
+	def update(self):
+		#print('car_manager_updating')
+		self.life += 1
+		if self.cars_loaded:
+			#check i f new car should be active
+			if self.life % 360 == 0:
+
+				self.activator_check()
+
+			for car in self.cars_active:
+				car.Execute()
+				#print(car, 'is an acitve car')
+			
+
+		else:
+			self.load_cars()
+			print('------------calling load cars')
+		# l = []
+		# for c in self.parking_spots:		
+		# 	if c.status == 'available':
+		# 		l.append(1)
+		# 	else:
+		# 		l.append(0)
+		#print(l, 'available spots')
+def Execute(cont):
+	own = cont.owner
+	if 'car_manager' not in own:
+		own['car_manager'] = CarManager(own)
+	car_man = own['car_manager']	
+	if car_man.active:
+
+		car_man.update()

scripts/controller2.py

@@ -2010,7 +2010,7 @@ def main():
                 rotation = [0.0, 0.0, ((-rotamt * 1.6) * multer)]
             local = True # use world axis
             own.applyRotation( rotation, local)
-            print('rotation = ', rotation)
+            #print('rotation = ', rotation)
             if onGround:
                 #print("med turn")
                 if STANCE == 0:

scripts/scene_init.py

@@ -133,9 +133,9 @@ def main():
         own['last_roty'] = 0.0
         
         own['walk_targ_speed'] = 2
-        own['walk_fast_targ_speed'] = 5
+        own['walk_fast_targ_speed'] = 8
         own['walk_speed'] = 0
-        own['walk_inc'] = .05
+        own['walk_inc'] = .2
         own['walk_jump_timer'] = 0
         own['no_grind_timer'] = 0
         own['last_jump_frame'] = 0

scripts/walk.py

@@ -326,7 +326,8 @@ def main(cont):
            
     elif (((lup == 1 and aBut == 1) or (dict['kb_lsh'] == 2 and dict['kb_ua'] == 2)) and yBut == False and (r_ground.positive or own['stair_counter'] > 0) and xBut == 0) or (turning == True and aBut == 1):
         own.actuators["walkondirt"].volume = .2
-        own.actuators["walkondirt"].pitch = 1.3
+        #own.actuators["walkondirt"].pitch = 1.3
+        own.actuators["walkondirt"].pitch = 2
         cont.activate(own.actuators["walkondirt"])
         #print('fastwalk')
         if stance == 0 and skater.isPlayingAction(fliplay) == False:        

scripts/walker_states.py

@@ -39,7 +39,7 @@ class Target1(State):
 		nm = self.own['navMesh']
 		self.pt = nm.findPath(self.own.worldPosition, self.scene.objects[self.target].worldPosition)
 		
-		print('target1')
+		#print('target1')
 		super(Target1, self).Enter()
 		
 	def Execute(self):
@@ -62,7 +62,7 @@ class Target1(State):
 			else:
 				self.pt.remove(self.pt[0])
 		else:
-			print('goal reached')	
+			#print('goal reached')	
 			self.npcFSM.ToTransition('toTarget2')	
 
 		if self.npcFSM.stateLife > duration:
@@ -87,7 +87,7 @@ class Target2(State):
 		
 		nm = self.own['navMesh']
 		self.pt = nm.findPath(self.own.worldPosition, self.scene.objects[self.target].worldPosition)
-		print('target2')
+		#print('target2')
 		super(Target2, self).Enter()
 		
 	def Execute(self):
@@ -109,7 +109,7 @@ class Target2(State):
 			else:
 				self.pt.remove(self.pt[0])
 		else:
-			print('goal reached')	
+			#print('goal reached')	
 			self.npcFSM.ToTransition('toTarget3')
 
 		if self.npcFSM.stateLife > duration:
@@ -136,7 +136,7 @@ class Target3(State):
 		nm = self.own['navMesh']
 		self.pt = nm.findPath(self.own.worldPosition, self.scene.objects[self.target].worldPosition)
 
-		print('target3')
+		#print('target3')
 		super(Target3, self).Enter()
 
 		
@@ -160,7 +160,7 @@ class Target3(State):
 			else:
 				self.pt.remove(self.pt[0])
 		else:
-			print('goal reached')	
+			#print('goal reached')	
 			self.npcFSM.ToTransition('toTarget1')	
 
 		if self.npcFSM.stateLife > duration:
@@ -194,11 +194,11 @@ class Idle(State):
 	def Execute(self):
 		self.npcFSM.stateLife += 1
 		duration = 300
-		if self.npcFSM.stateLife > duration:
-			num = randint(1,4)
-			self.npcFSM.ToTransition('toTarget1')
-		else:
-			self.npcArm.playAction('g_idle', 1,201, layer=2, play_mode=0, speed=.5)	
+		# if self.npcFSM.stateLife > duration:
+		# 	num = randint(1,4)
+		# 	self.npcFSM.ToTransition('toTarget1')
+		# else:
+		# 	self.npcArm.playAction('g_idle', 1,201, layer=2, play_mode=0, speed=.5)	
 			
 	def Exit(self):
 		pass
@@ -210,7 +210,7 @@ class Startup(State):
 		
 	def Enter(self):
 		self.npcFSM.stateLife = 1
-		print('npc startup enter')
+		#print('npc startup enter')
 		super(Startup, self).Enter()
 		
 	def Execute(self):

shuvit.blend

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:36b5868936935dc6e4cf8f2d4e321ff29c83909338c0a9f6a90c4e72d112b0d3
-size 112662748
+oid sha256:523757d0949b01bbfb40acc234a2165018eaac6af35797146e1dc8301ec79b68
+size 113390952