mettagrid 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

build/mettagrid/objects/agent.hpp

@@ -93,6 +93,10 @@ public:
         this->current_resource_reward = new_reward;
     }
 
+    virtual bool swappable() const override {
+        return this->frozen;
+    }
+
     virtual void obs(ObsType* obs, const std::vector<unsigned int> &offsets) const override {
         obs[offsets[0]] = 1;
         obs[offsets[1]] = group;

build/mettagrid/objects/constants.hpp

@@ -33,18 +33,22 @@ enum ObjectType {
 };
 
 enum InventoryItem {
-    ore = 0,
-    battery = 1,
-    heart = 2,
-    armor = 3,
-    laser = 4,
-    blueprint = 5,
-    InventoryCount = 6
+    ore_red = 0,
+    ore_blue =1,
+    ore_green = 2,
+    battery = 3,
+    heart = 4,
+    armor = 5,
+    laser = 6,
+    blueprint = 7,
+    InventoryCount = 8
 };
 
 // These should be const, but we run into type inference issues with cython
 std::vector<std::string> InventoryItemNames = {
-    "ore",
+    "ore.red",
+    "ore.blue",
+    "ore.green",
     "battery",
     "heart",
     "armor",
@@ -55,8 +59,13 @@ std::vector<std::string> InventoryItemNames = {
 std::vector<std::string> ObjectTypeNames = {
     "agent",
     "wall",
-    "mine",
-    "generator",
+    "block",
+    "mine.red",
+    "mine.blue",
+    "mine.green",
+    "generator.red",
+    "generator.blue",
+    "generator.green",
     "altar",
     "armory",
     "lasery",

build/mettagrid/objects/converter.hpp

@@ -62,6 +62,7 @@ public:
     unsigned char cooldown;        // Time to wait after producing before starting again
     bool converting;               // Currently in production phase
     bool cooling_down;             // Currently in cooldown phase
+    unsigned char color;
     EventManager *event_manager;
 
     Converter(GridCoord r, GridCoord c, ObjectConfig cfg, TypeId type_id) {
@@ -77,6 +78,7 @@ public:
         this->max_output = cfg["max_output"];
         this->conversion_ticks = cfg["conversion_ticks"];
         this->cooldown = cfg["cooldown"];
+        this->color = cfg.count("color") ? cfg["color"] : 0;
         this->converting = false;
         this->cooling_down = false;
 
@@ -130,7 +132,8 @@ public:
     void obs(ObsType *obs, const std::vector<unsigned int> &offsets) const override {
         obs[offsets[0]] = 1;
         obs[offsets[1]] = this->hp;
-        obs[offsets[2]] = this->converting || this->cooling_down;
+        obs[offsets[2]] = this->color;
+        obs[offsets[3]] = this->converting || this->cooling_down;
         for (unsigned int i = 0; i < InventoryItem::InventoryCount; i++) {
             obs[offsets[3] + i] = this->inventory[i];
         }
@@ -143,6 +146,7 @@ public:
         // we expect converters to be hard coded.
         names.push_back("converter");
         names.push_back("hp");
+        names.push_back("color");
         names.push_back("converting");
         for (unsigned int i = 0; i < InventoryItem::InventoryCount; i++) {
             names.push_back("inv:" + InventoryItemNames[i]);

build/mettagrid/objects/generator.hpp

@@ -12,6 +12,10 @@ class Generator : public Converter {
 public:
     Generator(GridCoord r, GridCoord c, ObjectConfig cfg) : Converter(r, c, cfg, ObjectType::GeneratorT) {}
 
+    void obs(ObsType *obs, const std::vector<unsigned int> &offsets) const override {
+        Converter::obs(obs, offsets);
+    }
+
     static std::vector<std::string> feature_names() {
         auto names = Converter::feature_names();
         names[0] = "generator";

build/mettagrid/objects/metta_object.hpp

@@ -15,7 +15,11 @@ public:
         this->hp = cfg["hp"];
     }
 
-    virtual bool has_inventory() {
+    virtual bool has_inventory() { // TODO: make const
+        return false;
+    }
+
+    virtual bool swappable() const {
         return false;
     }
 };

build/mettagrid/objects/mine.hpp

@@ -10,8 +10,13 @@
 
 class Mine : public Converter {
 public:
+
     Mine(GridCoord r, GridCoord c, ObjectConfig cfg) : Converter(r, c, cfg, ObjectType::MineT) {}
 
+    void obs(ObsType *obs, const std::vector<unsigned int> &offsets) const override {
+        Converter::obs(obs, offsets);
+    }
+
     static std::vector<std::string> feature_names() {
         auto names = Converter::feature_names();
         names[0] = "mine";
@@ -19,4 +24,5 @@ public:
     }
 };
 
+
 #endif

build/mettagrid/objects/wall.hpp

@@ -6,24 +6,34 @@
 #include "../grid_object.hpp"
 #include "constants.hpp"
 #include "metta_object.hpp"
+
 class Wall : public MettaObject {
 public:
+    bool _swappable;
+
     Wall(GridCoord r, GridCoord c, ObjectConfig cfg) {
         GridObject::init(ObjectType::WallT, GridLocation(r, c, GridLayer::Object_Layer));
         MettaObject::init_mo(cfg);
+        this->_swappable = cfg["swappable"];
     }
 
     virtual void obs(ObsType *obs, const std::vector<unsigned int> &offsets) const override {
         obs[offsets[0]] = 1;
         obs[offsets[1]] = this->hp;
+        obs[offsets[2]] = this->_swappable;
     }
 
     static std::vector<std::string> feature_names() {
         std::vector<std::string> names;
         names.push_back("wall");
         names.push_back("hp");
+        names.push_back("swappable");
         return names;
     }
+
+    virtual bool swappable() const override {
+        return this->_swappable;
+    }
 };
 
 #endif

mettagrid/actions/swap.pyx

@@ -9,6 +9,8 @@ from mettagrid.objects.agent cimport Agent
 from mettagrid.grid_object cimport GridLocation, GridObjectId, Orientation, GridObject
 from mettagrid.action cimport ActionHandler, ActionArg
 from mettagrid.actions.actions cimport MettaActionHandler
+from mettagrid.objects.metta_object cimport MettaObject
+from mettagrid.objects.constants cimport GridLayer
 
 cdef class Swap(MettaActionHandler):
     def __init__(self, cfg: OmegaConf):
@@ -25,13 +27,17 @@ cdef class Swap(MettaActionHandler):
 
         cdef GridLocation target_loc = self.env._grid.relative_location(
             actor.location,
-        <Orientation>actor.orientation
+            <Orientation>actor.orientation
         )
-        cdef Agent *target = <Agent*>self.env._grid.object_at(target_loc)
+        cdef MettaObject *target
+        target = <MettaObject*>self.env._grid.object_at(target_loc)
+        if target == NULL:
+            target_loc.layer = GridLayer.Object_Layer
+            target = <MettaObject*>self.env._grid.object_at(target_loc)
         if target == NULL:
             return False
 
-        if not target.frozen:
+        if not target.swappable():
             return False
 
         self.env._grid.swap_objects(actor.id, target.id)

mettagrid/config/config.py

@@ -10,36 +10,28 @@ import warnings
 
 warnings.warn("This config.py file is deprecated", DeprecationWarning)
 
-def seed_everything(seed, torch_deterministic):
-    random.seed(seed)
-    np.random.seed(seed)
-    if seed is not None:
-        torch.manual_seed(seed)
-    torch.backends.cudnn.deterministic = torch_deterministic
-
 def uniform(min_val, max_val, center, *, _root_):
-    sampling = _root_.get("sampling", 0)
+    sampling = _root_["sampling"]
     if sampling == 0:
         return center
-    else:
 
-        center = (max_val + min_val) // 2
-        # Calculate the available range on both sides of the center
-        left_range = center - min_val
-        right_range = max_val - center
+    center = (max_val + min_val) // 2
+    # Calculate the available range on both sides of the center
+    left_range = center - min_val
+    right_range = max_val - center
 
-        # Scale the ranges based on the sampling parameter
-        scaled_left = min(left_range, sampling * left_range)
-        scaled_right = min(right_range, sampling * right_range)
+    # Scale the ranges based on the sampling parameter
+    scaled_left = min(left_range, sampling * left_range)
+    scaled_right = min(right_range, sampling * right_range)
 
-        # Generate a random value within the scaled range
-        val = np.random.uniform(center - scaled_left, center + scaled_right)
+    # Generate a random value within the scaled range
+    val = np.random.uniform(center - scaled_left, center + scaled_right)
 
-        # Clip to ensure we stay within [min_val, max_val]
-        val = np.clip(val, min_val, max_val)
+    # Clip to ensure we stay within [min_val, max_val]
+    val = np.clip(val, min_val, max_val)
 
-        # Return integer if the original values were integers
-        return int(round(val)) if isinstance(center, int) else val
+    # Return integer if the original values were integers
+    return int(round(val)) if isinstance(center, int) else val
 
 def choose(*args):
     return random.choice(args)
@@ -53,29 +45,3 @@ def sub(a, b):
 def make_odd(a):
     return max(3, a // 2 * 2 + 1)
 
-def setup_omega_conf():
-    OmegaConf.register_new_resolver("div", div, replace=True)
-    OmegaConf.register_new_resolver("uniform", uniform, replace=True)
-    OmegaConf.register_new_resolver("sub", sub, replace=True)
-    OmegaConf.register_new_resolver("make_odd", make_odd, replace=True)
-    OmegaConf.register_new_resolver("choose", choose, replace=True)
-
-def setup_metta_environment(cfg):
-    # Set environment variables to run without display
-    os.environ['GLFW_PLATFORM'] = 'osmesa'  # Use OSMesa as the GLFW backend
-    os.environ['SDL_VIDEODRIVER'] = 'dummy'
-    os.environ['MPLBACKEND'] = 'Agg'
-    os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = '1'
-    os.environ['DISPLAY'] = ''
-
-    # Suppress deprecation warnings
-    warnings.filterwarnings('ignore', category=DeprecationWarning)
-    warnings.filterwarnings('ignore', category=DeprecationWarning, module='pkg_resources')
-    warnings.filterwarnings('ignore', category=DeprecationWarning, module='pygame.pkgdata')
-
-    setup_omega_conf()
-    # print(OmegaConf.to_yaml(cfg))
-    traceback.install(show_locals=False)
-    seed_everything(cfg.seed, cfg.torch_deterministic)
-    os.makedirs(cfg.run_dir, exist_ok=True)
-    signal.signal(signal.SIGINT, lambda sig, frame: os._exit(0))

mettagrid/grid_env.pyx

@@ -16,6 +16,7 @@ from mettagrid.grid_object cimport (
 )
 from mettagrid.observation_encoder cimport ObservationEncoder, ObsType
 from mettagrid.objects.production_handler cimport ProductionHandler, CoolDownHandler
+from mettagrid.objects.constants cimport ObjectTypeNames
 
 # Constants
 obs_np_type = np.uint8
@@ -309,3 +310,6 @@ cdef class GridEnv:
 
     def action_success(self):
         return self._action_success
+
+    def object_type_names(self):
+        return ObjectTypeNames

mettagrid/mettagrid.pyx

@@ -114,11 +114,20 @@ cdef class MettaGrid(GridEnv):
                     wall = new Wall(r, c, cfg.objects.wall)
                     self._grid.add_object(wall)
                     self._stats.incr(b"objects.wall")
-
-                elif map[r,c] == "mine":
-                    converter = new Mine(r, c, cfg.objects.mine)
-                elif map[r,c] == "generator":
-                    converter = new Generator(r, c, cfg.objects.generator)
+                elif map[r,c] == "block":
+                    block = new Wall(r, c, cfg.objects.block)
+                    self._grid.add_object(block)
+                    self._stats.incr(b"objects.block")
+                elif map[r,c].startswith("mine"):
+                    m = map[r,c]
+                    if "." not in m:
+                        m = "mine.red"
+                    converter = new Mine(r, c, cfg.objects[m])
+                elif map[r,c].startswith("generator"):
+                    m = map[r,c]
+                    if "." not in m:
+                        m = "generator.red"
+                    converter = new Generator(r, c, cfg.objects[m])
                 elif map[r,c] == "altar":
                     converter = new Altar(r, c, cfg.objects.altar)
                 elif map[r,c] == "armory":

mettagrid/mettagrid_env.py

@@ -1,20 +1,22 @@
 import copy
+import random
 from typing import Any, Dict
 
 import gymnasium as gym
 import hydra
 import numpy as np
-from mettagrid.config.config import setup_omega_conf
+from torch import sub
+from mettagrid.config.config import make_odd
 import pufferlib
 from omegaconf import OmegaConf, DictConfig
 
 from mettagrid.mettagrid_c import MettaGrid  # pylint: disable=E0611
-
-
+from mettagrid.config import config
+from util.config import config_from_path
 class MettaGridEnv(pufferlib.PufferEnv, gym.Env):
     def __init__(self, env_cfg: DictConfig, render_mode: str, buf=None, **kwargs):
         self._render_mode = render_mode
-        self._cfg = env_cfg
+        self._cfg_template = env_cfg
         self.make_env()
         self.should_reset = False
         self._renderer = None
@@ -22,8 +24,10 @@ class MettaGridEnv(pufferlib.PufferEnv, gym.Env):
         super().__init__(buf)
 
     def make_env(self):
-        self._env_cfg = copy.deepcopy(self._cfg)
+        self._env_cfg = OmegaConf.create(copy.deepcopy(self._cfg_template))
+
         OmegaConf.resolve(self._env_cfg)
+
         self._map_builder = hydra.utils.instantiate(self._env_cfg.game.map_builder)
         env_map = self._map_builder.build()
         map_agents = np.count_nonzero(np.char.startswith(env_map, "agent"))
@@ -59,7 +63,7 @@ class MettaGridEnv(pufferlib.PufferEnv, gym.Env):
         self.actions[:] = np.array(actions).astype(np.uint32)
         self._c_env.step(self.actions)
 
-        if self._cfg.normalize_rewards:
+        if self._env_cfg.normalize_rewards:
             self.rewards -= self.rewards.mean()
 
         infos = {}
@@ -157,12 +161,57 @@ class MettaGridEnv(pufferlib.PufferEnv, gym.Env):
     def action_success(self):
         return np.asarray(self._c_env.action_success())
 
+    def object_type_names(self):
+        return self._c_env.object_type_names()
+
     def close(self):
         pass
 
 
 def make_env_from_cfg(cfg_path: str, *args, **kwargs):
-    setup_omega_conf()
-    cfg = OmegaConf.load(cfg_path)
+    cfg = config_from_path(cfg_path)
     env = MettaGridEnv(cfg, *args, **kwargs)
     return env
+
+
+def oc_uniform(min_val, max_val, center, *, _root_):
+    sampling = _root_.get("sampling", 0)
+    if sampling == 0:
+        return center
+    else:
+
+        center = (max_val + min_val) // 2
+        # Calculate the available range on both sides of the center
+        left_range = center - min_val
+        right_range = max_val - center
+
+        # Scale the ranges based on the sampling parameter
+        scaled_left = min(left_range, sampling * left_range)
+        scaled_right = min(right_range, sampling * right_range)
+
+        # Generate a random value within the scaled range
+        val = np.random.uniform(center - scaled_left, center + scaled_right)
+
+        # Clip to ensure we stay within [min_val, max_val]
+        val = np.clip(val, min_val, max_val)
+
+        # Return integer if the original values were integers
+        return int(round(val)) if isinstance(center, int) else val
+
+def oc_choose(*args):
+    return random.choice(args)
+
+def oc_div(a, b):
+    return a // b
+
+def oc_sub(a, b):
+    return a - b
+
+def oc_make_odd(a):
+    return max(3, a // 2 * 2 + 1)
+
+OmegaConf.register_new_resolver("div", oc_div, replace=True)
+OmegaConf.register_new_resolver("uniform", oc_uniform, replace=True)
+OmegaConf.register_new_resolver("sub", oc_sub, replace=True)
+OmegaConf.register_new_resolver("make_odd", oc_make_odd, replace=True)
+OmegaConf.register_new_resolver("choose", oc_choose, replace=True)

mettagrid/objects/agent.hpp

@@ -93,6 +93,10 @@ public:
         this->current_resource_reward = new_reward;
     }
 
+    virtual bool swappable() const override {
+        return this->frozen;
+    }
+
     virtual void obs(ObsType* obs, const std::vector<unsigned int> &offsets) const override {
         obs[offsets[0]] = 1;
         obs[offsets[1]] = group;

mettagrid/objects/constants.hpp

@@ -33,18 +33,22 @@ enum ObjectType {
 };
 
 enum InventoryItem {
-    ore = 0,
-    battery = 1,
-    heart = 2,
-    armor = 3,
-    laser = 4,
-    blueprint = 5,
-    InventoryCount = 6
+    ore_red = 0,
+    ore_blue =1,
+    ore_green = 2,
+    battery = 3,
+    heart = 4,
+    armor = 5,
+    laser = 6,
+    blueprint = 7,
+    InventoryCount = 8
 };
 
 // These should be const, but we run into type inference issues with cython
 std::vector<std::string> InventoryItemNames = {
-    "ore",
+    "ore.red",
+    "ore.blue",
+    "ore.green",
     "battery",
     "heart",
     "armor",
@@ -55,8 +59,13 @@ std::vector<std::string> InventoryItemNames = {
 std::vector<std::string> ObjectTypeNames = {
     "agent",
     "wall",
-    "mine",
-    "generator",
+    "block",
+    "mine.red",
+    "mine.blue",
+    "mine.green",
+    "generator.red",
+    "generator.blue",
+    "generator.green",
     "altar",
     "armory",
     "lasery",

mettagrid/objects/converter.hpp

@@ -62,6 +62,7 @@ public:
     unsigned char cooldown;        // Time to wait after producing before starting again
     bool converting;               // Currently in production phase
     bool cooling_down;             // Currently in cooldown phase
+    unsigned char color;
     EventManager *event_manager;
 
     Converter(GridCoord r, GridCoord c, ObjectConfig cfg, TypeId type_id) {
@@ -77,6 +78,7 @@ public:
         this->max_output = cfg["max_output"];
         this->conversion_ticks = cfg["conversion_ticks"];
         this->cooldown = cfg["cooldown"];
+        this->color = cfg.count("color") ? cfg["color"] : 0;
         this->converting = false;
         this->cooling_down = false;
 
@@ -130,7 +132,8 @@ public:
     void obs(ObsType *obs, const std::vector<unsigned int> &offsets) const override {
         obs[offsets[0]] = 1;
         obs[offsets[1]] = this->hp;
-        obs[offsets[2]] = this->converting || this->cooling_down;
+        obs[offsets[2]] = this->color;
+        obs[offsets[3]] = this->converting || this->cooling_down;
         for (unsigned int i = 0; i < InventoryItem::InventoryCount; i++) {
             obs[offsets[3] + i] = this->inventory[i];
         }
@@ -143,6 +146,7 @@ public:
         // we expect converters to be hard coded.
         names.push_back("converter");
         names.push_back("hp");
+        names.push_back("color");
         names.push_back("converting");
         for (unsigned int i = 0; i < InventoryItem::InventoryCount; i++) {
             names.push_back("inv:" + InventoryItemNames[i]);

mettagrid/objects/generator.hpp

@@ -12,6 +12,10 @@ class Generator : public Converter {
 public:
     Generator(GridCoord r, GridCoord c, ObjectConfig cfg) : Converter(r, c, cfg, ObjectType::GeneratorT) {}
 
+    void obs(ObsType *obs, const std::vector<unsigned int> &offsets) const override {
+        Converter::obs(obs, offsets);
+    }
+
     static std::vector<std::string> feature_names() {
         auto names = Converter::feature_names();
         names[0] = "generator";

mettagrid/objects/metta_object.hpp

@@ -15,7 +15,11 @@ public:
         this->hp = cfg["hp"];
     }
 
-    virtual bool has_inventory() {
+    virtual bool has_inventory() { // TODO: make const
+        return false;
+    }
+
+    virtual bool swappable() const {
         return false;
     }
 };

mettagrid/objects/metta_object.pxd

@@ -9,3 +9,4 @@ cdef extern from "metta_object.hpp":
         unsigned int hp
         void init_mo(ObjectConfig cfg)
         bint has_inventory()
+        bint swappable()

mettagrid/objects/mine.hpp

@@ -10,8 +10,13 @@
 
 class Mine : public Converter {
 public:
+
     Mine(GridCoord r, GridCoord c, ObjectConfig cfg) : Converter(r, c, cfg, ObjectType::MineT) {}
 
+    void obs(ObsType *obs, const std::vector<unsigned int> &offsets) const override {
+        Converter::obs(obs, offsets);
+    }
+
     static std::vector<std::string> feature_names() {
         auto names = Converter::feature_names();
         names[0] = "mine";
@@ -19,4 +24,5 @@ public:
     }
 };
 
+
 #endif