Esempio n. 1
0
  def fitness(self, logical_swarm_pos, phys_swarm):
      #account for own health, enemy health/splash&anti air damage/
      # upgrade this function...
      # revert this back to a regular one unit function and apply the pyswarm evaluate method
      cost = []
 
      if self.known_enemy_units.exists:
          for logical_pos in logical_swarm_pos:
              cost.append(self.known_enemy_units.closest_distance_to(Point2(Pointlike((logical_pos[0], logical_pos[1])))))
      else:
          for logical_pos in logical_swarm_pos:
              cost.append(1 / phys_swarm.center.distance2_to(Point2(Pointlike((logical_pos[0], logical_pos[1])))))
      return np.array(cost)
Esempio n. 2
0
    def _find_creep_placement(self, target: Point2) -> Point2:
        nearest_spot = self.creep_map[np.sum(
            np.square(np.abs(self.creep_map -
                             np.array([[target.x, target.y]]))),
            1,
        ).argmin()]

        pos = Point2(Pointlike((nearest_spot[0], nearest_spot[1])))
        return pos
Esempio n. 3
0
  def fitness(self, logical_swarm_pos, phys_swarm):
      #account for own health, enemy health/splash&anti air damage/
      # upgrade this function...
      # revert this back to a regular one unit function and apply the pyswarm evaluate method
      cost = []
 
      # the coefficients within can be optimized...
      if self.known_enemy_units.exists:
          for logical_pos in logical_swarm_pos:
              target_point = Point2(Pointlike((logical_pos[0], logical_pos[1])))
              cost.append( \
                      self.known_enemy_units.closest_distance_to(target_point) + \
                      (5 * self.known_enemy_units.closer_than(10, target_point).amount - 5 * phys_swarm.closer_than(10, target_point).amount) \
                      )
      else:
          for logical_pos in logical_swarm_pos:
              cost.append(40 / phys_swarm.center.distance2_to(Point2(Pointlike((logical_pos[0], logical_pos[1])))))
      return np.array(cost)
Esempio n. 4
0
    def __init__(self):
        self.Chaining = False  # If Chaining Grenades
        self.Spot = Pointlike((23, 23))
        self.Destination = Point2(self.Spot)  # Where we initially move to
        self.Bomb = Pointlike((20, 20))
        self.Target = Point2(self.Bomb)  # Where initial bomb lands

        # state
        self.Enemy_Units = ()
        self.Available_Reapers = ()
        self.Cooldown_Reapers = ()

        self.cg = ()  # Control Groups

        self.SCV_counter = 0  # Base Building
        self.refinerys = 0
        self.barracks_started = False
        self.made_workers_for_gas = False
        self.attack_groups = set()
        self.Ideal_Workers = False
Esempio n. 5
0
 async def move_unit(self, unit_to_move, direction):
     current_pos = unit_to_move.position
     target_destination = current_pos
     if direction == 0:
         target_destination = [current_pos.x, current_pos.y + 5]
     elif direction == 1:
         target_destination = [current_pos.x + 5, current_pos.y]
     elif direction == 2:
         target_destination = [current_pos.x, current_pos.y - 5]
     elif direction == 3:
         target_destination = [current_pos.x - 5, current_pos.y]
     self.action_buffer.append(unit_to_move.move(Point2(Pointlike(target_destination))))
Esempio n. 6
0
    def _find_closest_to_target(self, from_pos: Point2,
                                grid: np.ndarray) -> Point2:
        try:
            nearest_spot = grid[np.sum(
                np.square(np.abs(grid - np.array([[from_pos.x, from_pos.y]]))),
                1,
            ).argmin()]

            pos = Point2(Pointlike((nearest_spot[0], nearest_spot[1])))
            return pos
        except ValueError:
            return from_pos.towards(self.bot.start_location, 1)
