cleaning

scripts/StatesCar.py

     for x in potentials:
         min_dist = 45
         dist = self.obj.getDistanceTo(x.obj)
-        #print('dist to potential', dist)
         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)
         path2 = self.manager.navmesh2.queue_path(self.start_empty.obj.worldPosition, new_parking.obj.worldPosition, self)
-        #print('parking added at', new_parking.obj.worldPosition)
-        #path.remove(path[0])
-        #mark_path(path, self)
         return new_parking, path2
     else:
-        #print('cant find parking for', self)
         self.FSM.FSM.ToTransition('toEnterParallelPark')
 
 def get_lane_point(self):
         self.lane_point = self.point + self.manager.lane_position * nv
     else:
         pass
-        #print('skipping lane point')
 
 def update_point(self):
-    #print(self.path_index, 'path index', len(self.path))
     if self.path_index >= (len(self.path) ):
         self.FSM.FSM.ToTransition('toEnterParallelPark')
     else:
                 self.path_index += 1
          
 def align_to_point(self):
-    #print('lane_point', self.lane_point)
     v = self.obj.getVectTo(self.lane_point)[1]
     v.z = 0
     self.obj.alignAxisToVect(v, 0, .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'
-        #mark_path(self.FSM.owner.path, self.FSM.owner)
-        print('physics resumed')
         super(ExitParallelPark, self).Enter()        
         
     def Execute(self):
         
     def Enter(self):
         self.FSM.stateLife = 1
-        #print('entering parallel park')
         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
-        #print('clearning last path')
-        
         clear_markers(self)
-        
-        #self.FSM.owner.obj.suspendDynamics()
-        #self.FSM.owner.obj.suspendPhysics()
         super(EnterParallelPark, self).Enter()        
         
     def Execute(self):
 
     def drive_to_point(self):
         pass
-        # 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 - 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
         
     def Enter(self):
         self.FSM.stateLife = 1
-
         self.FSM.owner.target, self.FSM.owner.path = find_new_parking(self.FSM.owner)
         self.FSM.owner.path_index = 0
         super(RequestPath, self).Enter()        
         
     def Execute(self):
         self.FSM.stateLife += 1
-        #own['ped_astar'] = Astar('nav_points')
-        #own['ped_astar'].get_path([5,-12,1] , [16,16,1])
-        #print('doing example')
         
     def Exit(self):
         pass

scripts/StatesWalker.py

             x.endObject()
         except:
             pass
+            
 def get_ground_ray(self):
     Axis = 2
     Distance = -10
     for x in potentials:
         min_dist = 45
         dist = self.obj.getDistanceTo(x.obj)
-        #print('dist to potential', dist)
         if dist < min_dist:
             potentials.remove(x)
-            #print('----removing potential')
-    if len(potentials) > 0:
 
+    if len(potentials) > 0:
         new_parking = random.choice(potentials)
-        #path = self.manager.navmesh.findPath(self.start_empty.obj.worldPosition, new_parking.obj.worldPosition)
         path2 = self.manager.navmesh2.queue_path(self.start_empty.obj.worldPosition, new_parking.obj.worldPosition, self)
-        #print('parking added at', new_parking.obj.worldPosition)
-        #path.remove(path[0])
-        #mark_path(path, self)
         return new_parking, path2
     else:
-        #print('cant find parking for', self)
         self.FSM.FSM.ToTransition('toEnterParallelPark')
 
 def get_lane_point(self):
         self.lane_point = self.point + self.manager.lane_position * nv
     else:
         pass
-        #print('skipping lane point')
 
 def update_point(self):
-    #print(self.path_index, 'path index', len(self.path))
     if self.path_index >= (len(self.path) ):
         self.FSM.FSM.ToTransition('toEnterParallelPark')
     else:
                 self.path_index += 1
          
 def align_to_point(self):
-    #print('lane_point', self.lane_point)
     v = self.obj.getVectTo(self.lane_point)[1]
     v.z = 0
     self.obj.alignAxisToVect(v, 0, .1)
         f *= -1
     self.obj.applyForce([0, f, 0], True)
             
-              
 def apply_gas(self):
     if self.obj.linearVelocity.x < self.speed_targ:
         self.obj.applyForce([self.speed_inc, 0, 0], True)
         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'
-        #mark_path(self.FSM.owner.path, self.FSM.owner)
         print('physics resumed')
         super(ExitParallelPark, self).Enter()        
         
         
     def Enter(self):
         self.FSM.stateLife = 1
-        #print('entering parallel park')
         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, 0, 0], True)
         self.FSM.owner.point = self.FSM.owner.target.obj.worldPosition.copy()
         self.FSM.owner.path_index = 0
         self.FSM.owner.path = None
