5.0

config/maze.ini

@@ -8,7 +8,6 @@ num_buffers = 5.96311
 num_threads = 2
 
 [env]
-max_size = 47
 num_maps = 8192
 map_size = -1
 

ocean/maze/binding.c

@@ -16,7 +16,7 @@ Env* my_vec_init(int* num_envs_out, int* buffer_env_starts, int* buffer_env_coun
     int agents_per_buffer = total_agents / num_buffers;
     int num_envs = total_agents;
 
-    int max_size = (int)dict_get(env_kwargs, "max_size")->value;
+    int max_size = MAX_SIZE;
     int num_maps = (int)dict_get(env_kwargs, "num_maps")->value;
     int map_size = (int)dict_get(env_kwargs, "map_size")->value;
 
@@ -28,11 +28,6 @@ Env* my_vec_init(int* num_envs_out, int* buffer_env_starts, int* buffer_env_coun
     // Generate maze levels (shared across all envs)
     State* levels = calloc(num_maps, sizeof(State));
 
-    // Temporary env used to generate maps
-    Grid temp_env;
-    temp_env.max_size = max_size;
-    init_maze(&temp_env);
-
     unsigned int map_rng = 42;
     for (int i = 0; i < num_maps; i++) {
         int sz = map_size;
@@ -44,17 +39,14 @@ Env* my_vec_init(int* num_envs_out, int* buffer_env_starts, int* buffer_env_coun
             sz -= 1;
         }
 
+        State* level = &levels[i];
+        level->width = sz;
+        level->height = sz;
+
         float difficulty = (float)rand_r(&map_rng) / (float)(RAND_MAX);
-        create_maze_level(&temp_env, sz, sz, difficulty, i);
-        init_state(&levels[i], max_size, 1);
-        get_state(&temp_env, &levels[i]);
+        create_maze_level(level, difficulty, i);
     }
 
-    // Free temp env internal allocations
-    free(temp_env.maze);
-    free(temp_env.counts);
-    free(temp_env.agents);
-
     // Allocate all environments
     Env* envs = (Env*)calloc(num_envs, sizeof(Env));
 
@@ -63,14 +55,13 @@ Env* my_vec_init(int* num_envs_out, int* buffer_env_starts, int* buffer_env_coun
     buffer_env_starts[0] = 0;
     buffer_env_counts[0] = 0;
 
+    unsigned int env_rng = 42;
     for (int i = 0; i < num_envs; i++) {
         Env* env = &envs[i];
-        env->rng = i;
-        env->max_size = max_size;
-        env->num_maps = num_maps;
+        env->num_levels = num_maps;
         env->num_agents = 1;
         env->levels = levels;
-        init_maze(env);
+        env->rng = rand_r(&env_rng);
 
         buf_agents += env->num_agents;
         buffer_env_counts[buf]++;
@@ -91,10 +82,8 @@ void my_vec_close(Env* envs) {
 }
 
 void my_init(Env* env, Dict* kwargs) {
-    env->max_size = (int)dict_get(kwargs, "max_size")->value;
-    env->num_maps = (int)dict_get(kwargs, "num_maps")->value;
+    env->num_levels = (int)dict_get(kwargs, "num_maps")->value;
     env->num_agents = 1;
-    init_maze(env);
 }
 
 void my_log(Log* log, Dict* out) {

ocean/maze/maze.c

@@ -6,55 +6,54 @@ void demo() {
     int logit_sizes[1] = {5};
     PufferNet* net = make_puffernet(weights, 1, 121, 512, 5, logit_sizes, 1);
 
-    int max_size = 47;
     int num_maps = 64;
-    int num_agents = 1;
     int horizon = 256;
     float speed = 1;
     int vision = 5;
     bool discretize = true;
 
-    Grid* env = allocate_maze(max_size, num_agents, horizon,
-        vision, speed, discretize);
+    Grid* env = (Grid*)calloc(1, sizeof(Grid));
+    env->num_agents = 1;
+    env->rng = 73;
+    env->observations = calloc(WINDOW*WINDOW, sizeof(unsigned char));
+    env->actions = calloc(1, sizeof(float));
+    env->rewards = calloc(1, sizeof(float));
+    env->terminals = calloc(1, sizeof(float));
 
     // Generate maps matching binding.c: random odd sizes, random difficulty
     State* levels = calloc(num_maps, sizeof(State));
-    Grid temp_env;
-    temp_env.max_size = max_size;
-    init_maze(&temp_env);
     unsigned int map_rng = 42;
     for (int i = 0; i < num_maps; i++) {
-        int sz = 5 + (rand_r(&map_rng) % (max_size - 5));
+        int sz = 5 + (rand_r(&map_rng) % (MAX_SIZE - 5));
         if (sz % 2 == 0) sz -= 1;
         float difficulty = (float)rand_r(&map_rng) / (float)(RAND_MAX);
-        create_maze_level(&temp_env, sz, sz, difficulty, i);
-        init_state(&levels[i], max_size, num_agents);
-        get_state(&temp_env, &levels[i]);
+        State* level = &levels[i];
+        level->width = sz;
+        level->height = sz;
+        create_maze_level(level, difficulty, i);
     }
-    free(temp_env.maze);
 
-    env->num_maps = num_maps;
+    env->num_levels = num_maps;
     env->levels = levels;
 
     c_reset(env);
     c_render(env);
     while (!WindowShouldClose()) {
         env->actions[0] = ATN_PASS;
-        Agent* agent = &env->agents[0];
+        env->actions[0] = ATN_SOUTH;
+        State* s = &env->state;
 
         if (IsKeyDown(KEY_LEFT_SHIFT)) {
             if (IsKeyDown(KEY_UP)    || IsKeyDown(KEY_W)){
-                agent->direction = 3.0*PI/2.0;
-                env->actions[0] = ATN_FORWARD;
+                env->actions[0] = ATN_NORTH;
             } else if (IsKeyDown(KEY_DOWN)  || IsKeyDown(KEY_S)) {
-                agent->direction = PI/2.0;
-                env->actions[0] = ATN_FORWARD;
+                env->actions[0] = ATN_SOUTH;
             } else if (IsKeyDown(KEY_LEFT)  || IsKeyDown(KEY_A)) {
-                agent->direction = PI;
-                env->actions[0] = ATN_FORWARD;
+                s->direction = PI;
+                env->actions[0] = ATN_WEST;
             } else if (IsKeyDown(KEY_RIGHT) || IsKeyDown(KEY_D)) {
-                agent->direction = 0;
-                env->actions[0] = ATN_FORWARD;
+                s->direction = 0;
+                env->actions[0] = ATN_EAST;
             } else {
                 env->actions[0] = ATN_PASS;
             }
@@ -70,8 +69,11 @@ void demo() {
 
     free_puffernet(net);
     free(weights);
-    free_allocated_maze(env);
-    for (int i = 0; i < num_maps; i++) free_state(&levels[i]);
+    free(env->observations);
+    free(env->actions);
+    free(env->rewards);
+    free(env->terminals);
+    c_close(env);
     free(levels);
 }