synth-ai 0.2.4.dev4__py3-none-any.whl → 0.2.4.dev6__py3-none-any.whl

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

@@ -0,0 +1,266 @@
+import collections
+
+import numpy as np
+
+from . import constants
+from . import engine
+from . import objects
+from . import 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)

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

@@ -0,0 +1,418 @@
+import numpy as np
+
+from . import constants
+from . import engine
+
+
+class Object:
+    def __init__(self, world, pos):
+        self.world = world
+        self.pos = np.array(pos)
+        self.random = world.random
+        self.inventory = {"health": 0}
+        self.removed = False
+
+    @property
+    def texture(self):
+        raise "unknown"
+
+    @property
+    def walkable(self):
+        return constants.walkable
+
+    @property
+    def health(self):
+        return self.inventory["health"]
+
+    @health.setter
+    def health(self, value):
+        self.inventory["health"] = max(0, value)
+
+    @property
+    def all_dirs(self):
+        return ((-1, 0), (+1, 0), (0, -1), (0, +1))
+
+    def move(self, direction):
+        direction = np.array(direction)
+        target = self.pos + direction
+        if self.is_free(target):
+            self.world.move(self, target)
+            return True
+        return False
+
+    def is_free(self, target, materials=None):
+        materials = self.walkable if materials is None else materials
+        material, obj = self.world[target]
+        return obj is None and material in materials
+
+    def distance(self, target):
+        if hasattr(target, "pos"):
+            target = target.pos
+        return np.abs(target - self.pos).sum()
+
+    def toward(self, target, long_axis=True):
+        if hasattr(target, "pos"):
+            target = target.pos
+        offset = target - self.pos
+        dists = np.abs(offset)
+        if dists[0] > dists[1] if long_axis else dists[0] <= dists[1]:
+            return np.array((np.sign(offset[0]), 0))
+        else:
+            return np.array((0, np.sign(offset[1])))
+
+    def random_dir(self):
+        return self.all_dirs[self.random.randint(0, 4)]
+
+
+class Player(Object):
+    def __init__(self, world, pos):
+        super().__init__(world, pos)
+        self.facing = (0, 1)
+        self.inventory = {name: info["initial"] for name, info in constants.items.items()}
+        self.achievements = {name: 0 for name in constants.achievements}
+        self.action = "noop"
+        self.sleeping = False
+        self._last_health = self.health
+        self._hunger = 0
+        self._thirst = 0
+        self._fatigue = 0
+        self._recover = 0
+
+    @property
+    def texture(self):
+        if self.sleeping:
+            return "player-sleep"
+        return {
+            (-1, 0): "player-left",
+            (+1, 0): "player-right",
+            (0, -1): "player-up",
+            (0, +1): "player-down",
+        }[tuple(self.facing)]
+
+    @property
+    def walkable(self):
+        return constants.walkable + ["lava"]
+
+    def update(self):
+        target = (self.pos[0] + self.facing[0], self.pos[1] + self.facing[1])
+        material, obj = self.world[target]
+        action = self.action
+        if self.sleeping:
+            if self.inventory["energy"] < constants.items["energy"]["max"]:
+                action = "sleep"
+            else:
+                self.sleeping = False
+                self.achievements["wake_up"] += 1
+        if action == "noop":
+            pass
+        elif action.startswith("move_"):
+            self._move(action[len("move_") :])
+        elif action == "do" and obj:
+            self._do_object(obj)
+        elif action == "do":
+            self._do_material(target, material)
+        elif action == "sleep":
+            if self.inventory["energy"] < constants.items["energy"]["max"]:
+                self.sleeping = True
+        elif action.startswith("place_"):
+            self._place(action[len("place_") :], target, material)
+        elif action.startswith("make_"):
+            self._make(action[len("make_") :])
+        self._update_life_stats()
+        self._degen_or_regen_health()
+        for name, amount in self.inventory.items():
+            maxmium = constants.items[name]["max"]
+            self.inventory[name] = max(0, min(amount, maxmium))
+        # This needs to happen after the inventory states are clamped
+        # because it involves the health water inventory count.
+        self._wake_up_when_hurt()
+
+    def _update_life_stats(self):
+        self._hunger += 0.5 if self.sleeping else 1
+        if self._hunger > 25:
+            self._hunger = 0
+            self.inventory["food"] -= 1
+        self._thirst += 0.5 if self.sleeping else 1
+        if self._thirst > 20:
+            self._thirst = 0
+            self.inventory["drink"] -= 1
+        if self.sleeping:
+            self._fatigue = min(self._fatigue - 1, 0)
+        else:
+            self._fatigue += 1
+        if self._fatigue < -10:
+            self._fatigue = 0
+            self.inventory["energy"] += 1
+        if self._fatigue > 30:
+            self._fatigue = 0
+            self.inventory["energy"] -= 1
+
+    def _degen_or_regen_health(self):
+        necessities = (
+            self.inventory["food"] > 0,
+            self.inventory["drink"] > 0,
+            self.inventory["energy"] > 0 or self.sleeping,
+        )
+        if all(necessities):
+            self._recover += 2 if self.sleeping else 1
+        else:
+            self._recover -= 0.5 if self.sleeping else 1
+        if self._recover > 25:
+            self._recover = 0
+            self.health += 1
+        if self._recover < -15:
+            self._recover = 0
+            self.health -= 1
+
+    def _wake_up_when_hurt(self):
+        if self.health < self._last_health:
+            self.sleeping = False
+        self._last_health = self.health
+
+    def _move(self, direction):
+        directions = dict(left=(-1, 0), right=(+1, 0), up=(0, -1), down=(0, +1))
+        self.facing = directions[direction]
+        self.move(self.facing)
+        if self.world[self.pos][0] == "lava":
+            self.health = 0
+
+    def _do_object(self, obj):
+        damage = max(
+            [
+                1,
+                self.inventory["wood_sword"] and 2,
+                self.inventory["stone_sword"] and 3,
+                self.inventory["iron_sword"] and 5,
+            ]
+        )
+        if isinstance(obj, Plant):
+            if obj.ripe:
+                obj.grown = 0
+                self.inventory["food"] += 4
+                self.achievements["eat_plant"] += 1
+        if isinstance(obj, Fence):
+            self.world.remove(obj)
+            self.inventory["fence"] += 1
+            self.achievements["collect_fence"] += 1
+        if isinstance(obj, Zombie):
+            obj.health -= damage
+            if obj.health <= 0:
+                self.achievements["defeat_zombie"] += 1
+        if isinstance(obj, Skeleton):
+            obj.health -= damage
+            if obj.health <= 0:
+                self.achievements["defeat_skeleton"] += 1
+        if isinstance(obj, Cow):
+            obj.health -= damage
+            if obj.health <= 0:
+                self.inventory["food"] += 6
+                self.achievements["eat_cow"] += 1
+                # TODO: Keep track of previous inventory state to do this in a more
+                # general way.
+                self._hunger = 0
+
+    def _do_material(self, target, material):
+        if material == "water":
+            # TODO: Keep track of previous inventory state to do this in a more
+            # general way.
+            self._thirst = 0
+        info = constants.collect.get(material)
+        if not info:
+            return
+        for name, amount in info["require"].items():
+            if self.inventory[name] < amount:
+                return
+        self.world[target] = info["leaves"]
+        if self.random.uniform() <= info.get("probability", 1):
+            for name, amount in info["receive"].items():
+                self.inventory[name] += amount
+                self.achievements[f"collect_{name}"] += 1
+
+    def _place(self, name, target, material):
+        if self.world[target][1]:
+            return
+        info = constants.place[name]
+        if material not in info["where"]:
+            return
+        if any(self.inventory[k] < v for k, v in info["uses"].items()):
+            return
+        for item, amount in info["uses"].items():
+            self.inventory[item] -= amount
+        if info["type"] == "material":
+            self.world[target] = name
+        elif info["type"] == "object":
+            cls = {
+                "fence": Fence,
+                "plant": Plant,
+            }[name]
+            self.world.add(cls(self.world, target))
+        self.achievements[f"place_{name}"] += 1
+
+    def _make(self, name):
+        nearby, _ = self.world.nearby(self.pos, 1)
+        info = constants.make[name]
+        if not all(util in nearby for util in info["nearby"]):
+            return
+        if any(self.inventory[k] < v for k, v in info["uses"].items()):
+            return
+        for item, amount in info["uses"].items():
+            self.inventory[item] -= amount
+        self.inventory[name] += info["gives"]
+        self.achievements[f"make_{name}"] += 1
+
+
+class Cow(Object):
+    def __init__(self, world, pos):
+        super().__init__(world, pos)
+        self.health = 3
+
+    @property
+    def texture(self):
+        return "cow"
+
+    def update(self):
+        if self.health <= 0:
+            self.world.remove(self)
+        if self.random.uniform() < 0.5:
+            direction = self.random_dir()
+            self.move(direction)
+
+
+class Zombie(Object):
+    def __init__(self, world, pos, player):
+        super().__init__(world, pos)
+        self.player = player
+        self.health = 5
+        self.cooldown = 0
+
+    @property
+    def texture(self):
+        return "zombie"
+
+    def update(self):
+        if self.health <= 0:
+            self.world.remove(self)
+        dist = self.distance(self.player)
+        if dist <= 8 and self.random.uniform() < 0.9:
+            self.move(self.toward(self.player, self.random.uniform() < 0.8))
+        else:
+            self.move(self.random_dir())
+        dist = self.distance(self.player)
+        if dist <= 1:
+            if self.cooldown:
+                self.cooldown -= 1
+            else:
+                if self.player.sleeping:
+                    damage = 7
+                else:
+                    damage = 2
+                self.player.health -= damage
+                self.cooldown = 5
+
+
+class Skeleton(Object):
+    def __init__(self, world, pos, player):
+        super().__init__(world, pos)
+        self.player = player
+        self.health = 3
+        self.reload = 0
+
+    @property
+    def texture(self):
+        return "skeleton"
+
+    def update(self):
+        if self.health <= 0:
+            self.world.remove(self)
+        self.reload = max(0, self.reload - 1)
+        dist = self.distance(self.player.pos)
+        if dist <= 3:
+            moved = self.move(-self.toward(self.player, self.random.uniform() < 0.6))
+            if moved:
+                return
+        if dist <= 5 and self.random.uniform() < 0.5:
+            self._shoot(self.toward(self.player))
+        elif dist <= 8 and self.random.uniform() < 0.3:
+            self.move(self.toward(self.player, self.random.uniform() < 0.6))
+        elif self.random.uniform() < 0.2:
+            self.move(self.random_dir())
+
+    def _shoot(self, direction):
+        if self.reload > 0:
+            return
+        if direction[0] == 0 and direction[1] == 0:
+            return
+        pos = self.pos + direction
+        if self.is_free(pos, Arrow.walkable):
+            self.world.add(Arrow(self.world, pos, direction))
+            self.reload = 4
+
+
+class Arrow(Object):
+    def __init__(self, world, pos, facing):
+        super().__init__(world, pos)
+        self.facing = facing
+
+    @property
+    def texture(self):
+        return {
+            (-1, 0): "arrow-left",
+            (+1, 0): "arrow-right",
+            (0, -1): "arrow-up",
+            (0, +1): "arrow-down",
+        }[tuple(self.facing)]
+
+    @engine.staticproperty
+    def walkable():
+        return constants.walkable + ["water", "lava"]
+
+    def update(self):
+        target = self.pos + self.facing
+        material, obj = self.world[target]
+        if obj:
+            obj.health -= 2
+            self.world.remove(self)
+        elif material not in self.walkable:
+            self.world.remove(self)
+            if material in ["table", "furnace"]:
+                self.world[target] = "path"
+        else:
+            self.move(self.facing)
+
+
+class Plant(Object):
+    def __init__(self, world, pos):
+        super().__init__(world, pos)
+        self.health = 1
+        self.grown = 0
+
+    @property
+    def texture(self):
+        if self.ripe:
+            return "plant-ripe"
+        else:
+            return "plant"
+
+    @property
+    def ripe(self):
+        return self.grown > 300
+
+    def update(self):
+        self.grown += 1
+        objs = [self.world[self.pos + dir_][1] for dir_ in self.all_dirs]
+        if any(isinstance(obj, (Zombie, Skeleton, Cow)) for obj in objs):
+            self.health -= 1
+        if self.health <= 0:
+            self.world.remove(self)
+
+
+class Fence(Object):
+    def __init__(self, world, pos):
+        super().__init__(world, pos)
+
+    @property
+    def texture(self):
+        return "fence"
+
+    def update(self):
+        pass