-        #print('clearning last path')
-        
-        clear_markers(self)
-        
-        #self.FSM.owner.obj.suspendDynamics()
-        #self.FSM.owner.obj.suspendPhysics()
         super(EnterParallelPark, self).Enter()        
         
     def Execute(self):
         delta_to_vect(self.FSM.owner)
         apply_gas(self.FSM.owner)
 
-        #emergency exit
         if self.FSM.stateLife > 30 * 180 * 3:
             self.FSM.ToTransition('toEnterParallelPark')
 
 
     def drive_to_point(self):
         pass
-        # 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 - 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
 
         
     def Execute(self):
         self.FSM.stateLife += 1
-        #own['ped_astar'] = Astar('nav_points')
-        #own['ped_astar'].get_path([5,-12,1] , [16,16,1])
-        #print('doing example')
-        
+
     def Exit(self):
-        pass

scripts/astar.py

         return value
     return wrapper
 
-def draw(locs, self):
-    for x in locs:
-        b = bge.logic.getCurrentScene().addObject('ball')
-        b.worldPosition = self.points[x].loc
-        b.color = [1,0,0,1]
-        
-def draw_mesh(self):
-    self.searched = set(self.searched)
-    for x in self.searched:
-        b = bge.logic.getCurrentScene().addObject('ball')
-        b.worldPosition = x.loc
-        b.color = [0,0,1,1]
-        b.worldScale = [.5, .5, .5] 
-    
-def draw_searched(self):
-    pass
-
-def draw_se(self):        
-    b = bge.logic.getCurrentScene().addObject('ball')
-    b.worldPosition = self.start.loc
-    b.color = [0,1,0,1]
-    b.worldScale = [.75, .75, .75] 
-    #----    
-    b = bge.logic.getCurrentScene().addObject('ball')
-    b.worldPosition = self.end.loc
-    b.color = [1,1,0,1]
-    b.worldScale = [2, 2, 2]  
-
 def draw_all(self):
     for x in self.points:
-
         pm = bge.logic.getCurrentScene().addObject('path_marker')
         pm.worldPosition = x.loc
         pm.color = [1,1,0,1]
         return iter(cls._registry)
 
 def load_points(points_file):        
-    #mainDir = bge.logic.expandPath("//")
     mainDir = bge.logic.expandPath("//assets/")
     fileName = mainDir + points_file    
     with open(fileName, 'r') as filehandle:        
     length = (end - start).magnitude
     return length
 
-
-
 class Point(object):
     __metaclass__ = IterRegistry
     _registry = []
         self.life += 1
         if self.state == 'searching':
             self.search()
-            #print('life', self.life)
             if self.life > 5000:
-                #print('path failed')
                 self.state = 'idle'
         else:
-            #print('updating pathfinder queue')
             self.update_queue()        
              
     def get_results(self):
         result_locs = []
         results = []
-        #print('self.end', self.end, self.end.id)
         cp = self.end   
         breaker = 0
         while cp != self.start:
                 cp = cp.prev
             breaker += 1
             if breaker > 2000:
-                #print('breaking results')
                 break
-        #if cp == self.start:
-            #print('start found!!')
-        #print('sp', self.start.id, 'ep', self.end.id)
-        #print('final path', result_locs, len(result_locs)) 
-        #draw_mesh(self)
-        #draw(result_locs, self)  
-        #publish
         results.reverse()
         self.messenger.dispatch('path found', ['found path for object', self.current_searcher, results])
-        #draw_all(self)
 
     def smallest_f(self):
         if len(self.open) > 1:
                 l.append(x)
                 lfs.append(x.f)
             ind = lfs.index(min(lfs))  
-            #print(ind, lfs, l[ind]) 
             return l[ind]
         else:
             return self.start
             
     #@chrono    
     def search(self):
-        #Loop until you find the end
         tries = 0
         if self.open == []:
-            draw_mesh(self)
             self.state = 'inactive'
 
         while self.open != []:
-            #Get the current node from open list with smallest fval
             try:
                 self.open.remove(self.current)
             except:
                 pass
