• Search by Module
• Search by Words
• Search Projects

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• python-sc2-master
  • examples
    • distributed_workers.py
    • protoss
      • cannon_rush.py
      • warpgate_push.py
      • __init__.py
      • threebase_voidray.py
    • worker_rush.py
    • arcade_bot.py
    • bot_vs_bot.py
    • fastreload.py
    • too_slow_bot.py
    • zerg
      • zerg_rush.py
      • __init__.py
      • hydralisk_push.py
      • onebase_broodlord.py
    • terran
      • onebase_battlecruiser.py
      • proxy_rax.py
      • cyclone_push.py
      • ramp_wall.py
      • mass_reaper.py
      • __init__.py
    • host_external_norestart.py
    • run_external.py
    • observer_easy_vs_easy.py
    • __init__.py
    • play_tvz.py
  • LICENSE
  • test
    • test_directions.py
    • autotest_bot.py
    • travis_test_script.py
    • test_sliding_window.py
    • Dockerfile
    • test_examples.py
    • conftest.py
  • Pipfile
  • generate_id_constants.py
  • setup.py
  • Pipfile.lock
  • setup.cfg
  • .travis.yml
  • README.md
  • generate_id_constants_from_stableid.py
  • sc2
    • data.py
    • tmpfix.py
    • renderer.py
    • cache.py
    • game_info.py
    • ids
      • ability_id.py
      • unit_typeid.py
      • effect_id.py
      • upgrade_id.py
      • buff_id.py
      • __init__.py
    • action.py
    • client.py
    • position.py
    • unit_command.py
    • units.py
    • helpers
      • __init__.py
      • control_group.py
    • unit.py
    • maps.py
    • game_data.py
    • pixel_map.py
    • player.py
    • constants.py
    • score.py
    • portconfig.py
    • controller.py
    • __init__.py
    • main.py
    • power_source.py
    • paths.py
    • bot_ai.py
    • game_state.py
    • sc2process.py
    • protocol.py
  • .gitignore

from typing import Callable, Set, FrozenSet, List

from .position import Point2


class PixelMap:
    def __init__(self, proto):
        self._proto = proto
        assert self.bits_per_pixel % 8 == 0, "Unsupported pixel density"
        assert self.width * self.height * self.bits_per_pixel / 8 == len(self._proto.data)
        self.data = bytearray(self._proto.data)

    @property
    def width(self):
        return self._proto.size.x

    @property
    def height(self):
        return self._proto.size.y

    @property
    def bits_per_pixel(self):
        return self._proto.bits_per_pixel

    @property
    def bytes_per_pixel(self):
        return self._proto.bits_per_pixel // 8

    def __getitem__(self, pos):
        x, y = pos

        assert 0 <= x < self.width, f"x is {x}, self.width is {self.width}"
        assert 0 <= y < self.height, f"y is {y}, self.height is {self.height}"

        index = -self.width * y + x
        # print(f"INDEX IS {index} FOR {pos}")
        start = index * self.bytes_per_pixel
        data = self.data[start : start + self.bytes_per_pixel]
        return int.from_bytes(data, byteorder="little", signed=False)

    def __setitem__(self, pos, val):
        """ Example usage: self._game_info.pathing_grid[Point2((20, 20))] = [255] """
        x, y = pos

        assert 0 <= x < self.width, f"x is {x}, self.width is {self.width}"
        assert 0 <= y < self.height, f"y is {y}, self.height is {self.height}"

        index = -self.width * y + x
        start = index * self.bytes_per_pixel
        self.data[start : start + self.bytes_per_pixel] = val

    def is_set(self, p):
        return self[p] != 0

    def is_empty(self, p):
        return not self.is_set(p)

    def invert(self):
        raise NotImplementedError

    def flood_fill(self, start_point: Point2, pred: Callable[[int], bool]) -> Set[Point2]:
        nodes: Set[Point2] = set()
        queue: List[Point2] = [start_point]

        while queue:
            x, y = queue.pop()

            if not (0 <= x < self.width and 0 <= y < self.height):
                continue

            if Point2((x, y)) in nodes:
                continue

            if pred(self[x, y]):
                nodes.add(Point2((x, y)))
                for a in [-1, 0, 1]:
                    for b in [-1, 0, 1]:
                        if not (a == 0 and b == 0):
                            queue.append(Point2((x + a, y + b)))

        return nodes

    def flood_fill_all(self, pred: Callable[[int], bool]) -> Set[FrozenSet[Point2]]:
        groups: Set[FrozenSet[Point2]] = set()

        for x in range(self.width):
            for y in range(self.height):
                if any((x, y) in g for g in groups):
                    continue

                if pred(self[x, y]):
                    groups.add(frozenset(self.flood_fill(Point2((x, y)), pred)))

        return groups

    def print(self, wide=False):
        for y in range(self.height):
            for x in range(self.width):
                print("#" if self.is_set((x, y)) else " ", end=(" " if wide else ""))
            print("")

    def save_image(self, filename):
        data = [(0, 0, self[x, y]) for y in range(self.height) for x in range(self.width)]
        from PIL import Image

        im = Image.new("RGB", (self.width, self.height))
        im.putdata(data)
        im.save(filename)