Esempio n. 7
0
    async def attack(self, phys_swarm):
        if phys_swarm.amount > 5:
            orders = []
            # reinitialize swarm if needed
            if phys_swarm.amount != self.swarm_size:
                self.swarm_size = phys_swarm.amount
                self.phys_swarm_pos = []
                for unit in phys_swarm:
                    self.phys_swarm_pos.append(
                        [unit.position.x, unit.position.y])
                self.phys_swarm_pos = np.array(self.phys_swarm_pos)

                self.logical_swarm = P.create_swarm(
                    n_particles=phys_swarm.amount,
                    dimensions=2,
                    options=self.my_options,
                    bounds=([0, 0], [
                        self.game_info.map_size[0], self.game_info.map_size[1]
                    ]),
                    init_pos=self.phys_swarm_pos,
                    clamp=(0, 5.6))

            self.logical_swarm.current_cost = self.fitness(
                self.logical_swarm.position, phys_swarm)
            self.logical_swarm.pbest_cost = self.fitness(
                self.logical_swarm.pbest_pos, phys_swarm)
            self.logical_swarm.pbest_pos, self.logical_swarm.pbest_cost = P.compute_pbest(
                self.logical_swarm)

            if np.min(self.logical_swarm.pbest_cost
                      ) < self.logical_swarm.best_cost:
                self.logical_swarm.best_pos, self.logical_swarm.best_cost = self.my_topology.compute_gbest(
                    self.logical_swarm)

            self.logical_swarm.velocity = self.my_topology.compute_velocity(
                self.logical_swarm)
            self.logical_swarm.position = self.my_topology.compute_position(
                self.logical_swarm)
            # Extract positions from above and issue movement/attack orders
            # loop through np array compiling positions and appending them to orders list.

            # The mutas are still ignoring nearby enemies.
            for row, unit in zip(self.logical_swarm.position, phys_swarm):
                if self.known_enemy_units.closer_than(unit.radar_range,
                                                      unit.position).exists:
                    orders.append(
                        unit.attack(
                            self.known_enemy_units.closest_to(unit.position)))
                else:
                    orders.append(
                        unit.move(Point2(Pointlike((row[0], row[1])))))
            await self.do_actions(orders)
Esempio n. 8
0
    async def attack(self, phys_swarm, iteration):
        if phys_swarm.amount > 10:
            orders = []
            # reinitialize swarm if needed
            if phys_swarm.amount > self.swarm_size + 3 or iteration > self.iter_of_last_update + 75:
                self.swarm_size = phys_swarm.amount
                self.phys_swarm_pos = []
                for unit in phys_swarm:
                    self.phys_swarm_pos.append([unit.position.x, unit.position.y])
                self.phys_swarm_pos = np.array(self.phys_swarm_pos)
                self.logical_swarm = P.create_swarm(n_particles=phys_swarm.amount, dimensions=2, options=self.my_options, bounds=([0,0], [self.game_info.map_size[0], self.game_info.map_size[1]]) , init_pos=self.phys_swarm_pos, clamp=(0,4.0))
                self.iter_of_last_update = iteration


            self.logical_swarm.current_cost = self.fitness(self.logical_swarm.position, phys_swarm)
            self.logical_swarm.pbest_cost = self.fitness(self.logical_swarm.pbest_pos, phys_swarm)
            self.logical_swarm.pbest_pos, self.logical_swarm.pbest_cost = P.compute_pbest(self.logical_swarm)

            if np.min(self.logical_swarm.pbest_cost) < self.logical_swarm.best_cost:
                self.logical_swarm.best_pos, self.logical_swarm.best_cost = self.my_topology.compute_gbest(self.logical_swarm)

            self.logical_swarm.velocity = self.my_topology.compute_velocity(self.logical_swarm)
            self.logical_swarm.position = self.my_topology.compute_position(self.logical_swarm)
            # Extract positions from above and issue movement/attack orders
            # loop through np array compiling positions and appending them to orders list.
          
            wounded_units = phys_swarm.filter(lambda u: u.health_percentage <= .7)
            phys_swarm = phys_swarm.filter(lambda u: u.health_percentage > .7)

            for unit in wounded_units:
                unit.move(self.townhalls.first.position)

            # The mutas are still ignoring nearby enemies.
            for row, unit in zip(self.logical_swarm.position, phys_swarm):
                if self.known_enemy_units.closer_than(unit.radar_range, unit.position).exists:
                    orders.append(unit.stop())
                    orders.append(unit.attack(self.known_enemy_units.closest_to(unit.position).position))
                elif self.known_enemy_units.exists:
                    orders.append(unit.attack(self.known_enemy_units.closest_to(Point2(Pointlike((row[0], row[1]))))))
                else:
                    orders.append(unit.move(Point2(Pointlike((row[0], row[1])))))

            await self.do_actions(orders)
