2.3 update

assets/buildings.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:16fed1fd530befd4a96ce808b57abf6dd7dc828dac432105ce9a42197c715a45
-size 25388192
+oid sha256:c96d1d66e128a87127bfab82e64b56eae49c8e96e641a17bc120ea0b293ec1dd
+size 24263352

assets/car1.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:201b5cce15fe189350d6d8145c7b3a4891ea8f8c7a0d2a0735036434f38a2372
-size 2003556
+oid sha256:4d50a7dd29dc4dd0d9ae2e25740c5ffb537636b0ef7cf935917ab7817e6d80a3
+size 2003676

assets/materials/base_m_kit.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:8e8bbc46fe8a241bafb503b8fe9d3f8e054a5182a11d637f0c16b39fff237680
-size 43913896
+oid sha256:fcf8b75332373b727633a58789cee2807fedba5e91734d64427b5887ce2d34a1
+size 43913880

assets/roads.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:9c8a35c0558f473447386c4a32da1536dc5719c37262e8c1b8bb55cd3dd782b4
-size 20668232
+oid sha256:fe325b25aa6538776e4353502377f46a89a213f9bbbcf23325efbc1a2eacb6be
+size 38132636

assets/user2-23.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:ce237f858713d7c9eddfd078e64100322cad38373d53d9e877033677a764dd09
+size 12500776

assets/user2.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:3b2527ea21c996d8837f676c7320b0fee9ed4fe5fe34fd5812fb4fd6f688d025
-size 12474024
+oid sha256:0a6c6de794fe00a7519740369793bd56366bc92ca7de9db7d967ee279f8df0ba
+size 13310152

assets/user2_working.blend

 version https://git-lfs.github.com/spec/v1
-oid sha256:efa7cc116a67b09844712555de9d8cb5b613816dd753420aa0cdf0214755baa5
-size 4893180
+oid sha256:4c3671edb4e3bbb4f492d23f7d13bc3c9b1d8fc18f6e5f64c85cfba1db641da4
+size 4920184

assets/user3_working.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:0c331653e541e5f03039ea7dc7a2ada208be95c49050af883ef8109ed743782a
+size 4907104

assets/user7_working.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:97c45edaf1a6874e3828b4bf98111702306f315918a2d745e1c585d7cf9e8482
+size 10603800

scripts/FSM.py

         'ExitParallelPark',
         'EnterParallelPark',
         'NavigateToTarget', 
-        'RequestPath']
+        'RequestPath',
+        'EnterPerpPark', 
+        'ExitPerpPark']
 
         
         for s in state_list:

scripts/StatesCar.py

         if iter_ == (len(path) +1):
             pm.color = [1,0,1,.4]    
         y.path_display.append(pm)
+def single_marker(pos, col):
+    pm = bge.logic.getCurrentScene().addObject('path_marker', None, 0)
+    pm.worldPosition = pos
+    pm.color = col
 
 def clear_markers(self):
     for x in self.FSM.owner.path_display:
             
         return new_parking, path2
     else:
-        self.FSM.FSM.ToTransition('toEnterParallelPark')
+        get_parking_type(self)
+        #self.FSM.FSM.ToTransition('toEnterParallelPark')
 
 def get_lane_point(self):
     self.point = self.path[self.path_index]
 
 def update_point(self):
     if self.path_index >= (len(self.path) ):
-        self.FSM.FSM.ToTransition('toEnterParallelPark')
+        get_parking_type(self)
+        #self.FSM.FSM.ToTransition('toEnterParallelPark')
     else:
         dist = self.obj.getDistanceTo(self.lane_point)
         self.point = self.path[self.path_index]
     v.z = 0
     self.obj.alignAxisToVect(v, 0, .05 * mult)
 
+def align_to_target(self, mult):
+    v = self.obj.getVectTo(self.FSM.FSM.curState.park_loc)[1]
+    v.z = 0
+    self.obj.alignAxisToVect(v, 0, .05 * mult)
+
+
 def delta_to_vect(self):
     v = self.obj.getVectTo(self.lane_point)[1]
     delta = self.last_lane_point - self.lane_point
         self.obj.applyForce([self.speed_inc * mult, 0, 0], True)
 
 def starting_mod(self):
-    #print('doing path mod')
-    #self.path[0] = self.start_empty.obj.worldPosition
-    #del self.path[0]
     path2 = self.path