-                #print('current is not in open, cant remove')
             current_node = self.smallest_f()
             self.current = current_node
             self.searched.append(current_node)
-             #remove from open
             self.closed.append(current_node) #add to closed
             if current_node == self.end:
-                #print('path found')
                 path = self.get_results()
-                #print('p', path)
                 self.state = 'inactive'
                 self.open = []
                 break                
+
             else:
                 children = current_node.neighbors
                 for child in children:
                         self.closed[:] = [x for x in self.closed if x != child]    
                         self.open.append(child)
 
-#            print('trying', current_node.id, current_node.f, len(self.open))
-#            nei = []
-#            for z in current_node.neighbors:
-#                nei.append(z.id)
             tries += 1
             if tries >= 5:
                 break                      
                 num = iter
             else:
                 pass
-                #print('cant get navmesh neighbor id')    
             iter += 1    
-        #print(num, 'id')
         
     def set_gscore(self):
         self.gscores = []
 
     def queue_path(self, start_in, end_in, obj):
         self.queue.append([start_in, end_in, obj])
-        #obj.manager.pub.register("path found", obj)
-        #print('queueing path', len(self.queue))
 
     def update_queue(self):
         if self.queue != []:
-            #print('--getting next path in queue')
             self.get_path(self.queue[0][0], self.queue[0][1], self.queue[0][2])
             self.queue.remove(self.queue[0])           
                          
         self.open.append(self.start)
         self.set_gscore()
         self.current = self.start
-        #beginning search
-        #Initialize both open and closed list
         self.open = []
         self.closed = []
         self.searched = []
-
-        #Add the start node
         self.open.append(self.start)
         self.current = self.start
         self.current.g = 0
         self.current.f = 0
         self.current.h = get_distance(self.current.loc, self.end.loc)
-        #draw_se(self)
-        print('start', self.start.id, 'end', self.end.id)
-        
-# def main(cont):
-#     own = cont.owner
-#     if 'inited' not in own:
-#         own['inited'] = True
-#         own['ped_astar'] = Astar('nav_points')
-#         own['ped_astar'].get_path([5,-12,1] , [16,16,1])
-        
-#     own['ped_astar'].update()
-
+        

scripts/birds.py

 import bge
 import random
 
-
-        
 def bird(cont):
     own = cont.owner
     if 'inited' not in own:
         act.target = own['end']
         act.velocity = 2
         cont.activate(act)
-        #print('doing bird')
     if own.getDistanceTo(own['end']) < 1:
         own.endObject()
-        #print('kill bird') 
 
 def main(cont, scene):
-
     def build_bird_list(scene,own):
         own['bird_list'] = []
         for x in scene.objects:
             if own['life'] % 50 == 0:
                 num = random.randint(0,2)
                 if num == 1:
-                    #print('add bird')
                     top = len(own['bird_list']) - 1
                     start = random.randint(0, top)
                     end = start
                     obj['start'] = own['bird_list'][start]
                     obj['end'] = own['bird_list'][end]
                     obj.worldPosition = obj['start'].worldPosition
-                    #print(obj['start'], obj['end'])
                 
     def life(own):
         if 'life' in own:
         else:
             own['life'] = 0    
         
-  
-
     own = cont.owner
     if 'binited' not in own:
         build_bird_list(scene, own)            
         own['binited'] = True
 
     life(own)    
-    do_birds(scene, own, cont)  
-    #print('birding')    
+    do_birds(scene, own, cont)  

scripts/camera.py

 import walkers
 
 def main(cont):
-    #camFSM.main(cont)
     own = cont.owner
     dict = bge.logic.globalDict
     camempty = scene.objects['camEmpty.001']
             dict['cam_state'] = 'driving'
         else:
             dict['cam_state'] = 'RollCam'   
-        #print(dict['cam_state'])             
-
 
     if controlcube['driving'] == False:
         LAST_GRIND = False
             camempty['hitdown'] = False
             if cam_height > (cam_def_height + .08) and zdist > -.2 and raised == 0:
                 cam.height = cam_height - .02
-                #print('raising a')
+
         if cam_height < -.6 and cam_moved == 0 and LAST_GRIND == False and zdist > -.2 and raised == 0 and walk == 0:
             cam_height = .1
-            #print('raising b')
         if LAST_GRIND == True and walk == 0:
             if cam.height < -.5 or zdist < -.2:
                 cam.height = cam.height + .013