Esempio n. 9
0
    async def attack(self, phys_swarm, iteration):
        if phys_swarm.amount > 10:
            orders = []

            # I should be able to dynamically add and subtract particles from the swarm... should only init once at beginning...
            if # The business of adding/subrtracting from swarm should be done in on created/destroyed methods...
            # do a comprehension that deletes matches positions and alive units?

            
            # calcuate the current
            self.log_swarm.current_cost = self.fitness(  self.log_swarm.position,  phys_swarm  )
            self.log_swarm.pbest_cost = self.fitness(  self.log_swarm.pbest_pos,  phys_swarm  )
            self.log_swarm.pbest_pos, self.log_swarm.pbest_cost = P.compute_pbest(  self.log_swarm  )


            #
            if np.min(  self.log_swarm.pbest_cost  ) < self.log_swarm.best_cost:
                self.log_swarm.best_pos, self.log_swarm.best_cost = self.my_topology.compute_gbest(  self.log_swarm  )



            #
            self.logical_swarm.velocity = self.my_topology.compute_velocity(  self.log_swarm  )
            self.logical_swarm.position = self.my_topology.compute_position(  self.log_swarm  )
            

            #this should be parameterized as aggression...
            wounded_units = phys_swarm.filter(lambda u: u.health_percentage <= .7)

            for unit in wounded_units:
                unit.move(self.townhalls.first.position)

            
            phys_swarm = phys_swarm.filter(lambda u: u.health_percentage > .7)

            for row, unit in zip(self.logical_swarm.position, phys_swarm):
                orders.append(unit.attack(Point2(Pointlike((row[0], row[1])))))
            # might need to get the nearest unit to do this... also check to make sure nearest unit not already assigned a task


            await self.do_actions(orders)
Esempio n. 10
0
def away(this: Pointlike, from_this: Pointlike, this_much_more: float):
    distance_total = from_this.distance_to(this) + this_much_more
    return from_this.towards(this, distance_total)
Esempio n. 11
0
    async def test_positions(self):
        p1 = Pointlike((2.3, 2.7))
        p2 = Point2((-5.3, -7.9))
        p3 = Point3((-2.7, 5.4, 133.2))

        # Testing Pointlike
        assert p1 == Pointlike((2.3, 2.7))
        assert p1.rounded == Pointlike((2, 3))
        assert p1.position == p1
        assert p1.distance_to(Pointlike((-0.7, 6.7))) == 5
        assert p1.closest([
            Pointlike((2, 2)),
            Pointlike((-2, -2))
        ]) == Pointlike((2, 2))
        assert p1.furthest([
            Pointlike((2, 2)),
            Pointlike((-2, -2))
        ]) == Pointlike((-2, -2))
        assert p1.offset(Pointlike((-1, -1))) == Pointlike((1.3, 1.7))
        assert p1.offset(Pointlike((-1, 1))) == Pointlike((1.3, 3.7))
        assert p1.towards(Pointlike((2.3, 50)), 5) == Pointlike((2.3, 7.7))
        # testing backwards aswell
        assert p1.towards(Pointlike((2.3, 50)), -5) == Pointlike((2.3, -2.3))

        # Testing Point2
        assert p2.x == -5.3
        assert p2.y == -7.9
        assert p2.to2 == p2
        assert p2.to3 == Point3((-5.3, -7.9, 0))
        assert (p2.neighbors4 ==
            {
                Point2((-5.3, -6.9)),
                Point2((-5.3, -8.9)),
                Point2((-4.3, -7.9)),
                Point2((-6.3, -7.9)),
            })
        assert p2.neighbors8 == (p2.neighbors4 |
            {
                Point2((-4.3, -6.9)),
                Point2((-4.3, -8.9)),
                Point2((-6.3, -6.9)),
                Point2((-6.3, -8.9)),
            })

        # Testing Point3
        assert p3.z == 133.2
        assert p3.to3 == p3