-    path2.append(self.target.obj.worldPosition) #add endpoint
-    path2.append(self.target.obj.worldPosition) 
-
-    #check if vector between 1 and start point and vector between 2 and sp are the same dir
-    # v1 = Vector(self.start_empty.obj.worldPosition).normalized() - Vector(self.path[0]).normalized()
-    # v2 = Vector(self.start_empty.obj.worldPosition).normalized() - Vector(self.path[1]).normalized()
-    # lens = []
-    # lens.append(len(self.path))
-    # if v1.dot(v2) < 0:
-    #     del self.path[0]
-    # lens.append(len(self.path))
-    # del self.path[0]   
-    # lens.append(len(self.path))
-    # del self.path[0]    
-    # lens.append(len(self.path))
-    # print(lens, 'path length', v1.dot(v2))
+    #path2.append(self.target.obj.worldPosition) #add endpoint
+    #path2.append(self.target.obj.worldPosition) 
 
 def check_front(self):    #
-    #obj_vec = self.obj.worldOrientation[0].normalized()
     obj_vec = self.obj.getAxisVect([1,0,0])
     targ_vec = self.obj.getVectTo(self.path[self.path_index] +1)[1].normalized()
     dot_ = obj_vec.dot(targ_vec)
 
-    # while dot_ < 0:
-    #     del self.path[0]
-    #     targ_vec = self.obj.getVectTo(self.path[0])[1].normalized()
-    #     dot_ = obj_vec.dot(targ_vec)
     if dot_ > 0:
         print('in front', self)
     else:
     if dot_ > 0:
         return True
     else:
+        return False    
+
+def get_parking_type(self):
+    if self.target.type == 'perp':
+        self.FSM.FSM.ToTransition('toEnterPerpPark')
+    else:
+        self.FSM.FSM.ToTransition('toEnterParallelPark')
+
+def get_parking_point(self):
+    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
+
+    local = Vector([7,0,0])
+    return Vector(self.target.obj.worldPosition + (self.target.obj.worldOrientation * local))
+
+
+    #return Vector(self.target.obj.worldPosition) - 7 * tv
+
+def move_to_point(self):
+    #print(self.v_to_target[0])
+    if self.v_to_target[0] < .95:
+        #print('reached')
+        return True
+    else:
+        vectTo = Vector(self.v_to_target[1])
+        vectTo.magnitude = 4.01
+        self.FSM.owner.obj.linearVelocity = vectTo
         return False
-    #get starting pos
-    # v = Vector([path2[0].x - path2[1].x, path2[0].y - path2[1].y, 0])
-    # tv = v.normalized()
-    # nv = Vector([-tv.y, tv.x, 0])
-    # print('og', path2[0])
-    # path2[0] = path2[0] + -.2 * nv
-    # print('mod1', path2[0])
-    # #path2[0] *= nv
-    # print('mod2', path2[0])    
-    # self.path = path2    
+
+def forward_ray(self):
+
+    Axis = 0
+    Distance = 30
+    End = self.obj.worldPosition + (self.obj.worldOrientation.col[Axis]*Distance)
+    Start = self.obj.worldPosition.copy()
+    return self.obj.rayCast(End, Start, 10,'traffic', 1, 0, 0)
+    
+#dist = v1[0]
+#print(dist)    
 
 #====================================     
 
         self.FSM.owner.obj.restoreDynamics()
         self.FSM.owner.obj.linearVelocity = [0,0,0]
         self.FSM.owner.path_index = 1
-        get_lane_point(self.FSM.owner)
+        
         try:
             self.FSM.owner.point = self.FSM.owner.path[self.FSM.owner.path_index]
+            get_lane_point(self.FSM.owner)
         except:
             print('no path')    
         self.FSM.owner.target.status = 'targetted'
 
 #====================================  
             
