Ejemplo n.º 1
0
 def isDeadend(self):
     """
     True if path ends in the formation of its deploying player.
     """
     if transform.is_lowerHalf(self.py[0]):
         return transform.is_lowerHalf(self.py[-1] + 1)
     else:
         return transform.is_upperHalf(self.py[-1] - 1)
Ejemplo n.º 2
0
    def _add_stationary_unit(self, pos, attacking=True):
        """
        attacking: True if this unit is a destructor
        """
        x, y = pos
        if transform.is_lowerHalf(y):
            for (i, j, r) in self.CIRCLE:
                if not transform.pos2_inbound((x + i, y + j)): continue
                p = transform.pos2_encode((x + i, y + j))

                if r < self.proximity_self[p]:
                    if attacking:
                        self.proximity_self[p] = r
                    else:
                        self.proximity_self[p] = self.MAX_STATIONARY_RANGE
        else:
            for (i, j, r) in self.CIRCLE:
                if not transform.pos2_inbound((x + i, y + j)): continue
                p = transform.pos2_encode((x + i, y + j))

                if r < self.proximity_enemy[p]:
                    if attacking:
                        self.proximity_enemy[p] = r
                    else:
                        self.proximity_enemy[p] = self.MAX_STATIONARY_RANGE
Ejemplo n.º 3
0
    def markTrajectory(self, path):
        if not path:
            return

        for (x, y) in path:
            if transform.is_lowerHalf(y):
                self.prohibited_loc.add((x, y))
Ejemplo n.º 4
0
    def readPaths(self, game_state):

        self.resetPaths()

        # Create the pressure map.
        for p in range(transform.ARENA_SIZE):
            # Player 1 perspective
            x, y = transform.pos2_edge_decode(p)
            if not game_state.contains_stationary_unit([x, y]):
                # Determine the target edge from x,y.
                if transform.is_lowerHalf(p):
                    edge = game_state.game_map.TOP_RIGHT
                else:
                    assert transform.is_upperHalf(p)
                    edge = game_state.game_map.TOP_LEFT

                path = game_state.find_path_to_edge([x, y], edge)
                self.path1_self.append(Path.fromGamePath(path))
            else:
                self.path1_self.append(None)

            # Player 2 persepctive
            x, y = transform.pos2_flip((x, y))
            if not game_state.contains_stationary_unit([x, y]):
                # Reminder: When p is lower half on the top edge, it
                # corresponds to TOP_RIGHT!
                if transform.is_lowerHalf(p):
                    edge = game_state.game_map.BOTTOM_LEFT
                else:
                    assert transform.is_upperHalf(p)
                    edge = game_state.game_map.BOTTOM_RIGHT
                path = game_state.find_path_to_edge([x, y], edge)
                self.path1_enemy.append(Path.fromGamePath(path))
            else:
                self.path1_enemy.append(None)

        # Check invariants
        assert len(self.path1_self) == transform.ARENA_SIZE
        assert len(self.path1_enemy) == transform.ARENA_SIZE
        self.flag_pathOutdated = False
Ejemplo n.º 5
0
 def _add_destructor_contribution(self, pos):
     (x, y) = pos
     if transform.is_lowerHalf(pos[1]):
         self.number_D_self += 1
         for (dx, dy, r) in self.CIRCLE_DESTRUCTOR:
             if not transform.pos2_inbound((x + dx, y + dy)): continue
             p = transform.pos2_encode((x + dx, y + dy))
             self.barrage_self[p] += 1
     else:
         self.number_D_enemy += 1
         for (dx, dy, r) in self.CIRCLE_DESTRUCTOR:
             if not transform.pos2_inbound((x + dx, y + dy)): continue
             p = transform.pos2_encode((x + dx, y + dy))
             self.barrage_enemy[p] += 1
Ejemplo n.º 6
0
    def readGameState(self, game_state):
        self.bits_self = game_state.get_resource(game_state.BITS, 0)
        self.bits_enemy = game_state.get_resource(game_state.BITS, 1)
        self.cores_self = game_state.get_resource(game_state.CORES, 0)
        self.cores_enemy = game_state.get_resource(game_state.CORES, 1)

        self.number_E_self = 0
        self.number_E_enemy = 0
        self.number_D_self = 0
        self.number_D_enemy = 0
        # Primary attack trajectories
        self.primal_self = None
        self.primal_enemy = None
        # Set of prohibited locations as determined by the primary trajectory.
        self.prohibited_loc = set()
        # Create units map
        for p in range(transform.ARENA_VOL):
            self.stability_F[p] = 0
            self.stability_E[p] = 0
            self.stability_D[p] = 0
            self.pressure_self[p] = 0
            self.pressure_enemy[p] = 0
            self.barrage_self[p] = 0
            self.barrage_enemy[p] = 0
            self.proximity_self[p] = float('+inf')
            self.proximity_enemy[p] = float('+inf')

            x, y = transform.pos2_decode(p)

            units = game_state.game_map[x, y]
            for unit in units:
                stability = unit.stability
                if not unit.stationary: continue

                if unit.unit_type == FILTER:
                    self._add_stationary_unit([x, y], attacking=False)
                    self.stability_F[p] = stability
                elif unit.unit_type == ENCRYPTOR:
                    if transform.is_lowerHalf(y):
                        self.number_E_self += 1
                    else:
                        self.number_E_enemy += 1
                    self._add_stationary_unit([x, y], attacking=False)
                    self.stability_E[p] = stability
                elif unit.unit_type == DESTRUCTOR:
                    self._add_stationary_unit([x, y], attacking=True)
                    self._add_destructor_contribution((x, y))
                    self.stability_D[p] = stability