-                #print('raising c')
             if cam.height >= -.5 and not down.triggered:
                 pass
 
         controlcube['lastCamheight'] = cam.height
-        #activating######
         cont.activate(own.actuators['Camera'])
-        #################
+
         if near.triggered == True and walk == 0:
-            #print("near")
             if cam.min < 1:
                 cam.min = cam.min + .1
                 cam.max = cam.max + .1
             cam.height = cam_height + .01
-            print('moving cam up')
             cam.damping = .001
             cont.activate(move)
 
         else:
-            #print("far")
             cont.deactivate(move)
             if cam.min > cam_def_min:
                 cam.min = cam.min - .05
         hitobj = str(hitobj)
         
         if hit[0]:
-            #if hitobj != control and walk == 0 and 'vert' not in hit[0] and 'ground' in hit[0] and controlcube['ragdoll_active'] == False:
             if hitobj != control and walk == 0 and 'vert' not in hit[0] and 'ground' in hit[0]:
                 cam.damping = .01
                 if cam.height < 2:
                     cam.height = cam_height + .1
                     cam.max = cam.max - .2
-                    #print('small move', cam.height, dict['cam_height'])
                 elif cam.height >= 2 and cam.height < 4:
                     cam.height = cam_height + .05
                     cam.max = cam.max - .05
-                    #print('big move')
 
     if dict['menu_idle_timer'] > 300:
         move_len = 2048
             if dict['cur_ccH_targetHeight'] < dict['cch_targetHeight'] + .001:
                 dict['cur_ccH_targetHeight'] = dict['cch_targetHeight']
 
-
     ccH_targetHeight = dict['cur_ccH_targetHeight']
-
     ccH = camCube.worldPosition.z
     pH = camCube.parent.worldPosition.z
     ccheight = (round((ccH - pH), 2) - .4)
-
     localPos = camCube.localPosition.z
+
     if localPos != ccH_targetHeight:
         num = ccH_targetHeight - localPos
         camCube.localPosition.z += num
-    #if camHeightSet not in own:
-    #if 1 == 1:
     num = ccH_targetHeight - ccheight
-    #else:
-        #own['camHeightSet'] = True
+
     try:
         if dict['npause'] == False and controlcube['ragdoll_active'] == False:
             cont.activate(own.actuators['Camera'])
             controlcube['camera'] = 0
         if controlcube['ragdoll_active'] == True:
-            #print('ragdoll_camera', own.actuators['Camera'].object)
             own.actuators['Camera'].object = scene.objects['ragdoll_parent']
             cont.activate(own.actuators['Camera'])
             controlcube['camera'] = 0
             cam.max = new_max
         except:
             pass
-    #print(own.actuators['Camera'].object)        
+
     set_lens_dist()        
     get_cam_state()
     camFSM.main(cont)
     birds.main(cont, scene)
     sound_man.main(cont)
     
-    #own['NpcPedFSM'].Execute()
     if own['life'] % 2 == 1:
         cars.Execute(cont)
         own['CamFSM'].Execute()
-        #print('doing')
         walkers.Execute(cont)
 
     else:

scripts/cars.py

 			x['in_use'] = False
 			print('this is a parking spot')
 			output = True
-	
 	return output
 			
 
 	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
 		y.color = color
 	print('setting car color to ', car.color)
 	x.status = 'in_use'
-
-
 	return car
 
 #====================================  
 		self.path = None
 		self.path_index = 0
 		self.path_display = []
-		#self.messages = observer.Subscriber(self)
 		self.manager.pub.register("path found", self)
 
 	def Execute(self):
 		self.life += 1
 
 	def ReceiveMessage(self, message):
-		#print('{} got message "{}"'.format(self, message))	
 		if self == message[1]:
-			#print('unregistering observer')
-			#print(message[2])
 			self.path = message[2]
 			self.FSM.FSM.ToTransition('toExitParallelPark')
-			
-			#self.manager.pub.unregister("path found", self)
-		#self.manager.pub.unregister("path found", self)	
-
+		
 class CarManager:
 	def __init__(self, own):
 		self.parent = own
 		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 = 8.0#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.append(car_)	
 			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:
 			self.cars_active.append(car)
 			car.active = True
 			car.FSM.FSM.ToTransition('toRequestPath')
-			#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 % 120 == 0:
-
 				self.activator_check()
 
 			for car in self.cars_active:
 				car.Execute()