+
+class ExitPerpPark(State):
+    def __init__(self,FSM):
+        super(ExitPerpPark, 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.path_index = 1
+        
+        try:
+            self.FSM.owner.point = self.FSM.owner.path[self.FSM.owner.path_index]
+            get_lane_point(self.FSM.owner)
+        except:
+            print('no path')    
+        self.FSM.owner.target.status = 'targetted'
+        self.FSM.owner.start_empty.status = 'available'
+        starting_mod(self.FSM.owner)
+        super(ExitPerpPark, self).Enter()        
+        
+    def Execute(self):
+        #print('exiting perp park', self.FSM.owner.start_empty.type)
+        self.FSM.stateLife += 1
+        set_height(self.FSM.owner)
+        if self.FSM.owner.path != []:
+            update_point(self.FSM.owner)
+            if self.FSM.owner.path_index > 1 or self.FSM.stateLife > 300:    
+                self.FSM.ToTransition('toNavigateToTarget')
+            
+
+            #align_to_point(self.FSM.owner, .65)
+            align_to_road(self.FSM.owner)
+            #set_height(self.FSM.owner)
+            #delta_to_vect(self.FSM.owner)
+            #apply_gas(self.FSM.owner, .5)  
+
+            if self.FSM.stateLife < 120:
+                self.FSM.owner.obj.applyForce([-50,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
+        
+        clear_markers(self)
+        super(EnterParallelPark, self).Enter() 
+
+    def cleanup(self):
         self.FSM.owner.obj.worldPosition = self.FSM.owner.target.obj.worldPosition.copy()
         self.FSM.owner.obj.worldOrientation = self.FSM.owner.target.obj.worldOrientation.copy()
         self.FSM.owner.obj.applyMovement([0, -6, 0], True)
         self.FSM.owner.point = self.FSM.owner.target.obj.worldPosition.copy()
         self.FSM.owner.path_index = 0
         self.FSM.owner.path = None
-        clear_markers(self)
-        super(EnterParallelPark, self).Enter()        
+
+        self.FSM.owner.manager.cars_active.remove(self.FSM.owner)
+        self.FSM.owner.obj.suspendDynamics()       
         
     def Execute(self):
         self.FSM.stateLife += 1
-        if self.FSM.stateLife == 2:
-            self.FSM.owner.manager.cars_active.remove(self.FSM.owner)
-            self.FSM.owner.obj.suspendDynamics()
+        if self.FSM.stateLife == 240:
+            self.cleanup()    
             #self.FSM.owner.obj.suspendPhysics()
     def Exit(self):
         pass
 
+class EnterPerpPark(State):
+    def __init__(self,FSM):        
+        super(EnterPerpPark, self).__init__(FSM)    
+
+    def Enter(self):
+        self.FSM.stateLife = 1
+        self.park_loc = get_parking_point(self.FSM.owner)
+        single_marker(self.park_loc, [1,0,0,.3])
+
+        clear_markers(self)
+        super(EnterPerpPark, self).Enter()     
+
+    def cleanup(self):
+        self.FSM.owner.obj.worldPosition = self.FSM.owner.target.obj.worldPosition.copy()
+        self.FSM.owner.obj.worldOrientation = self.FSM.owner.target.obj.worldOrientation.copy()
+        self.FSM.owner.obj.applyMovement([7, 0, 0], True)
+        self.FSM.owner.target.status = 'in_use'
+        self.FSM.owner.obj.worldPosition.z += .9
+        self.FSM.owner.active = False
+        self.FSM.owner.start_empty = self.FSM.owner.target
+        self.FSM.owner.last_point = self.FSM.owner.target.obj.worldPosition.copy()
+        self.FSM.owner.lane_point = self.FSM.owner.target.obj.worldPosition.copy()
+        self.FSM.owner.last_lane_point = self.FSM.owner.target.obj.worldPosition.copy()
+        self.FSM.owner.point = self.FSM.owner.target.obj.worldPosition.copy()
+        self.FSM.owner.path_index = 0
+        self.FSM.owner.path = None
+
+        self.FSM.owner.manager.cars_active.remove(self.FSM.owner)
+        self.FSM.owner.obj.suspendDynamics()       
+        
+    def Execute(self):
+        self.FSM.stateLife += 1
+
+        self.v_to_target = self.FSM.owner.obj.getVectTo(self.park_loc)
+
+        goal_met = move_to_point(self)
+        set_height(self.FSM.owner)
+        if self.v_to_target[0] > 2:
+
+            align_to_target(self.FSM.owner, .65)
+
+        else:
+            self.FSM.owner.obj.alignAxisToVect(-self.FSM.owner.target.obj.worldOrientation[0], 0, .05)
+
+        if self.FSM.stateLife == 440 or goal_met:
+            self.cleanup()    
+            #self.FSM.owner.obj.suspendPhysics()
+
+    def Exit(self):
+        pass        
+
 #==================================== 
 
 class NavigateToTarget(State):
         
     def Execute(self):
         self.FSM.stateLife += 1
+        self.forward_ray = forward_ray(self.FSM.owner)
         update_point(self.FSM.owner)
 
         align_to_point(self.FSM.owner, 1)
         align_to_road(self.FSM.owner)
         set_height(self.FSM.owner)
         delta_to_vect(self.FSM.owner)
-        apply_gas(self.FSM.owner, 1)
+        gas = True
+        if self.forward_ray[0]:
+            
+            dist = self.FSM.owner.obj.getDistanceTo(self.forward_ray[1])
+            if dist < 10:
+                gas = False
+                self.FSM.owner.obj.linearVelocity.x *= .98
+            print(dist, 'forward ray', self.forward_ray[0])
+        
+        if gas:
+            apply_gas(self.FSM.owner, 1)
 
         #emergency exit
         if self.FSM.stateLife > 30 * 90:
-            self.FSM.ToTransition('toEnterParallelPark')
+            get_parking_type(self.FSM.owner)
+            #self.FSM.ToTransition('toEnterParallelPark')
 
     def Exit(self):
         pass        

scripts/astar.py

         self.life += 1
         if self.state == 'searching':
             self.search()
-            if self.life > 3000:
+            print('open', len(self.open))
+            if self.life > 2000:
                 print('path failed', self.current_searcher)
+                self.messenger.dispatch('path found', ['failed', self.current_searcher, []])
                 self.state = 'idle'
+
         else:
             self.update_queue()        
              
                 break
         results.reverse()
         self.messenger.dispatch('path found', ['path', self.current_searcher, results])
-        print('path found', self.current_searcher)
+        #print('path found', self.current_searcher)
 
     def smallest_f(self):
-        if len(self.open) > 1:
+        if len(self.open) >= 1:
             l = []
             lfs = []
             for x in self.open:

scripts/camera.py

 import FSM
 import cars
 import walkers
+import occluders
 
 def main(cont):
     own = cont.owner
         #own['NpcPedFSM'] = FSM.NpcPed(own)
         own['CamFSM'] = FSM.CameraFSM(own)
         own['life'] = 0
+        occluders.place()
     acam = scene.active_camera
 
     def get_cam_state():
     else:
         pass
 
-    own['life'] += 1
+    own['life'] += 1
+
+    # mo = scene.objects['Suzanne']
+    # print(mo.culled)
+
+    # if dict['kb_a'] == True and dict['last_kb_a'] == False:
+        
+    #     if scene.active_camera == scene.objects['tmp_cam2']:
+    #         scene.active_camera = scene.objects['tmp_cam']
+    #         print('change cam tmp', scene.active_camera)
+    #     else:
+    #         scene.active_camera = scene.objects['tmp_cam2']
+
+    #         print('change cam og', scene.active_camera)

scripts/cars.py

 	for obj in bge.logic.getCurrentScene().objects:
 		if 'parking' in obj:
 			ps = ParkingSpot(obj, 'available')
+			if 'perp' in obj:
+				ps.type = 'perp'
+			else:
+				ps.type = 'parallel'
 			op.append(ps)
 	return op
 
 	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)
+	if x.type == 'perp':
+		car.applyMovement([7, 0, 0], True)
+	else:
+		car.applyMovement([0, -6, 0], True)
 	car.suspendDynamics()
 	#car.suspendPhysics()	
 	car.name = 'lcar' + str(len(self.manager.cars))
 class ParkingSpot:
 	def __init__(self, obj, status):
 		self.obj = obj
+		self.type = None
 		self.status = status
 
 class Car:
 		if self == message[1]:
 			self.path = message[2]
 			if self.path != []:
-				self.FSM.FSM.ToTransition('toExitParallelPark')
+				print(self.start_empty.type, 'target type')
+				if self.start_empty.type == 'perp':
+					self.FSM.FSM.ToTransition('toExitPerpPark')
+				else:
+					self.FSM.FSM.ToTransition('toExitParallelPark')
+					print('setting goal available after failure', self.FSM.owner.target.obj.worldPosition)
+					self.FSM.owner.target.status = 'available'
 			else:
 				print('path failed for', self)
-				self.FSM.FSM.ToTransition('toEnterParallelPark')	
+				self.FSM.FSM.ToTransition('toEnterParallelPark')
+
 		
 class CarManager:
 	def __init__(self, own):
 		self.pub = observer.Publisher(['path found', 'working'])
 		self.navmesh2 =  astar.Astar('nav_points', self.pub)
 		self.cars = []
-		self.max_cars = 6
-		self.max_active = 4
+		self.max_cars = 10
+		self.max_active = 6
 		self.targets = []
 		self.target_loc = None
 		self.parking_spots = get_parking_spots()

scripts/occluders.py

+import bge
+
+def place():
+	scene = bge.logic.getCurrentScene()
+	for x in scene.objects:
+		if 'occluder_tmp' in x.name:
+			print('place occluder')
+			o = scene.addObject('occluder_obj', x)
+			o.worldOrientation = x.worldOrientation
+			o.worldScale = x.worldScale
+			x.endObject()

scripts/walkers.py

 		self.pub = observer.Publisher(['path found', 'working'])
 		self.navmesh2 =  astar.Astar('walker_nav_points', self.pub)
 		self.walkers = []
-		self.max_walkers = 16
-		self.max_active = 8
+		self.max_walkers = 5
+		self.max_active = 3
 		self.targets = []
 		self.target_loc = None
 		self.idle_spots = get_idle_spots()

shuvit23.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:c7a95ab819b4cb0ae5c46b4662e8f139e79f02cec48ad8a5240e7b2a584897e4
+size 120592856

shuvit23a1.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:92c47d52d95b1b4c39d8d821202a6bce8fceaa2f73cbce02dfe9e6e1dcb545a0
+size 67591136