Ejemplo n.º 7
0
 def addUnit(self, game_state, pos, unittype):
     """
     Called by spawnDefensiveUnit only. Can only add points in friendly
     territory
     """
     uid = UNIT_TYPE_TO_INDEX[unittype]
     assert transform.is_lowerHalf(pos[1])
     p = transform.pos2_encode(pos)
     stability = self.STABILITY[uid]
     if uid == UNIT_TYPE_TO_INDEX[FILTER]:
         self._add_stationary_unit(pos, attacking=False)
         self.stability_F[p] = self.STABILITY[uid]
     elif uid == UNIT_TYPE_TO_INDEX[ENCRYPTOR]:
         self._add_stationary_unit(pos, attacking=False)
         self.stability_E[p] = self.STABILITY[uid]
     elif uid == UNIT_TYPE_TO_INDEX[DESTRUCTOR]:
         self._add_stationary_unit(pos, attacking=True)
         self._add_destructor_contribution(pos)
         self.stability_D[p] = self.STABILITY[uid]
Ejemplo n.º 8
0
    def _evaluatePath(self, path, nEMP: int = 1):
        """
        Populate the shield,damage field of the path. Populate pressure field.
        """
        if not path:
            # Path starts from a occupied unit.
            return float('-inf')

        path.evaluated = True
        player = 0 if transform.is_lowerHalf(path.py[0]) else 1

        path.feasibility = 0.0
        path.shield = 0.0
        path.damage = 0.0
        path.harass = 0.0

        if path.isDeadend:
            path.feasibility = float('-inf')
            return path.feasibility

        # Get list of encryptors
        if player == 0: encs = self.li_encryptors_self.copy()
        else: encs = self.li_encryptors_enemy.copy()

        EMP_STABILITY = self.STABILITY[UNIT_TYPE_TO_INDEX[EMP]]
        EMP_SPEED = self.SPEED[UNIT_TYPE_TO_INDEX[EMP]]
        EMP_RANGE = self.RANGE[UNIT_TYPE_TO_INDEX[EMP]]

        n = len(path)
        for i in range(n):
            x = path.px[i]
            y = path.py[i]
            p = transform.pos2_encode((x, y))

            # Filter the encs list
            ne = len(encs)
            encs = [e for e in encs if \
                transform.distance2(e, (x,y)) >= \
                    self.RANGE[UNIT_TYPE_TO_INDEX[ENCRYPTOR]] + 0.51]
            shield = (ne - len(encs)) * self.ENCRYPTOR_SHIELD
            path.shield_dp[i] = shield
            path.shield += shield

            # Enemy destructor
            if player == 0: damage = self.barrage_enemy[p]
            else: damage = self.barrage_self[p]
            path.damage_dp[i] = damage
            path.damage += damage

            if transform.is_lowerHalf(y) == (player == 0):
                path.dist_self += 1
            else:
                path.dist_enemy += 1

            nEMP += shield / EMP_STABILITY
            nEMP -= damage / EMP_STABILITY / EMP_SPEED

            path.pressure_dp[i] = nEMP * self.DAMAGE_F_EMP
            if player == 0:
                if self.proximity_enemy[p] == EMP_RANGE:
                    path.harass += 1
                    #gamelib.debug_write('Harassed (Self)')

                # This is always 0
                if transform.is_upperHalf(y):
                    path.pressure_dp[i] -= \
                        self.stability_F[p] + \
                        self.stability_E[p] + \
                        self.stability_D[p]
            else:
                if self.proximity_self[p] == EMP_RANGE:
                    path.harass += 1
                    #gamelib.debug_write('Harassed (Enemy)')

                # This is always 0
                if transform.is_lowerHalf(y):
                    path.pressure_dp[i] -= \
                        self.stability_F[p] + \
                        self.stability_E[p] + \
                        self.stability_D[p]

            AMBIENT_PRESSURE = self.DAMAGE_F_EMP
            path.pressure_dp[i] = max(path.pressure_dp[i], AMBIENT_PRESSURE)

        x_normal, y_normal = path.px[0], path.py[0]
        if player == 0:
            policy = self.policy_self
        else:
            policy = self.policy_enemy
            x_normal, y_normal = transform.pos2_flip((x_normal, y_normal))
        x_normal /= (transform.ARENA_SIZE - 1)
        y_normal /= (transform.HALF_ARENA - 1)
        path.feasibility = policy.w_dist_self  * path.dist_self \
                         - policy.w_dist_enemy * path.dist_enemy \
                         + policy.w_shield     * path.shield \
                         + policy.w_damage     * path.damage \
                         + policy.w_pos_x      * x_normal \
                         + policy.w_pos_y      * y_normal \
                         + policy.w_harass     * path.harass
        return path.feasibility
Ejemplo n.º 9
0
 def fromGamePath(cls, path):
     px, py = zip(*path)  # Transpose
     px = array.array('i', px)
     py = array.array('i', py)
     player = (0 if transform.is_lowerHalf(py[0]) else 1)
     return cls(px=px, py=py, player=player)