cars2

assets/roads_bak.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:784809674b518a6435240657168d882fc30d0dace8f4fdd643ecc4dc0189b4e4
+size 83642732

characters/annie_actions.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:79b18251c91fea0da8010ccbc3999a6038753731fcd1707eedc026af6fdce1a8
+size 12021164

characters/annie_actions1.blend

+version https://git-lfs.github.com/spec/v1
+oid sha256:04b45c642e23d76d6526d7f4da8fb61ee1c2b6a48ae95cf4228647cf0bd122f8
+size 12504512

scripts/StatesCar.py

 
 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_]    
         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()
         self.FSM.FSM.ToTransition('toEnterParallelPark')
 
 def get_lane_point(self):
-
-
     self.point = self.path[self.path_index]
-    #print(self.path_index, 'path index')
     if self.point != self.last_lane_point:
         v = Vector([self.last_lane_point.x - self.point.x, self.last_lane_point.y - self.point.y, 0])
         tv = v.normalized()
         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]
 
 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)
     f = deltamove * 5000
     self.obj.applyForce([0, f, 0], True)
             
     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
 
         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):
-        
+    def __init__(self,FSM):        
         super(EnterParallelPark, self).__init__(FSM)    
         
     def Enter(self):
         self.FSM.stateLife += 1
         if self.FSM.stateLife == 2:
             self.FSM.owner.manager.cars_active.remove(self.FSM.owner)
-        #self.FSM.ToTransition('toActivate')
-        
 
     def Exit(self):
         pass
         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 > 30 * 60:
             self.FSM.ToTransition('toEnterParallelPark')
 
-        #print('doing NavigateToTarget')
-
-        #self.FSM.owner.obj.applyForce([6, 0, 0], True)
-
     def Exit(self):
         pass        
 
         
     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:
             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:
     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