synth-ai 0.2.14__py3-none-any.whl → 0.4.1__py3-none-any.whl

synth_ai/environments/examples/crafter_custom/crafter/constants.py

@@ -1,8 +0,0 @@
-import pathlib
-
-import ruamel.yaml
-
-root = pathlib.Path(__file__).parent
-yaml = ruamel.yaml.YAML(typ="safe", pure=True)
-for key, value in yaml.load((root / "data.yaml").read_text()).items():
-    globals()[key] = value

synth_ai/environments/examples/crafter_custom/crafter/engine.py

@@ -1,269 +0,0 @@
-import collections
-import functools
-import pathlib
-
-import imageio.v3 as imageio
-import numpy as np
-from PIL import Image, ImageEnhance
-
-
-class AttrDict(dict):
-    __getattr__ = dict.__getitem__
-
-
-class staticproperty:
-    def __init__(self, function):
-        self.function = function
-
-    def __get__(self, instance, owner=None):
-        return self.function()
-
-
-class World:
-    def __init__(self, area, materials, chunk_size):
-        self.area = area
-        self._chunk_size = chunk_size
-        self._mat_names = {i: x for i, x in enumerate([None] + materials)}
-        self._mat_ids = {x: i for i, x in enumerate([None] + materials)}
-        self.reset()
-
-    def reset(self, seed=None):
-        self.random = np.random.RandomState(seed)
-        self.daylight = 0.0
-        self._chunks = collections.defaultdict(set)
-        self._objects = [None]
-        self._mat_map = np.zeros(self.area, np.uint8)
-        self._obj_map = np.zeros(self.area, np.uint32)
-
-    @property
-    def objects(self):
-        # Return a new list so the objects cannot change while being iterated over.
-        return [obj for obj in self._objects if obj]
-
-    @property
-    def chunks(self):
-        return self._chunks.copy()
-
-    def add(self, obj):
-        assert hasattr(obj, "pos")
-        obj.pos = np.array(obj.pos)
-        assert self._obj_map[tuple(obj.pos)] == 0
-        index = len(self._objects)
-        self._objects.append(obj)
-        self._obj_map[tuple(obj.pos)] = index
-        self._chunks[self.chunk_key(obj.pos)].add(obj)
-
-    def remove(self, obj):
-        if obj.removed:
-            return
-        self._objects[self._obj_map[tuple(obj.pos)]] = None
-        self._obj_map[tuple(obj.pos)] = 0
-        self._chunks[self.chunk_key(obj.pos)].remove(obj)
-        obj.removed = True
-
-    def move(self, obj, pos):
-        if obj.removed:
-            return
-        pos = np.array(pos)
-        assert self._obj_map[tuple(pos)] == 0
-        index = self._obj_map[tuple(obj.pos)]
-        self._obj_map[tuple(pos)] = index
-        self._obj_map[tuple(obj.pos)] = 0
-        old_chunk = self.chunk_key(obj.pos)
-        new_chunk = self.chunk_key(pos)
-        if old_chunk != new_chunk:
-            self._chunks[old_chunk].remove(obj)
-            self._chunks[new_chunk].add(obj)
-        obj.pos = pos
-
-    def __setitem__(self, pos, material):
-        if material not in self._mat_ids:
-            id_ = len(self._mat_ids)
-            self._mat_ids[material] = id_
-        self._mat_map[tuple(pos)] = self._mat_ids[material]
-
-    def __getitem__(self, pos):
-        if not _inside((0, 0), pos, self.area):
-            return None, None
-        material = self._mat_names[self._mat_map[tuple(pos)]]
-        obj = self._objects[self._obj_map[tuple(pos)]]
-        return material, obj
-
-    def nearby(self, pos, distance):
-        (x, y), d = pos, distance
-        ids = set(self._mat_map[x - d : x + d + 1, y - d : y + d + 1].flatten().tolist())
-        materials = tuple(self._mat_names[x] for x in ids)
-        indices = self._obj_map[x - d : x + d + 1, y - d : y + d + 1].flatten().tolist()
-        objs = {self._objects[i] for i in indices if i > 0}
-        return materials, objs
-
-    def mask(self, xmin, xmax, ymin, ymax, material):
-        region = self._mat_map[xmin:xmax, ymin:ymax]
-        return region == self._mat_ids[material]
-
-    def count(self, material):
-        return (self._mat_map == self._mat_ids[material]).sum()
-
-    def chunk_key(self, pos):
-        (x, y), (csx, csy) = pos, self._chunk_size
-        xmin, ymin = (x // csx) * csx, (y // csy) * csy
-        xmax = min(xmin + csx, self.area[0])
-        ymax = min(ymin + csy, self.area[1])
-        return (xmin, xmax, ymin, ymax)
-
-
-class Textures:
-    def __init__(self, directory):
-        self._originals = {}
-        self._textures = {}
-        for filename in pathlib.Path(directory).glob("*.png"):
-            image = imageio.imread(filename.read_bytes())
-            image = image.transpose((1, 0) + tuple(range(2, len(image.shape))))
-            self._originals[filename.stem] = image
-            self._textures[(filename.stem, image.shape[:2])] = image
-
-    def get(self, name, size):
-        if name is None:
-            name = "unknown"
-        size = int(size[0]), int(size[1])
-        key = name, size
-        if key not in self._textures:
-            image = self._originals[name]
-            image = Image.fromarray(image)
-            image = image.resize(size[::-1], resample=Image.NEAREST)
-            image = np.array(image)
-            self._textures[key] = image
-        return self._textures[key]
-
-
-class GlobalView:
-    pass
-
-
-class UncoverView:
-    pass
-
-
-class LocalView:
-    def __init__(self, world, textures, grid):
-        self._world = world
-        self._textures = textures
-        self._grid = np.array(grid)
-        self._offset = self._grid // 2
-        self._area = np.array(self._world.area)
-        self._center = None
-
-    def __call__(self, player, unit):
-        self._unit = np.array(unit)
-        self._center = np.array(player.pos)
-        canvas = np.zeros(tuple(self._grid * unit) + (3,), np.uint8) + 127
-        for x in range(self._grid[0]):
-            for y in range(self._grid[1]):
-                pos = self._center + np.array([x, y]) - self._offset
-                if not _inside((0, 0), pos, self._area):
-                    continue
-                texture = self._textures.get(self._world[pos][0], unit)
-                _draw(canvas, np.array([x, y]) * unit, texture)
-        for obj in self._world.objects:
-            pos = obj.pos - self._center + self._offset
-            if not _inside((0, 0), pos, self._grid):
-                continue
-            texture = self._textures.get(obj.texture, unit)
-            _draw_alpha(canvas, pos * unit, texture)
-        canvas = self._light(canvas, self._world.daylight)
-        if player.sleeping:
-            canvas = self._sleep(canvas)
-        # if player.health < 1:
-        #   canvas = self._tint(canvas, (128, 0, 0), 0.6)
-        return canvas
-
-    def _light(self, canvas, daylight):
-        night = canvas
-        if daylight < 0.5:
-            night = self._noise(night, 2 * (0.5 - daylight), 0.5)
-        night = np.array(ImageEnhance.Color(Image.fromarray(night.astype(np.uint8))).enhance(0.4))
-        night = self._tint(night, (0, 16, 64), 0.5)
-        return daylight * canvas + (1 - daylight) * night
-
-    def _sleep(self, canvas):
-        canvas = np.array(ImageEnhance.Color(Image.fromarray(canvas.astype(np.uint8))).enhance(0.0))
-        canvas = self._tint(canvas, (0, 0, 16), 0.5)
-        return canvas
-
-    def _tint(self, canvas, color, amount):
-        color = np.array(color)
-        return (1 - amount) * canvas + amount * color
-
-    def _noise(self, canvas, amount, stddev):
-        noise = self._world.random.uniform(32, 127, canvas.shape[:2])[..., None]
-        mask = amount * self._vignette(canvas.shape, stddev)[..., None]
-        return (1 - mask) * canvas + mask * noise
-
-    @functools.lru_cache(10)
-    def _vignette(self, shape, stddev):
-        xs, ys = np.meshgrid(np.linspace(-1, 1, shape[0]), np.linspace(-1, 1, shape[1]))
-        return 1 - np.exp(-0.5 * (xs**2 + ys**2) / (stddev**2)).T
-
-
-class ItemView:
-    def __init__(self, textures, grid):
-        self._textures = textures
-        self._grid = np.array(grid)
-
-    def __call__(self, inventory, unit):
-        unit = np.array(unit)
-        canvas = np.zeros(tuple(self._grid * unit) + (3,), np.uint8)
-        for index, (item, amount) in enumerate(inventory.items()):
-            if amount < 1:
-                continue
-            self._item(canvas, index, item, unit)
-            self._amount(canvas, index, amount, unit)
-        return canvas
-
-    def _item(self, canvas, index, item, unit):
-        pos = index % self._grid[0], index // self._grid[0]
-        pos = (pos * unit + 0.1 * unit).astype(np.int32)
-        texture = self._textures.get(item, 0.8 * unit)
-        _draw_alpha(canvas, pos, texture)
-
-    def _amount(self, canvas, index, amount, unit):
-        pos = index % self._grid[0], index // self._grid[0]
-        pos = (pos * unit + 0.4 * unit).astype(np.int32)
-        text = str(amount) if amount in list(range(10)) else "unknown"
-        texture = self._textures.get(text, 0.6 * unit)
-        _draw_alpha(canvas, pos, texture)
-
-
-class SemanticView:
-    def __init__(self, world, obj_types):
-        self._world = world
-        self._mat_ids = world._mat_ids.copy()
-        self._obj_ids = {c: len(self._mat_ids) + i for i, c in enumerate(obj_types)}
-
-    def __call__(self):
-        canvas = self._world._mat_map.copy()
-        for obj in self._world.objects:
-            canvas[tuple(obj.pos)] = self._obj_ids[type(obj)]
-        return canvas
-
-
-def _inside(lhs, mid, rhs):
-    return (lhs[0] <= mid[0] < rhs[0]) and (lhs[1] <= mid[1] < rhs[1])
-
-
-def _draw(canvas, pos, texture):
-    (x, y), (w, h) = pos, texture.shape[:2]
-    if texture.shape[-1] == 4:
-        texture = texture[..., :3]
-    canvas[x : x + w, y : y + h] = texture
-
-
-def _draw_alpha(canvas, pos, texture):
-    (x, y), (w, h) = pos, texture.shape[:2]
-    if texture.shape[-1] == 4:
-        alpha = texture[..., 3:].astype(np.float32) / 255
-        texture = texture[..., :3].astype(np.float32) / 255
-        current = canvas[x : x + w, y : y + h].astype(np.float32) / 255
-        blended = alpha * texture + (1 - alpha) * current
-        texture = (255 * blended).astype(np.uint8)
-    canvas[x : x + w, y : y + h] = texture

synth_ai/environments/examples/crafter_custom/crafter/env.py

@@ -1,262 +0,0 @@
-import collections
-
-import numpy as np
-
-from . import constants, engine, objects, worldgen
-from .config import WorldGenConfig
-
-# Gym is an optional dependency.
-try:
-    import gym
-
-    DiscreteSpace = gym.spaces.Discrete
-    BoxSpace = gym.spaces.Box
-    DictSpace = gym.spaces.Dict
-    BaseClass = gym.Env
-except ImportError:
-    DiscreteSpace = collections.namedtuple("DiscreteSpace", "n")
-    BoxSpace = collections.namedtuple("BoxSpace", "low, high, shape, dtype")
-    DictSpace = collections.namedtuple("DictSpace", "spaces")
-    BaseClass = object
-
-
-class Env(BaseClass):
-    def __init__(
-        self,
-        area=(64, 64),
-        view=(9, 9),
-        size=(64, 64),
-        reward=True,
-        length=10000,
-        seed=None,
-        world_config=None,
-    ):
-        view = np.array(view if hasattr(view, "__len__") else (view, view))
-        size = np.array(size if hasattr(size, "__len__") else (size, size))
-        seed = np.random.randint(0, 2**31 - 1) if seed is None else seed
-        self._area = area
-        self._view = view
-        self._size = size
-        self._reward = reward
-        self._length = length
-        self._seed = seed
-        self._episode = 0
-
-        # Handle world configuration
-        if isinstance(world_config, str):
-            # Load from preset or file path
-            if world_config.endswith(".json"):
-                self._world_config = WorldGenConfig.from_json(world_config)
-            else:
-                self._world_config = WorldGenConfig.from_preset(world_config)
-        elif isinstance(world_config, dict):
-            self._world_config = WorldGenConfig(**world_config)
-        elif isinstance(world_config, WorldGenConfig):
-            self._world_config = world_config
-        else:
-            self._world_config = WorldGenConfig()  # Default config
-
-        self._world = engine.World(area, constants.materials, (12, 12))
-        self._world._config = self._world_config  # Pass config to world
-        self._textures = engine.Textures(constants.root / "assets")
-        item_rows = int(np.ceil(len(constants.items) / view[0]))
-        self._local_view = engine.LocalView(
-            self._world, self._textures, [view[0], view[1] - item_rows]
-        )
-        self._item_view = engine.ItemView(self._textures, [view[0], item_rows])
-        self._sem_view = engine.SemanticView(
-            self._world,
-            [
-                objects.Player,
-                objects.Cow,
-                objects.Zombie,
-                objects.Skeleton,
-                objects.Arrow,
-                objects.Plant,
-            ],
-        )
-        self._step = None
-        self._player = None
-        self._last_health = None
-        self._unlocked = None
-        # Some libraries expect these attributes to be set.
-        self.reward_range = None
-        self.metadata = None
-
-    @property
-    def observation_space(self):
-        return BoxSpace(0, 255, tuple(self._size) + (3,), np.uint8)
-
-    @property
-    def action_space(self):
-        return DiscreteSpace(len(constants.actions))
-
-    @property
-    def action_names(self):
-        return constants.actions
-
-    def reset(self):
-        center = (self._world.area[0] // 2, self._world.area[1] // 2)
-        self._episode += 1
-        self._step = 0
-        self._world.reset(seed=hash((self._seed, self._episode)) % (2**31 - 1))
-        self._update_time()
-        self._player = objects.Player(self._world, center)
-        self._last_health = self._player.health
-        self._world.add(self._player)
-        self._unlocked = set()
-        worldgen.generate_world(self._world, self._player)
-        return self._obs()
-
-    def step(self, action):
-        self._step += 1
-        self._update_time()
-        self._player.action = constants.actions[action]
-        for obj in self._world.objects:
-            if self._player.distance(obj) < 2 * max(self._view):
-                obj.update()
-        if self._step % 10 == 0:
-            for chunk, objs in self._world.chunks.items():
-                # xmin, xmax, ymin, ymax = chunk
-                # center = (xmax - xmin) // 2, (ymax - ymin) // 2
-                # if self._player.distance(center) < 4 * max(self._view):
-                self._balance_chunk(chunk, objs)
-        obs = self._obs()
-        reward = (self._player.health - self._last_health) / 10
-        self._last_health = self._player.health
-        unlocked = {
-            name
-            for name, count in self._player.achievements.items()
-            if count > 0 and name not in self._unlocked
-        }
-        if unlocked:
-            self._unlocked |= unlocked
-            reward += 1.0
-        dead = self._player.health <= 0
-        over = self._length and self._step >= self._length
-        done = dead or over
-        info = {
-            "inventory": self._player.inventory.copy(),
-            "achievements": self._player.achievements.copy(),
-            "discount": 1 - float(dead),
-            "semantic": self._sem_view(),
-            "player_pos": self._player.pos,
-            "reward": reward,
-        }
-        if not self._reward:
-            reward = 0.0
-        return obs, reward, done, info
-
-    def render(self, size=None):
-        size = size or self._size
-        unit = size // self._view
-        canvas = np.zeros(tuple(size) + (3,), np.uint8)
-        local_view = self._local_view(self._player, unit)
-        item_view = self._item_view(self._player.inventory, unit)
-        view = np.concatenate([local_view, item_view], 1)
-        border = (size - (size // self._view) * self._view) // 2
-        (x, y), (w, h) = border, view.shape[:2]
-        canvas[x : x + w, y : y + h] = view
-        return canvas.transpose((1, 0, 2))
-
-    def _obs(self):
-        return self.render()
-
-    def _update_time(self):
-        # https://www.desmos.com/calculator/grfbc6rs3h
-        progress = (self._step / 300) % 1 + 0.3
-        daylight = 1 - np.abs(np.cos(np.pi * progress)) ** 3
-        self._world.daylight = daylight
-
-    def _balance_chunk(self, chunk, objs):
-        light = self._world.daylight
-        config = self._world_config
-
-        # Zombies - daylight affects count
-        self._balance_object(
-            chunk,
-            objs,
-            objects.Zombie,
-            "grass",
-            config.zombie_min_spawn_distance,
-            0,
-            config.zombie_spawn_rate,
-            config.zombie_despawn_rate,
-            lambda pos: objects.Zombie(self._world, pos, self._player),
-            lambda num, space: (
-                0
-                if space < 50
-                else config.zombie_max_count
-                - (config.zombie_max_count - config.zombie_min_count) * light,
-                config.zombie_max_count
-                - (config.zombie_max_count - config.zombie_min_count) * light,
-            ),
-        )
-
-        # Skeletons - static count
-        self._balance_object(
-            chunk,
-            objs,
-            objects.Skeleton,
-            "path",
-            config.skeleton_min_spawn_distance,
-            config.skeleton_min_spawn_distance,
-            config.skeleton_spawn_rate,
-            config.skeleton_despawn_rate,
-            lambda pos: objects.Skeleton(self._world, pos, self._player),
-            lambda num, space: (
-                0 if space < 6 else config.skeleton_min_count,
-                config.skeleton_max_count,
-            ),
-        )
-
-        # Cows - daylight affects count positively
-        self._balance_object(
-            chunk,
-            objs,
-            objects.Cow,
-            "grass",
-            config.cow_min_spawn_distance,
-            config.cow_min_spawn_distance,
-            config.cow_spawn_rate,
-            config.cow_despawn_rate,
-            lambda pos: objects.Cow(self._world, pos),
-            lambda num, space: (
-                0 if space < 30 else config.cow_min_count,
-                config.cow_min_count + (config.cow_max_count - config.cow_min_count) * light,
-            ),
-        )
-
-    def _balance_object(
-        self,
-        chunk,
-        objs,
-        cls,
-        material,
-        span_dist,
-        despan_dist,
-        spawn_prob,
-        despawn_prob,
-        ctor,
-        target_fn,
-    ):
-        xmin, xmax, ymin, ymax = chunk
-        random = self._world.random
-        creatures = [obj for obj in objs if isinstance(obj, cls)]
-        mask = self._world.mask(*chunk, material)
-        target_min, target_max = target_fn(len(creatures), mask.sum())
-        if len(creatures) < int(target_min) and random.uniform() < spawn_prob:
-            xs = np.tile(np.arange(xmin, xmax)[:, None], [1, ymax - ymin])
-            ys = np.tile(np.arange(ymin, ymax)[None, :], [xmax - xmin, 1])
-            xs, ys = xs[mask], ys[mask]
-            i = random.randint(0, len(xs))
-            pos = np.array((xs[i], ys[i]))
-            empty = self._world[pos][1] is None
-            away = self._player.distance(pos) >= span_dist
-            if empty and away:
-                self._world.add(ctor(pos))
-        elif len(creatures) > int(target_max) and random.uniform() < despawn_prob:
-            obj = creatures[random.randint(0, len(creatures))]
-            away = self._player.distance(obj.pos) >= despan_dist
-            if away:
-                self._world.remove(obj)