Esempio n. 1
0
 def data_dump(self, file_path=None):
     """Dumps data for debugging purposes"""
     
     data = []
     
     data.append("Tick: %d" % self.tick)
     
     data.append("\n**** Actors ****")
     for a in self.actors:
         data.append("\nAID: %s, ID: %s" % (a.oid, str(a)))
         data.append("team: %s" % a.team)
         data.append("pos: %s" % a.pos)
         data.append("rect: %s" % a.rect)
         data.append("velocity: %s" % a.velocity)
     
     data.append("\n**** Collisions **** ")
     data.append(str(sim_lib.get_collisions(self.actors)))
     
     data = "\n".join(data)
     
     # Output
     if file_path == None:
         print(data)
         print("")
     else:
         with open(file_path, "w") as f:
             f.write(data)
Esempio n. 2
0
 def logic_cycle(self):
     """The core function of the sim, this is where the 'magic happens'"""
     if int(time.time()) != self.cycle_count[1]:
         self.cycle_count = [0, int(time.time())]
     
     self.next_ai_update -= 1
     if self.next_ai_update <= 0:
         self.update_ai_queues()
         self.next_ai_update = 30
     
     self.read_ai_queues()
     
     self.tick += 1
     
     self.orders[self.tick + self.tick_jump] = []
     self.q_orders[self.tick + self.tick_jump] = []
     self.issue_orders()
     
     # This will warn us if the sim is lagging behind how fast it's meant to be
     time_over = time.time() - self.next_cycle
     if time_over > 0.25:
         print("Logic lag of %ss" % time_over)
     
     # Update the AIs
     for t, a in self.autotargeters.items():
         a.update()
     
     # Update the actors themselves
     to_remove = []
     to_add = []
     for i, a in enumerate(self.actors):
         # First we need to check to see if it's got a build order
         # it'd have one because the AI can't directly tell us
         # to build something and instantly be told what the building
         # item is, thus we place it here and automatically tell
         # the actor to go build it
         if a.current_order[0] == "build" and a.completion >= 100:
             cmd, pos, type_name = a.current_order
             
             # Should this be done via a build queue instead?
             if self.actor_types[a.actor_type]['uses_build_queue']:
                 a.build_queue.append(type_name)
                 
             else:
                 a_type = self.actor_types[type_name]
         
                 new_rect = pygame.Rect(pos[0], pos[1], a_type['size'][0], a_type['size'][1])
                 building_rect = ai_lib.place_actor(self.actors, new_rect, [50, 100, 200], self.battlefield['size'])
                 
                 if building_rect != None:
                     posx = building_rect.left + building_rect.width/2
                     posy = building_rect.top + building_rect.height/2
             
                     to_add.append((a, {
                         "type": type_name,
                         "pos":  [posx, posy, 0],
                         "team": a.team,
                         "order_queue": list(a.rally_orders),
                     }))
             
             a.next_order()
         
         a.update()
         
         # Is the actor trying to place a new unit?
         # We only check as often as we check for collisions, this gives a cycle
         # for an already started actor to be given a position as it defaults to 0,0
         # and this has an impact on it's rect
         if self._collision_inverval_count < 2:
             if a.build_queue != [] and a.completion >= 100:
                 a_type = self.actor_types[a.build_queue[0]]
                 
                 new_rect_pos = vectors.add_vectors(a.pos, a.build_offset)
                 new_rect = pygame.Rect(new_rect_pos[0], new_rect_pos[1], a_type['size'][0], a_type['size'][1])
             
                 if not sim_lib.test_possible_collision(self.actors, new_rect):
                     to_add.append((a, {
                         "type": a.build_queue[0],
                         "pos":  new_rect_pos,
                         "team": a.team,
                         "order_queue": list(a.rally_orders),
                     }))
                     self.signal_menu_rebuild = True
                     del(a.build_queue[0])
         
         if a.hp <= 0: to_remove.insert(0, i)
     for i in to_remove: del(self.actors[i])
     for builder, new_actor in to_add:
         new_target = self.place_actor(new_actor)
         builder.issue_command("aid", target=new_target)
     
     # Bullets too
     to_delete = []
     for i, b in enumerate(self.bullets):
         b.update()
         
         if b.dead:
             new_effect = b.explode(self.actors)
             if new_effect != None:
                 self.effects.append(new_effect)
             to_delete.insert(0, i)
     for i in to_delete:
         del(self.bullets[i])
     
     # And lastly effects
     to_delete = []
     for i, e in enumerate(self.effects):
         e.update()
         if e.dead:
             to_delete.insert(0, i)
             continue
     
     # Delete any uneeded effects
     for i in to_delete:
         del(self.effects[i])
     
     # Check for collisions
     self._collision_inverval_count -= 1
     
     if self._collision_inverval_count < 1:
         self._collision_inverval_count = self._collision_interval
         collisions = sim_lib.get_collisions(self.actors)
         
         # We now have a list of all the collisions
         for obj1, obj2 in collisions:
             # We order them based on aid, this way we always deal with the same
             # actor in the same way and the order the collison was found is
             # irrelevant
             actor_lib.handle_pathing_collision(min(obj1, obj2), max(obj1, obj2))
     
     # Set next cycle time
     self.next_cycle = time.time() + self._cycle_delay
     self.cycle_count[0] += 1
Esempio n. 3
0
 def logic_cycle(self):
     """The core function of the sim, this is where the 'magic happens'"""
     if int(time.time()) != self.cycle_count[1]:
         self.cycle_count = [0, int(time.time())]
     
     self.tick += 1
     
     self.orders[self.tick + self.tick_jump] = []
     self.q_orders[self.tick + self.tick_jump] = []
     self.issue_orders()
     
     # This will warn us if the sim is lagging behind how fast it's meant to be
     time_over = time.time() - self.next_cycle
     if time_over > 0.25:
         print("Logic lag of %ss" % time_over)
     
     # Update the AIs
     for t, a in self.ais.items():
         a.update()
     
     # Update the actors themselves
     to_remove = []
     for i, a in enumerate(self.actors):
         a.update()
         
         if a.hp <= 0: to_remove.insert(0, i)
     for i in to_remove: del(self.actors[i])
     
     # Bullets too
     to_delete = []
     for i, b in enumerate(self.bullets):
         b.update()
         
         if b.dead:
             new_effect = b.explode(self.actors)
             if new_effect != None:
                 self.effects.append(new_effect)
             to_delete.insert(0, i)
     for i in to_delete:
         del(self.bullets[i])
     
     # And lastly effects
     to_delete = []
     for i, e in enumerate(self.effects):
         e.update()
         if e.dead:
             to_delete.insert(0, i)
             continue
     
     # Delete any uneeded effects
     for i in to_delete:
         del(self.effects[i])
     
     # Check for collisions
     self._collision_inverval_count -= 1
     
     if self._collision_inverval_count < 1:
         self._collision_inverval_count = self._collision_interval
         collisions = sim_lib.get_collisions(self.actors)
         
         # We now have a list of all the collisions
         for obj1, obj2 in collisions:
             # We order them based on aid, this way we always deal with the same
             # actor in the same way and the order the collison was found is
             # irrelevant
             actor_lib.handle_pathing_collision(min(obj1, obj2), max(obj1, obj2))
     
     # Set next cycle time
     self.next_cycle = time.time() + self._cycle_delay
     self.cycle_count[0] += 1