initial commit

5 files changed, 1265 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..5761abc
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+*.o
diff --git a/src/cli-main.c b/src/cli-main.c
new file mode 100644
index 0000000..00853e7
--- /dev/null
+++ b/src/cli-main.c
@@ -0,0 +1,193 @@
+#include <stdbool.h> // bool
+#include <string.h> // atoi()
+#include <stdlib.h> // EXIT_{FAILURE,SUCCESS}
+#include <stdio.h>
+#include "sok.h"
+
+#define UNUSED(a) ((void) (a))
+
+static const char * const
+LEVELS[] = {
+  "#####|#@$.#|#####|",
+  "#######|###.###|###$###|#.$@$.#|###$###|###.###|#######",
+};
+#define NUM_LEVELS (sizeof(LEVELS) / sizeof(char*))
+
+static char print_buf[(SOK_LEVEL_MAX_WIDTH + 1) * SOK_LEVEL_MAX_HEIGHT + 1];
+
+static bool
+on_size(
+  const sok_ctx_t * const ctx, 
+  const sok_pos_t size,
+  void * const data
+) {
+  UNUSED(ctx);
+  UNUSED(data);
+
+  // fprintf(stderr, "size: x = %u, y = %u\n", size.x, size.y);
+
+  memset(print_buf, ' ', sizeof(print_buf));
+  print_buf[(size.x + 1) * size.y + 1] = '\0';
+  for (size_t i = 0; i < size.y; i++) {
+    print_buf[(i + 1) * (size.x + 1) - 1] = '\n';
+  }
+
+  return true;
+}
+
+static bool
+on_home(
+  const sok_ctx_t * const ctx, 
+  const sok_pos_t pos,
+  const bool has_goal,
+  void * const data
+) {
+  UNUSED(data);
+  print_buf[pos.y * (ctx->level.size.x + 1) + pos.x] = has_goal ? '+' : '@';
+  return true;
+}
+
+static bool
+on_wall(
+  const sok_ctx_t * const ctx, 
+  const sok_pos_t pos,
+  void * const data
+) {
+  // fprintf(stderr, "wall: x = %u, y = %u\n", pos.x, pos.y);
+  UNUSED(data);
+  print_buf[pos.y * (ctx->level.size.x + 1) + pos.x] = '#';
+  return true;
+}
+
+static bool
+on_goal(
+  const sok_ctx_t * const ctx, 
+  const sok_pos_t pos,
+  const bool has_player,
+  const bool has_box,
+  void * const data
+) {
+  UNUSED(data);
+  const char c = has_player ? '+' : (has_box ? '*' : '.');
+  print_buf[pos.y * (ctx->level.size.x + 1) + pos.x] = c;
+  return true;
+}
+
+static bool
+on_box(
+  const sok_ctx_t * const ctx, 
+  const sok_pos_t pos,
+  const bool has_goal,
+  void * const data
+) {
+  UNUSED(data);
+  print_buf[pos.y * (ctx->level.size.x + 1) + pos.x] = has_goal ? '*' : '$';
+  return true;
+}
+
+static sok_ctx_walk_cbs_t PRINT_CBS = {
+  .on_size = on_size,
+  .on_home = on_home,
+  .on_wall = on_wall,
+  .on_goal = on_goal,
+  .on_box =  on_box,
+};
+
+static void
+print_level(
+  const sok_ctx_t * const ctx
+) {
+  // fill buffer
+  if (!sok_ctx_walk(ctx, &PRINT_CBS, NULL)) {
+    fprintf(stderr, "Couldn't print level\n");
+    exit(EXIT_FAILURE);
+  }
+
+  // print level
+  printf("%s\n", print_buf);
+}
+
+int main(int argc, char *argv[]) {
+  size_t level = (argc > 1) ? atoi(argv[1]) : 0;
+
+  // init context
+  sok_ctx_t ctx;
+  sok_ctx_init(&ctx, NULL);
+
+  if (!sok_ctx_set_level(&ctx, LEVELS[level])) {
+    fprintf(stderr, "Couldn't load level %zu\n", level);
+    return EXIT_FAILURE;
+  }
+
+  char buf[1024];
+  bool done = false;
+  while (!done) {
+    print_level(&ctx);
+    for (size_t i = 0; i < ctx.level.num_boxes; i++) {
+      fprintf(stderr, "ctx->boxes[i] = {%u, %u}\n", ctx.boxes[i].x, ctx.boxes[i].y);
+    }
+    printf("%zu%s> ", ctx.num_moves, sok_ctx_is_done(&ctx) ? " (won!)" : "");
+
+    if (!fgets(buf, sizeof(buf), stdin)) {
+      done = true;
+      break;
+    }
+
+    switch (buf[0]) {
+    case EOF:
+    case 'q':
+      done = true;
+      break;
+    case 'k':
+      if (!sok_ctx_move(&ctx, SOK_DIR_UP)) {
+        fprintf(stderr, "W: move up failed\n");
+      }
+
+      break;
+    case 'h':
+      if (!sok_ctx_move(&ctx, SOK_DIR_LEFT)) {
+        fprintf(stderr, "W: move left failed\n");
+      }
+
+      break;
+    case 'j':
+      if (!sok_ctx_move(&ctx, SOK_DIR_DOWN)) {
+        fprintf(stderr, "W: move down failed\n");
+      }
+
+      break;
+    case 'l':
+      if (!sok_ctx_move(&ctx, SOK_DIR_RIGHT)) {
+        fprintf(stderr, "W: move right failed\n");
+      }
+
+      break;
+    case 'u':
+      if (!sok_ctx_undo(&ctx)) {
+        fprintf(stderr, "W: undo failed\n");
+      }
+
+      break;
+    case 'n':
+      if (sok_ctx_is_done(&ctx)) {
+        // advance level
+        level = (level + 1) % NUM_LEVELS;
+
+        // load next level
+        if (!sok_ctx_set_level(&ctx, LEVELS[level])) {
+          fprintf(stderr, "Couldn't load level %zu\n", level);
+          return EXIT_FAILURE;
+        }
+      } else {
+        fprintf(stderr, "W: cannot advance to next level\n");
+      }
+
+      break;
+    default:
+      // ignore
+      break;
+    }
+  }
+
+  return 0;
+}
diff --git a/src/sok-ctx.c b/src/sok-ctx.c
new file mode 100644
index 0000000..e4a922b
--- /dev/null
+++ b/src/sok-ctx.c
@@ -0,0 +1,731 @@
+#include <stdbool.h>
+#include <stdio.h> // debugging
+#include <string.h> // memset()
+#include "sok.h"
+
+#define UNUSED(a) ((void) (a))
+
+#define VALID_POS(pos) ( \
+  (pos).x < SOK_LEVEL_MAX_WIDTH && \
+  (pos).y < SOK_LEVEL_MAX_HEIGHT \
+)
+
+#define POINTS_EQUAL(a, b) ( \
+  ((a).x == (b).x) && \
+  ((a).y == (b).y) \
+)
+
+static bool
+on_size(
+  const sok_level_parser_t * const parser,
+  const sok_pos_t pos
+) {
+  sok_ctx_t *ctx = (sok_ctx_t*) parser->user_data;
+
+  if (!VALID_POS(pos)) {
+    // size out of bounds
+    return false;
+  }
+
+  // save width and height
+  ctx->level.size = pos;
+
+  // return success
+  return true;
+}
+
+static bool
+on_home(
+  const sok_level_parser_t * const parser,
+  const sok_pos_t pos
+) {
+  sok_ctx_t *ctx = (sok_ctx_t*) parser->user_data;
+
+  if (!VALID_POS(pos)) {
+    // position out of bounds
+    return false;
+  }
+
+  // save start position
+  ctx->level.home = pos;
+
+  // return success
+  return true;
+}
+
+static bool
+on_wall(
+  const sok_level_parser_t * const parser,
+  const sok_pos_t pos
+) {
+  sok_ctx_t *ctx = (sok_ctx_t*) parser->user_data;
+
+  if (!VALID_POS(pos)) {
+    // position out of bounds
+    return false;
+  }
+
+  // save wall
+  ctx->level.walls[pos.y * ctx->level.size.x + pos.x] = true;
+
+  // return sucess
+  return true;
+}
+
+static bool
+on_goal(
+  const sok_level_parser_t * const parser,
+  const sok_pos_t pos
+) {
+  sok_ctx_t *ctx = (sok_ctx_t*) parser->user_data;
+
+  if (!VALID_POS(pos)) {
+    // position out of bounds
+    return false;
+  }
+
+  if (ctx->level.num_goals >= SOK_LEVEL_MAX_GOALS - 1) {
+    // too many goals
+    return false;
+  }
+
+  // save goal
+  ctx->level.goals[ctx->level.num_goals++] = pos;
+
+  // return sucess
+  return true;
+}
+
+static bool
+on_box(
+  const sok_level_parser_t * const parser,
+  const sok_pos_t pos
+) {
+  sok_ctx_t *ctx = (sok_ctx_t*) parser->user_data;
+
+  if (!VALID_POS(pos)) {
+    // position out of bounds
+    return false;
+  }
+
+  if (ctx->level.num_boxes >= SOK_LEVEL_MAX_BOXES - 1) {
+    // too many boxes
+    return false;
+  }
+
+  // save box
+  ctx->level.boxes[ctx->level.num_boxes++] = pos;
+
+  // return sucess
+  return true;
+}
+
+static bool
+on_junk(
+  const sok_level_parser_t * const parser,
+  const size_t ofs,
+  const char tile
+) {
+  UNUSED(parser);
+  UNUSED(ofs);
+  UNUSED(tile);
+
+  // TODO
+
+  // return sucess
+  return true;
+}
+
+static const sok_level_parser_cbs_t
+LEVEL_PARSER_CBS = {
+  .on_size = on_size,
+  .on_home = on_home,
+  .on_wall = on_wall,
+  .on_goal = on_goal,
+  .on_box  = on_box,
+  .on_junk = on_junk,
+};
+
+void
+sok_ctx_init(sok_ctx_t * const ctx, void *user_data) {
+  memset(ctx, 0, sizeof(sok_ctx_t));
+  ctx->user_data = user_data;
+}
+
+bool
+sok_ctx_set_level(
+  sok_ctx_t * const ctx,
+  const char * const str
+) {
+
+  // clear level
+  ctx->level.num_goals = 0;
+  ctx->level.num_boxes = 0;
+  memset(ctx->level.walls, 0, SOK_LEVEL_MAX_WIDTH * SOK_LEVEL_MAX_HEIGHT);
+
+  // parse level
+  sok_level_parser_t parser;
+  sok_level_parser_init(&parser, &LEVEL_PARSER_CBS, ctx);
+  if (!sok_level_parser_parse(&parser, str, strlen(str))) {
+    // return failure
+    return false;
+  }
+
+  // init moves
+  ctx->num_moves = 0;
+
+  // init player
+  ctx->home = ctx->level.home;
+
+  // init boxes
+  memcpy(ctx->boxes, ctx->level.boxes, ctx->level.num_boxes * sizeof(sok_pos_t));
+
+  // return success
+  return true;
+}
+
+static bool
+tile_is_floor(
+  const sok_ctx_t * const ctx,
+  const sok_pos_t pos
+) {
+  return (
+    (pos.x < SOK_LEVEL_MAX_WIDTH - 1) &&
+    (pos.y < SOK_LEVEL_MAX_HEIGHT - 1) &&
+    !(ctx->level.walls[pos.y * ctx->level.size.x + pos.x])
+  );
+}
+
+static bool
+tile_is_box(
+  const sok_ctx_t * const ctx,
+  const sok_pos_t pos
+) {
+  for (size_t i = 0; i < ctx->level.num_boxes; i++) {
+    // fprintf(stderr, "D: ctx->boxes[%zu] = {%u, %u}\n", i, ctx->boxes[i].x, ctx->boxes[i].y);
+    if (POINTS_EQUAL(ctx->boxes[i], pos)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+static bool
+tile_is_goal(
+  const sok_ctx_t * const ctx,
+  const sok_pos_t pos
+) {
+  for (size_t i = 0; i < ctx->level.num_goals; i++) {
+    if (POINTS_EQUAL(pos, ctx->level.goals[i])) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+static bool
+sok_can_move(
+  sok_ctx_t * const ctx,
+  const sok_dir_t dir
+) {
+  if (ctx->num_moves >= SOK_CTX_MAX_MOVES - 1) {
+    // no more move slots available
+    return false;
+  }
+
+  if (dir == SOK_DIR_UP) {
+    const sok_pos_t ps[2] = {
+      { .x = ctx->home.x, .y = ctx->home.y - 1 },
+      { .x = ctx->home.x, .y = ctx->home.y - 2 },
+    };
+
+    fprintf(
+      stderr,
+      "D: ctx->home = {%u, %u}, ps[] = {{%u, %u}, {%u, %u}};\n"
+      "D: tile_is_floor(ctx, ps[0]) = %c, tile_is_box(ctx, ps[0]) = %c\n"
+      "D: tile_is_floor(ctx, ps[1]) = %c, tile_is_box(ctx, ps[1]) = %c\n"
+      "",
+      ctx->home.x, ctx->home.y,
+      ps[0].x, ps[0].y,
+      ps[1].x, ps[1].y,
+      tile_is_floor(ctx, ps[0]) ? 't' : 'f',
+      tile_is_box(ctx, ps[0]) ? 't' : 'f',
+      tile_is_floor(ctx, ps[1]) ? 't' : 'f',
+      tile_is_box(ctx, ps[1]) ? 't' : 'f'
+    );
+
+    return ((
+      (ctx->home.y > 0) &&
+      tile_is_floor(ctx, ps[0]) &&
+      !tile_is_box(ctx, ps[0])
+    ) || (
+      (ctx->home.y > 1) &&
+      tile_is_floor(ctx, ps[0]) &&
+      tile_is_box(ctx, ps[0]) &&
+      tile_is_floor(ctx, ps[1]) &&
+      !tile_is_box(ctx, ps[1])
+    ));
+  } else if (dir == SOK_DIR_DOWN) {
+    const sok_pos_t ps[2] = {
+      { .x = ctx->home.x, .y = ctx->home.y + 1 },
+      { .x = ctx->home.x, .y = ctx->home.y + 2 },
+    };
+
+    return ((
+      (ctx->home.y < SOK_LEVEL_MAX_HEIGHT - 1) &&
+      tile_is_floor(ctx, ps[0]) &&
+      !tile_is_box(ctx, ps[0])
+    ) || (
+      (ctx->home.y < SOK_LEVEL_MAX_HEIGHT - 2) &&
+      tile_is_floor(ctx, ps[0]) &&
+      tile_is_box(ctx, ps[0]) &&
+      tile_is_floor(ctx, ps[1]) &&
+      !tile_is_box(ctx, ps[1])
+    ));
+  } else if (dir == SOK_DIR_LEFT) {
+    const sok_pos_t ps[2] = {
+      { .x = ctx->home.x - 1, .y = ctx->home.y },
+      { .x = ctx->home.x - 2, .y = ctx->home.y },
+    };
+
+    return ((
+      (ctx->home.x > 0) &&
+      tile_is_floor(ctx, ps[0]) &&
+      !tile_is_box(ctx, ps[0])
+    ) || (
+      (ctx->home.x > 1) &&
+      tile_is_floor(ctx, ps[0]) &&
+      tile_is_box(ctx, ps[0]) &&
+      tile_is_floor(ctx, ps[1]) &&
+      !tile_is_box(ctx, ps[1])
+    ));
+  } else if (dir == SOK_DIR_RIGHT) {
+    const sok_pos_t ps[2] = {
+      { .x = ctx->home.x + 1, .y = ctx->home.y },
+      { .x = ctx->home.x + 2, .y = ctx->home.y },
+    };
+
+    return ((
+      (ctx->home.x < SOK_LEVEL_MAX_WIDTH - 1) &&
+      tile_is_floor(ctx, ps[0]) &&
+      !tile_is_box(ctx, ps[0])
+    ) || (
+      (ctx->home.x < SOK_LEVEL_MAX_WIDTH - 2) &&
+      tile_is_floor(ctx, ps[0]) &&
+      tile_is_box(ctx, ps[0]) &&
+      tile_is_floor(ctx, ps[1]) &&
+      !tile_is_box(ctx, ps[1])
+    ));
+  }
+
+  // return failure
+  return false;
+}
+
+static bool
+sok_ctx_push_move(
+  sok_ctx_t * const ctx,
+  const sok_dir_t dir,
+  const bool is_push
+) {
+  if (ctx->num_moves >= SOK_CTX_MAX_MOVES - 1) {
+    return false;
+  }
+
+  ctx->moves[ctx->num_moves].pos = ctx->home;
+  ctx->moves[ctx->num_moves].dir = dir;
+  ctx->moves[ctx->num_moves].is_push = is_push;
+  ctx->num_moves++;
+
+  return true;
+}
+
+static bool
+sok_ctx_pop_move(
+  sok_ctx_t * const ctx,
+  sok_move_t * const ret
+) {
+  if (!ctx->num_moves) {
+    // return failure
+    return false;
+  }
+
+  // decriment moves
+  ctx->num_moves--;
+
+  if (ret) {
+    // save popped move
+    *ret = ctx->moves[ctx->num_moves];
+  }
+
+  // return success
+  return true;
+}
+
+static bool
+sok_ctx_move_box(
+  sok_ctx_t * const ctx,
+  const sok_pos_t old_pos,
+  const sok_pos_t new_pos
+) {
+  for (size_t i = 0; i < ctx->level.num_boxes; i++) {
+    if (POINTS_EQUAL(ctx->boxes[i], old_pos)) {
+      ctx->boxes[i] = new_pos;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool
+sok_ctx_is_done(
+  sok_ctx_t * const ctx
+) {
+  for (size_t i = 0; i < ctx->level.num_goals; i++) {
+    bool on_goal = false;
+
+    for (size_t j = 0; !on_goal && j < ctx->level.num_boxes; j++) {
+      if (POINTS_EQUAL(ctx->level.goals[i], ctx->boxes[j])) {
+        // found box on this goal
+        on_goal = true;
+      }
+    }
+
+    if (!on_goal) {
+      // no box on this goal, return false
+      return false;
+    }
+  }
+
+  // return success
+  return true;
+}
+
+bool
+sok_ctx_move(
+  sok_ctx_t * const ctx,
+  const sok_dir_t dir
+) {
+  if (!sok_can_move(ctx, dir)) {
+    fprintf(stderr, "can_move failed\n");
+    return false;
+  }
+
+  if (dir == SOK_DIR_UP) {
+    const sok_pos_t ps[2] = {
+      { .x = ctx->home.x, .y = ctx->home.y - 1 },
+      { .x = ctx->home.x, .y = ctx->home.y - 2 },
+    };
+
+    if (
+      (ctx->home.y > 0) &&
+      tile_is_floor(ctx, ps[0]) &&
+      !tile_is_box(ctx, ps[0])
+    ) { 
+      // push move
+      if (!sok_ctx_push_move(ctx, dir, false)) {
+        return false;
+      }
+
+      // update position
+      ctx->home.y--;
+
+      // return success
+      return true;
+    } else if (
+      (ctx->home.y > 1) &&
+      tile_is_floor(ctx, ps[0]) &&
+      tile_is_box(ctx, ps[0]) &&
+      tile_is_floor(ctx, ps[1]) &&
+      !tile_is_box(ctx, ps[1])
+    ) { 
+      // push move
+      if (!sok_ctx_push_move(ctx, dir, true)) {
+        return false;
+      }
+
+      // move box
+      if (!sok_ctx_move_box(ctx, ps[0], ps[1])) {
+        return false;
+      }
+
+      // update position
+      ctx->home.y--;
+
+      // return success
+      return true;
+    }
+  } else if (dir == SOK_DIR_DOWN) {
+    const sok_pos_t ps[2] = {
+      { .x = ctx->home.x, .y = ctx->home.y + 1 },
+      { .x = ctx->home.x, .y = ctx->home.y + 2 },
+    };
+
+    if (
+      (ctx->home.y < SOK_LEVEL_MAX_HEIGHT - 1) &&
+      tile_is_floor(ctx, ps[0]) &&
+      !tile_is_box(ctx, ps[0])
+    ) {
+      // push move
+      if (!sok_ctx_push_move(ctx, dir, false)) {
+        return false;
+      }
+
+      // update position
+      ctx->home.y++;
+
+      // return success
+      return true;
+    } else if (
+      (ctx->home.y < SOK_LEVEL_MAX_HEIGHT - 2) &&
+      tile_is_floor(ctx, ps[0]) &&
+      tile_is_box(ctx, ps[0]) &&
+      tile_is_floor(ctx, ps[1]) &&
+      !tile_is_box(ctx, ps[1])
+    ) {
+      // push move
+      if (!sok_ctx_push_move(ctx, dir, true)) {
+        return false;
+      }
+
+      // move box
+      if (!sok_ctx_move_box(ctx, ps[0], ps[1])) {
+        return false;
+      }
+
+      // update position
+      ctx->home.y++;
+
+      // return success
+      return true;
+    }
+  } else if (dir == SOK_DIR_LEFT) {
+    const sok_pos_t ps[2] = {
+      { .x = ctx->home.x - 1, .y = ctx->home.y },
+      { .x = ctx->home.x - 2, .y = ctx->home.y },
+    };
+
+    if (
+      (ctx->home.x > 1) &&
+      tile_is_floor(ctx, ps[0]) &&
+      !tile_is_box(ctx, ps[0])
+    ) { 
+      // push move
+      if (!sok_ctx_push_move(ctx, dir, false)) {
+        return false;
+      }
+
+      // update position
+      ctx->home.x--;
+
+      // return success
+      return true;
+    } else if (
+      (ctx->home.x > 1) &&
+      tile_is_floor(ctx, ps[0]) &&
+      tile_is_box(ctx, ps[0]) &&
+      tile_is_floor(ctx, ps[1]) &&
+      !tile_is_box(ctx, ps[1])
+    ) {
+      // push move
+      if (!sok_ctx_push_move(ctx, dir, true)) {
+        return false;
+      }
+
+      // move box
+      if (!sok_ctx_move_box(ctx, ps[0], ps[1])) {
+        return false;
+      }
+
+      // update position
+      ctx->home.x--;
+
+      // return success
+      return true;
+    }
+  } else if (dir == SOK_DIR_RIGHT) {
+    const sok_pos_t ps[2] = {
+      { .x = ctx->home.x + 1, .y = ctx->home.y },
+      { .x = ctx->home.x + 2, .y = ctx->home.y },
+    };
+
+    if (
+      (ctx->home.x < SOK_LEVEL_MAX_WIDTH - 1) &&
+      tile_is_floor(ctx, ps[0]) &&
+      !tile_is_box(ctx, ps[0])
+    ) {
+      // push move
+      if (!sok_ctx_push_move(ctx, dir, false)) {
+        return false;
+      }
+
+      // update position
+      ctx->home.x++;
+
+      // return success
+      return true;
+    } else if (
+      (ctx->home.x < SOK_LEVEL_MAX_WIDTH - 2) &&
+      tile_is_floor(ctx, ps[0]) &&
+      tile_is_box(ctx, ps[0]) && 
+      tile_is_floor(ctx, ps[1]) &&
+      !tile_is_box(ctx, ps[1])
+    ) {
+      // push move
+      if (!sok_ctx_push_move(ctx, dir, true)) {
+        return false;
+      }
+
+      // move box
+      if (!sok_ctx_move_box(ctx, ps[0], ps[1])) {
+        return false;
+      }
+
+      // update position
+      ctx->home.x++;
+
+      // return success
+      return true;
+    }
+  }
+
+  // return failure
+  return false;
+}
+
+bool
+sok_ctx_undo(
+  sok_ctx_t * const ctx
+) {
+  sok_move_t move;
+  if (!sok_ctx_pop_move(ctx, &move)) {
+    // return failure
+    return false;
+  }
+
+  if (move.is_push) {
+    switch (move.dir) {
+    case SOK_DIR_UP:
+      {
+        const sok_pos_t box_pos = { move.pos.x, move.pos.y - 2 };
+        sok_ctx_move_box(ctx, box_pos, ctx->home);
+      }
+
+      break;
+    case SOK_DIR_DOWN:
+      {
+        const sok_pos_t box_pos = { move.pos.x, move.pos.y + 2 };
+        sok_ctx_move_box(ctx, box_pos, ctx->home);
+      }
+
+      break;
+    case SOK_DIR_LEFT:
+      {
+        const sok_pos_t box_pos = { move.pos.x - 2, move.pos.y };
+        sok_ctx_move_box(ctx, box_pos, ctx->home);
+      }
+
+      break;
+    case SOK_DIR_RIGHT:
+      {
+        const sok_pos_t box_pos = { move.pos.x + 2, move.pos.y };
+        sok_ctx_move_box(ctx, box_pos, ctx->home);
+      }
+
+      break;
+    default:
+      // never reached
+      return false;
+    }
+  }
+
+  // update position
+  ctx->home = move.pos;
+
+  // return success
+  return true;
+}
+
+bool sok_ctx_walk(
+  const sok_ctx_t * const ctx,
+  const sok_ctx_walk_cbs_t * const cbs,
+  void * const data
+) {
+  if (!cbs) {
+    return false;
+  }
+
+  if (cbs->on_size) {
+    // emit size
+    if (!cbs->on_size(ctx, ctx->level.size, data)) {
+      return false;
+    }
+  }
+
+  if (cbs->on_home) {
+    const bool has_goal = tile_is_goal(ctx, ctx->home);
+
+    // emit home
+    if (!cbs->on_home(ctx, ctx->home, has_goal, data)) {
+      return false;
+    }
+  }
+
+  if (cbs->on_wall) {
+    // walk walls
+    for (size_t i = 0; i < (ctx->level.size.x * ctx->level.size.y); i++) {
+      if (ctx->level.walls[i]) {
+        const sok_pos_t pos = {
+          .y = i / ctx->level.size.x,
+          .x = i % ctx->level.size.x,
+        };
+
+        // emit wall
+        if (!cbs->on_wall(ctx, pos, data)) {
+          return false;
+        }
+      }
+    }
+  }
+
+  if (cbs->on_goal) {
+    // walk goals
+    for (size_t i = 0; i < ctx->level.num_goals; i++) {
+      const bool has_player = POINTS_EQUAL(ctx->level.goals[i], ctx->home);
+      const bool has_box = tile_is_box(ctx, ctx->level.goals[i]);
+
+      // emit goal
+      if (!cbs->on_goal(ctx, ctx->level.goals[i], has_player, has_box, data)) {
+        return false;
+      }
+    }
+  }
+
+  if (cbs->on_box) {
+    // walk boxes
+    for (size_t i = 0; i < ctx->level.num_boxes; i++) {
+      const bool has_goal = tile_is_goal(ctx, ctx->boxes[i]);
+
+      // emit box
+      if (!cbs->on_box(ctx, ctx->boxes[i], has_goal, data)) {
+        return false;
+      }
+    }
+  }
+
+  if (cbs->on_move) {
+    // walk moves
+    for (size_t i = 0; i < ctx->num_moves; i++) {
+      // emit move
+      if (!cbs->on_move(ctx, ctx->moves[i], data)) {
+        return false;
+      }
+    }
+  }
+
+  // return success
+  return true;
+}
diff --git a/src/sok-level-parser.c b/src/sok-level-parser.c
new file mode 100644
index 0000000..eec08c3
--- /dev/null
+++ b/src/sok-level-parser.c
@@ -0,0 +1,159 @@
+#include <stdbool.h>
+#include <stddef.h> // size_t
+#include "sok.h"
+
+#define UNUSED(a) ((void) (a))
+
+void
+sok_level_parser_init(
+  sok_level_parser_t * const parser, 
+  const sok_level_parser_cbs_t * const cbs,
+  void * const user_data
+) {
+  parser->cbs = cbs;
+  parser->user_data = user_data;
+}
+
+bool
+sok_level_parser_parse(
+  sok_level_parser_t * const parser,
+  const char * const buf,
+  const size_t buf_len
+) {
+  sok_pos_t size = { .x = 0, .y = 0 };
+
+  for (size_t i = 0, w = 0; i < buf_len; i++) {
+    if (buf[i] == '|') {
+      if (w > size.x) {
+        size.x = w;
+      }
+
+      // reset column position, increment row count
+      w = 0;
+      size.y++;
+    } else {
+      w++;
+    }
+  }
+
+  // increment row count
+  size.y++;
+
+  // emit level size
+  if (
+    parser->cbs->on_size &&
+    !parser->cbs->on_size(parser, size) 
+  ) {
+    // return failure
+    return false;
+  }
+
+  sok_pos_t pos = { 0, 0 };
+  for (size_t i = 0; i < buf_len; i++) {
+    switch (buf[i]) {
+    case '|':
+      // new line
+      pos.x = 0;
+      pos.y++;
+
+      break;
+    case '-':
+    case '_':
+    case ' ':
+      // advance
+      pos.x++;
+
+      break;
+    case '+':
+      // emit goal
+      if (parser->cbs->on_goal && !parser->cbs->on_goal(parser, pos)) {
+        // return failure
+        return false;
+      }
+
+      // emit home
+      if (parser->cbs->on_home && !parser->cbs->on_home(parser, pos)) {
+        // return failure
+        return false;
+      }
+
+      // advance
+      pos.x++;
+
+      break;
+    case '@':
+      // emit home
+      if (parser->cbs->on_home && !parser->cbs->on_home(parser, pos)) {
+        // return failure
+        return false;
+      }
+
+      // advance
+      pos.x++;
+
+      break;
+    case '#':
+      // emit wall
+      if (parser->cbs->on_wall && !parser->cbs->on_wall(parser, pos)) {
+        // return failure
+        return false;
+      }
+
+      // advance
+      pos.x++;
+
+      break;
+    case '*':
+      // emit goal
+      if (parser->cbs->on_goal && !parser->cbs->on_goal(parser, pos)) {
+        // return failure
+        return false;
+      }
+
+      // emit box
+      if (parser->cbs->on_box && !parser->cbs->on_box(parser, pos)) {
+        // return failure
+        return false;
+      }
+
+      // advance
+      pos.x++;
+
+      break;
+    case '.':
+      // emit goal
+      if (parser->cbs->on_goal && !parser->cbs->on_goal(parser, pos)) {
+        // return failure
+        return false;
+      }
+
+      // advance
+      pos.x++;
+
+      break;
+    case '$':
+      // emit box
+      if (parser->cbs->on_box && !parser->cbs->on_box(parser, pos)) {
+        // return failure
+        return false;
+      }
+
+      // advance
+      pos.x++;
+
+      break;
+    default:
+      // emit junk
+      if (parser->cbs->on_junk && !parser->cbs->on_junk(parser, i, buf[i])) {
+        // return failure
+        return false;
+      }
+
+      // return failure
+      return false;
+    }
+  }
+
+  // return success
+  return true;
+}
diff --git a/src/sok.h b/src/sok.h
new file mode 100644
index 0000000..7635ead
--- /dev/null
+++ b/src/sok.h
@@ -0,0 +1,181 @@
+#ifndef SOK_H
+#define SOK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <stdint.h> // uint16_t
+
+/*********/
+/* types */
+/*********/
+
+typedef struct {
+  uint16_t x, y;
+} sok_pos_t;
+
+typedef enum {
+  SOK_DIR_RIGHT,
+  SOK_DIR_UP,
+  SOK_DIR_LEFT,
+  SOK_DIR_DOWN,
+  SOK_DIR_LAST,
+} sok_dir_t;
+
+typedef struct {
+  sok_pos_t pos;
+  sok_dir_t dir;
+  _Bool is_push;
+} sok_move_t;
+
+/****************/
+/* level parser */
+/****************/
+
+typedef struct sok_level_parser_t_ sok_level_parser_t;
+
+typedef bool (*sok_level_parser_pos_cb_t)(
+  const sok_level_parser_t * const,
+  const sok_pos_t
+);
+
+typedef bool (*sok_level_parser_junk_cb_t)(
+  const sok_level_parser_t * const,
+  const size_t,
+  const char
+);
+
+typedef struct {
+  sok_level_parser_pos_cb_t on_size,
+                            on_home,
+                            on_wall,
+                            on_goal,
+                            on_box;
+  sok_level_parser_junk_cb_t on_junk;
+} sok_level_parser_cbs_t;
+
+struct sok_level_parser_t_ {
+  const sok_level_parser_cbs_t *cbs;
+  void *user_data;
+};
+
+void sok_level_parser_init(
+  sok_level_parser_t * const parser, 
+  const sok_level_parser_cbs_t * const cbs,
+  void * const user_data
+);
+
+bool sok_level_parser_parse(
+  sok_level_parser_t * const parser,
+  const char * const buf,
+  const size_t buf_len
+);
+
+/*********/
+/* level */
+/*********/
+
+#define SOK_LEVEL_MAX_WIDTH (1 << 8)
+#define SOK_LEVEL_MAX_HEIGHT (1 << 8)
+#define SOK_LEVEL_MAX_BOXES 64
+#define SOK_LEVEL_MAX_GOALS 64
+
+typedef struct {
+  sok_pos_t size;
+  _Bool walls[SOK_LEVEL_MAX_WIDTH * SOK_LEVEL_MAX_HEIGHT];
+
+  // player home position
+  sok_pos_t home;
+
+  // boxes
+  sok_pos_t boxes[SOK_LEVEL_MAX_BOXES];
+  size_t num_boxes;
+
+  // goals
+  sok_pos_t goals[SOK_LEVEL_MAX_GOALS];
+  size_t num_goals;
+} sok_level_t;
+
+/***********/
+/* context */
+/***********/
+
+#define SOK_CTX_MAX_MOVES 1024
+
+typedef struct {
+  sok_level_t level;
+
+  sok_move_t moves[SOK_CTX_MAX_MOVES];
+  size_t num_moves;
+
+  // player position
+  sok_pos_t home;
+
+  // box positions
+  sok_pos_t boxes[SOK_LEVEL_MAX_BOXES];
+
+  // user data
+  void *user_data;
+} sok_ctx_t;
+
+void sok_ctx_init(sok_ctx_t * const ctx, void *user_data);
+
+_Bool sok_ctx_set_level(sok_ctx_t * const ctx, const char * const level);
+
+_Bool sok_ctx_is_done(sok_ctx_t * const);
+
+_Bool sok_ctx_move(sok_ctx_t * const, const sok_dir_t);
+_Bool sok_ctx_undo(sok_ctx_t * const);
+
+/******************/
+/* context walker */
+/******************/
+
+typedef _Bool (*sok_ctx_walk_pos_cb_t)(
+  const sok_ctx_t * const,
+  const sok_pos_t,
+  void * const
+);
+
+typedef _Bool (*sok_ctx_walk_tile_cb_t)(
+  const sok_ctx_t * const,
+  const sok_pos_t,
+  const _Bool,
+  void * const
+);
+
+typedef _Bool (*sok_ctx_walk_goal_cb_t)(
+  const sok_ctx_t * const,
+  const sok_pos_t,
+  const _Bool has_player,
+  const _Bool has_box,
+  void * const
+);
+
+typedef _Bool (*sok_ctx_walk_move_cb_t)(
+  const sok_ctx_t * const,
+  const sok_move_t,
+  void * const
+);
+
+typedef struct {
+  sok_ctx_walk_pos_cb_t on_size,
+                        on_wall;
+  sok_ctx_walk_tile_cb_t on_home,
+                         on_box;
+  sok_ctx_walk_goal_cb_t on_goal;
+  sok_ctx_walk_move_cb_t on_move;
+} sok_ctx_walk_cbs_t;
+
+_Bool sok_ctx_walk(
+  const sok_ctx_t * const,
+  const sok_ctx_walk_cbs_t * const,
+  void * const
+);
+
+#ifdef __cplusplus
+};
+#endif /* __cplusplus */
+
+#endif /* SOK_H */