class TestPosition(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        pass

    @classmethod
    def tearDownClass(cls):
        pass

    def setUp(self):
        self.p = Pointlike((2.3, 2.7))
        self.p2 = Point2((-5.3, -7.9))
        self.p3 = Point3((-2.7, 5.4, 133.2))

    def tearDown(self):
        pass

    def test_Pointlike(self):
        self.assertEqual(self.p, Pointlike((2.3, 2.7)))
        self.assertEqual(self.p.rounded, Pointlike((2, 3)))
        self.assertEqual(self.p.position, self.p)
        self.assertEqual(self.p.distance_to(Pointlike((-0.7, 6.7))), 5)
        self.assertEqual(
            self.p.closest([Pointlike((2, 2)),
                            Pointlike((-2, -2))]), Pointlike((2, 2)))
        self.assertEqual(
            self.p.furthest([Pointlike((2, 2)),
                             Pointlike((-2, -2))]), Pointlike((-2, -2)))
        self.assertEqual(self.p.offset(Pointlike((-1, -1))),
                         Pointlike((1.3, 1.7)))
        self.assertEqual(self.p.offset(Pointlike((-1, 1))),
                         Pointlike((1.3, 3.7)))
        self.assertEqual(self.p.towards(Pointlike((2.3, 50)), 5),
                         Pointlike((2.3, 7.7)))
        # testing backwards aswell
        self.assertEqual(self.p.towards(Pointlike((2.3, 50)), -5),
                         Pointlike((2.3, -2.3)))

    def test_Point2(self):
        self.assertEqual(self.p2.x, -5.3)
        self.assertEqual(self.p2.y, -7.9)
        self.assertEqual(self.p2.to2, self.p2)
        self.assertEqual(self.p2.to3, Point3((-5.3, -7.9, 0)))
        self.assertEqual(
            self.p2.neighbors4, {
                Point2((-5.3, -6.9)),
                Point2((-5.3, -8.9)),
                Point2((-4.3, -7.9)),
                Point2((-6.3, -7.9)),
            })
        self.assertEqual(
            self.p2.neighbors8, self.p2.neighbors4 | {
                Point2((-4.3, -6.9)),
                Point2((-4.3, -8.9)),
                Point2((-6.3, -6.9)),
                Point2((-6.3, -8.9)),
            })

    def test_Point3(self):
        self.assertEqual(self.p3.z, 133.2)
        self.assertEqual(self.p3.to3, self.p3)
 def test_Pointlike(self):
     self.assertEqual(self.p, Pointlike((2.3, 2.7)))
     self.assertEqual(self.p.rounded, Pointlike((2, 3)))
     self.assertEqual(self.p.position, self.p)
     self.assertEqual(self.p.distance_to(Pointlike((-0.7, 6.7))), 5)
     self.assertEqual(
         self.p.closest([Pointlike((2, 2)),
                         Pointlike((-2, -2))]), Pointlike((2, 2)))
     self.assertEqual(
         self.p.furthest([Pointlike((2, 2)),
                          Pointlike((-2, -2))]), Pointlike((-2, -2)))
     self.assertEqual(self.p.offset(Pointlike((-1, -1))),
                      Pointlike((1.3, 1.7)))
     self.assertEqual(self.p.offset(Pointlike((-1, 1))),
                      Pointlike((1.3, 3.7)))
     self.assertEqual(self.p.towards(Pointlike((2.3, 50)), 5),
                      Pointlike((2.3, 7.7)))
     # testing backwards aswell
     self.assertEqual(self.p.towards(Pointlike((2.3, 50)), -5),
                      Pointlike((2.3, -2.3)))
 def setUp(self):
     self.p = Pointlike((2.3, 2.7))
     self.p2 = Point2((-5.3, -7.9))
     self.p3 = Point3((-2.7, 5.4, 133.2))
Esempio n. 15
0
    async def on_step(self, iteration):

        if iteration == 0:
            if iteration == 0:
                await self.chat_send("(glhf)")

#creates control groups of 14 reapers
        if self.units(REAPER).idle.amount > 14:
            cg = ControlGroup(self.units(REAPER).idle)
            self.attack_groups.add(cg)

# trains workers
        for cc in self.units(UnitTypeId.COMMANDCENTER).ready.noqueue:
            if self.can_afford(
                    SCV) and self.workers.amount < 20 and cc.noqueue:
                await self.do(cc.train(SCV))

        cc = self.units(COMMANDCENTER).ready.first
        bobthebuilder = self.units(SCV)[0]

        #build supply depots
        if self.supply_left < 2:
            if self.can_afford(
                    SUPPLYDEPOT) and self.already_pending(SUPPLYDEPOT) < 2:
                await self.build(SUPPLYDEPOT,
                                 near=cc.position.towards(
                                     self.game_info.map_center, 5))

#build barracks
        if self.units(
                BARRACKS
        ).amount < 1:  # or (self.minerals > 400 and self.units(BARRACKS).amount < 5):
            if self.can_afford(BARRACKS):
                err = await self.build(BARRACKS,
                                       near=cc.position.towards(
                                           self.game_info.map_center, 5))
#train reapers
        elif self.units(BARRACKS).ready.exists and self.units(
                REFINERY).ready.exists and self.units(REAPER).amount < 1:
            barracks = self.units(BARRACKS).ready
            if self.can_afford(REAPER) and barracks.noqueue:
                await self.do(barracks.random.train(REAPER))
#build refinerys
        if self.refinerys < 2:
            if self.can_afford(REFINERY):
                worker = self.workers.random
                target = self.state.vespene_geyser.closest_to(worker.position)
                err = await self.do(bobthebuilder.build(REFINERY, target))
                if not err:
                    self.refinerys += 1
#workers in the mines/gas
        for a in self.units(REFINERY):
            if a.assigned_harvesters < a.ideal_harvesters:
                w = self.workers.closer_than(20, a)
                if w.exists:
                    await self.do(w.random.gather(a))


#send out reapers
        if self.units(REAPER).amount > 0:
            for reaper in self.units(REAPER).idle:
                #randomize where bomb lands a bit
                x = self.Target.x - .5
                y = self.Target.y - .5
                rand = random.random() * 100
                randx = (rand / 100) + x
                rand = random.random() * 100
                randy = (rand / 100) + y
                lz = Pointlike((randx, randy))
                boom = Point2(lz)
                #use grenade
                abilities = await self.get_available_abilities(reaper)
                if AbilityId.KD8CHARGE_KD8CHARGE in abilities:
                    await self.do(reaper(KD8CHARGE_KD8CHARGE, boom))
Esempio n. 16
0
 def __init__(self):
     self.point = Pointlike((20,20))
     self.nextpoint = Point2(self.point)    #where we send our noobs
     self.workers = 12
     self.noob = False                    #keep count of noobs
Esempio n. 17
0
    async def on_step(self, iteration):

            # State
        Available_Reapers = []
        Cooldown_Reapers = []
        Enemy_Units = []


        for reaper in self.units(REAPER):
            abilities = await self.get_available_abilities(reaper)
            if AbilityId.KD8CHARGE_KD8CHARGE in abilities:
                Available_Reapers.append(reaper)
            else:
                Cooldown_Reapers.append(reaper)
        for enemy in self.known_enemy_units:
            if (enemy in self.prev_Enemy) == False and enemy.is_structure == False:
                Enemy_Units.append(enemy)


        current_state = [
            Available_Reapers,
            Cooldown_Reapers,
            Enemy_Units,
        ]

            # Reward
        reward = 0
        if self.prev_action != None:

            for bomber in Cooldown_Reapers:
                reward += 1000
            for lazy in Available_Reapers:
                reward += -100
            for enemy in Enemy_Units:
                reward += 100

            self.qlearn.learn(str(self.prev_state), self.prev_action, reward, str(current_state))
            # Choose action
        rl_action = self.qlearn.choose_action(str(current_state))
        smart_action = smart_actions[rl_action]
            # Prep next step
        self.prev_score = reward
        self.prev_state = current_state
        self.prev_action = rl_action
        self.prev_Enemy = Enemy_Units
            # Actions
        if smart_action == ACTION_DO_NOTHING:
                # Run Away
            for reaper in self.units(REAPER):
                targetx = (random.randrange(0, 100))/20
                targety = (random.randrange(0, 100))/20
                home = Pointlike((24 + targetx, 24 + targety))
                moveto = reaper.position
                await self.do(reaper.move(moveto))

        if smart_action == ACTION_KD8_CHARGE:
                # default spot on the map
            targetx = (random.randrange(0, 100))/20
            targety = (random.randrange(0, 100))/20
            home = Pointlike((20 + targetx, 20 + targety))
            moveto = Point2(home)
                # throw grenade at enemy
            if len(Available_Reapers) > 5 and len(Enemy_Units) > 0:
                for reaper in Available_Reapers:
                    if reaper == self.units(REAPER).closest_to(Enemy_Units[0].position):
                        bomb = Point3(Enemy_Units[0].position)
                        await self.do(reaper(KD8CHARGE_KD8CHARGE, bomb))

                    else:
                        await self.do(reaper.move(moveto))
            else:
                for reaper in Available_Reapers:
                    await self.do(reaper.move(moveto))


        if iteration == 0:
            if iteration == 0:
                await self.chat_send("(glhf)")

#creates control groups of 14 reapers
        if self.units(REAPER).idle.amount > 14:
            cg = ControlGroup(self.units(REAPER).idle)
            self.attack_groups.add(cg)

# trains workers
        for cc in self.units(UnitTypeId.COMMANDCENTER).ready.noqueue:
            if self.can_afford(SCV) and self.workers.amount < 20 and cc.noqueue:
                await self.do(cc.train(SCV))

        cc = self.units(COMMANDCENTER).ready.first
        bobthebuilder = self.units(SCV)[0]

#build supply depots
        if self.supply_left < 2:
            if self.can_afford(SUPPLYDEPOT) and self.already_pending(SUPPLYDEPOT) < 2:
                await self.build(SUPPLYDEPOT, near=cc.position.towards(self.game_info.map_center, 5))

#build barracks
        if self.units(BARRACKS).amount < 3: # or (self.minerals > 400 and self.units(BARRACKS).amount < 5):
            if self.can_afford(BARRACKS):
                err = await self.build(BARRACKS, near=cc.position.towards(self.game_info.map_center, 5))
#train reapers
        elif self.units(BARRACKS).ready.exists and self.units(REAPER).amount < 28:
            barracks = self.units(BARRACKS).ready
            if self.can_afford(REAPER) and barracks.noqueue:
                await self.do(barracks.random.train(REAPER))
#build refinerys
        if self.refinerys < 2:
            if self.can_afford(REFINERY):
                worker = self.workers.random
                target = self.state.vespene_geyser.closest_to(worker.position)
                err = await self.do(bobthebuilder.build(REFINERY, target))
                if not err:
                    self.refinerys += 1
#workers in the mines/gas
        for a in self.units(REFINERY):
            if a.assigned_harvesters < a.ideal_harvesters:
                w = self.workers.closer_than(20, a)
                if w.exists:
                    await self.do(w.random.gather(a))