-				#print(car, 'is an acitve car')
-			self.navmesh2.update()
-			#print('updating navmesh from cars')	
-			
+			self.navmesh2.update()			
 
 		else:
 			self.load_cars()
-			print('------------calling load cars')
-
-		# if self.life == 400:
-		# 	self.pub.dispatch('path found', 'found path for object')
-		# 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:

scripts/walkers.py

 		if 'walker_idle_empty' in x.name:
 			self.idle_spots.append(x)
 			x['in_use'] = False
-			#print('this is a parking spot')
 			output = True
-	
 	return output
 			
 
 	return op		
 
 def add_walker(self, x):
-	#print('put car here', x.obj.worldPosition)
 	walker = bge.logic.getCurrentScene().addObject('larryCube', x.obj, 0)
 	walker.worldOrientation = x.obj.worldOrientation
 	walker.worldPosition.z += .8
-	#car.applyMovement([0, -6, 0], True)
-	#car.suspendDynamics()
-	#car.suspendPhysics()	
-
 	walker.name = 'lwalker' + str(len(self.manager.walkers))
-	#color = random.choice(car_colors)
-	#walker.color = color
-	#for y in car.children:
-		#y.color = color
-	#print('setting car color to ', car.color)
 	x.status = 'in_use'
 
-
 	return walker
 
 #====================================  
 		self.path = None
 		self.path_index = 0
 		self.path_display = []
-		#self.messages = observer.Subscriber(self)
 		self.manager.pub.register("path found", self)
 
 	def Execute(self):
 		self.life += 1
 
 	def ReceiveMessage(self, message):
-		#print('{} got message "{}"'.format(self, message))	
 		if self == message[1]:
-			#print('unregistering observer')
-			#print(message[2])
 			self.path = message[2]
 			self.FSM.FSM.ToTransition('toExitParallelPark')
-			
-			#self.manager.pub.unregister("path found", self)
-		#self.manager.pub.unregister("path found", self)	
 
 class WalkerManager:
 	def __init__(self, own):
 		self.targets = []
 		self.target_loc = None
 		self.idle_spots = get_idle_spots()
-		#self.intersections = get_intersections()
-		#self.active = car_run_check(self)
 		self.active = True
 		self.walkers_active = []
 		self.walkers_loaded = False
-		#self.max_active = 5
 		self.life = 0
 		self.default_speed = 1.0#5.0
 		self.lane_position = 0.5#1.75
-		
-		    
-
 
 	def load_walkers(self):
 		iter_ = 0
-		#look for car in scene
 		if 'larryCube' in bge.logic.getCurrentScene().objectsInactive:
-
 			start_choices = self.idle_spots.copy()
 			while len(self.walkers) < self.max_walkers:
 				#get starting position
 				start_choice = random.choice(start_choices)
 				start_choices.remove(start_choice)
 
-				#add_car(self, start_choice.worldPosition)
 				walker_ = Walker(self, start_choice)
 				self.walkers.append(walker_)
 
 			mainDir = bge.logic.expandPath("//npc_walkers/")
 			npc = 'larry'
 			fileName = mainDir + str(npc) + '.blend'    
-			
 			path = bge.logic.expandPath(fileName)
 			print('loading npc')
 			try:
-				#bge.logic.LibLoad(path, 'Scene') 
 				bge.logic.LibLoad(fileName, 'Scene') 
 				print('larry loaded')
 			except Exception as e:
 			self.walkers_active.append(walker)
 			walker.active = True
 			walker.FSM.FSM.ToTransition('toRequestPath')
-			#state
-			print('activate walker', walker)
 
 	def update(self):
-		#print('car_manager_updating')
 		self.life += 1
 		if self.walkers_loaded:
-			#check i f new car should be active
 			if self.life % 180 == 0:
-
 				self.activator_check()
 
 			for walker in self.walkers_active:
 				walker.Execute()
-				#print(car, 'is an acitve car')
 			self.navmesh2.update()
-			#print('updating navmesh from cars')	
-			
 
 		else:
 			self.load_walkers()
-			print('------------calling walkers')
 
 def Execute(cont):
 	own = cont.owner
 	if 'walker_manager' not in own:
 		own['walker_manager'] = WalkerManager(own)
 	walker_man = own['walker_manager']	
-	#print('running walkers')
 	if walker_man.active:
 
 		walker_man.update()