Merge pull request 'various: implement fog of war; make enemy AI slightly more intelligent' (#14) from notashelf/push-wlxxmonulyzt into main

Reviewed-on: NotAShelf/rogged#14
Reviewed-by: A.M. Rowsell <amr@noreply.localhost>

build.zig

@@ -25,6 +25,7 @@ pub fn build(b: *std.Build) void {
         "src/main.c",
         "src/map.c",
         "src/player.c",
+        "src/movement.c",
         "src/render.c",
         "src/rng.c",
         "src/settings.c",

src/common.h

@@ -4,6 +4,10 @@
 #include "settings.h"
 #include <raylib.h>
 
+typedef struct {
+  int x, y;
+} Vec2;
+
 // Tile types
 typedef enum { TILE_WALL, TILE_FLOOR, TILE_STAIRS } TileType;
 
@@ -30,6 +34,8 @@ typedef struct {
   TileType tiles[MAP_HEIGHT][MAP_WIDTH];
   Room rooms[MAX_ROOMS];
   int room_count;
+  unsigned char visible[MAP_HEIGHT][MAP_WIDTH];
+  unsigned char remembered[MAP_HEIGHT][MAP_WIDTH];
 } Map;
 
 // Dungeon
@@ -57,7 +63,7 @@ typedef struct {
 
 // Player
 typedef struct {
-  int x, y;
+  Vec2 position;
   int hp, max_hp;
   int attack;
   int defense;
@@ -83,7 +89,7 @@ typedef enum { ENEMY_GOBLIN, ENEMY_SKELETON, ENEMY_ORC } EnemyType;
 
 // Enemy
 typedef struct {
-  int x, y;
+  Vec2 position;
   int hp;
   int max_hp;
   int attack;
@@ -98,6 +104,11 @@ typedef struct {
   int status_chance;
   int crit_chance;  // crit chance percentage (0-100)
   int crit_mult;    // crit damage multiplier percentage (e.g. 150 = 1.5x)
+  // vision
+  int vision_range;
+  int alert;         // 1 = aware of player, searching
+  int last_known_x;  // last position where enemy saw player
+  int last_known_y;
   // status effects
   StatusEffect effects[MAX_EFFECTS];
   int effect_count;

src/enemy.c

@@ -2,7 +2,9 @@
 #include "combat.h"
 #include "common.h"
 #include "map.h"
+#include "movement.h"
 #include "rng.h"
+#include "settings.h"
 #include <string.h>
 
 // Forward declaration
@@ -29,7 +31,7 @@ void enemy_spawn(Enemy enemies[], int *count, Map *map, Player *p, int floor) {
     get_random_floor_tile(map, &ex, &ey, 50);
 
     // Don't spawn on player position
-    if (ex == p->x && ey == p->y) {
+    if (ex == p->position.x && ey == p->position.y) {
       continue;
     }
 
@@ -41,8 +43,8 @@ void enemy_spawn(Enemy enemies[], int *count, Map *map, Player *p, int floor) {
     // Create enemy
     Enemy e;
     memset(&e, 0, sizeof(Enemy));
-    e.x = ex;
+    e.position.x = ex;
-    e.y = ey;
+    e.position.y = ey;
     e.alive = 1;
     e.type = rng_int(ENEMY_GOBLIN, max_type);
     e.effect_count = 0;
@@ -68,6 +70,7 @@ void enemy_spawn(Enemy enemies[], int *count, Map *map, Player *p, int floor) {
       e.resistance[DMG_PIERCE] = 0;
       e.resistance[DMG_FIRE] = -25;
       e.resistance[DMG_POISON] = 50;
+      e.vision_range = 7;
       break;
     case ENEMY_SKELETON:
       e.max_hp = ENEMY_BASE_HP + floor + 2;
@@ -85,6 +88,7 @@ void enemy_spawn(Enemy enemies[], int *count, Map *map, Player *p, int floor) {
       e.resistance[DMG_PIERCE] = 50;
       e.resistance[DMG_FIRE] = 25;
       e.resistance[DMG_POISON] = 75;
+      e.vision_range = 6;
       break;
     case ENEMY_ORC:
       e.max_hp = ENEMY_BASE_HP + floor + 4;
@@ -102,6 +106,7 @@ void enemy_spawn(Enemy enemies[], int *count, Map *map, Player *p, int floor) {
       e.resistance[DMG_PIERCE] = -25;
       e.resistance[DMG_FIRE] = 0;
       e.resistance[DMG_POISON] = 0;
+      e.vision_range = 5;
       break;
     default:
       e.max_hp = ENEMY_BASE_HP;
@@ -115,6 +120,7 @@ void enemy_spawn(Enemy enemies[], int *count, Map *map, Player *p, int floor) {
       e.crit_chance = ENEMY_CRIT_CHANCE;
       e.crit_mult = ENEMY_CRIT_MULT;
       memset(e.resistance, 0, sizeof(e.resistance));
+      e.vision_range = ENEMY_VIEW_RANGE;
       break;
     }
     e.cooldown = e.speed;
@@ -127,58 +133,129 @@ void enemy_spawn(Enemy enemies[], int *count, Map *map, Player *p, int floor) {
 // Check if position has an enemy
 int is_enemy_at(const Enemy *enemies, int count, int x, int y) {
   for (int i = 0; i < count; i++) {
-    if (enemies[i].alive && enemies[i].x == x && enemies[i].y == y) {
+    if (enemies[i].alive && enemies[i].position.x == x && enemies[i].position.y == y) {
       return 1;
     }
   }
   return 0;
 }
 
-// Check if enemy can see player (adjacent)
+// Check if enemy can see player (within view range and line of sight)
-static int can_see_player(Enemy *e, Player *p) {
+static int can_see_player(Enemy *e, Player *p, Map *map) {
-  int dx = p->x - e->x;
+  return can_see_entity(map, e->position.x, e->position.y, p->position.x, p->position.y, e->vision_range);
-  int dy = p->y - e->y;
-  return (dx >= -1 && dx <= 1 && dy >= -1 && dy <= 1);
 }
 
-// Check if position is occupied by player
-static int is_player_at(Player *p, int x, int y) {
-  return (p->x == x && p->y == y);
-}
 
 // Move enemy toward player
 static void enemy_move_toward_player(Enemy *e, Player *p, Map *map, Enemy *all_enemies, int enemy_count) {
   int dx = 0, dy = 0;
 
-  if (p->x > e->x)
+  if (p->position.x > e->position.x)
     dx = 1;
-  else if (p->x < e->x)
+  else if (p->position.x < e->position.x)
     dx = -1;
 
-  if (p->y > e->y)
+  if (p->position.y > e->position.y)
     dy = 1;
-  else if (p->y < e->y)
+  else if (p->position.y < e->position.y)
     dy = -1;
 
-  // Try horizontal first, then vertical
+  Vec2 dir = {dx, 0};
-  int new_x = e->x + dx;
+  if (dx != 0) {
-  int new_y = e->y;
+    MoveResult r = try_move_entity(&e->position, dir, map, p, all_enemies, enemy_count, false);
+    if (r == MOVE_RESULT_MOVED)
+      return;
+  }
 
-  if (dx != 0 && is_floor(map, new_x, new_y) && !is_enemy_at(all_enemies, enemy_count, new_x, new_y) &&
+  dir.x = 0;
-      !is_player_at(p, new_x, new_y)) {
+  dir.y = dy;
-    e->x = new_x;
+  if (dy != 0) {
+    try_move_entity(&e->position, dir, map, p, all_enemies, enemy_count, false);
+  }
+}
+
+// Move enemy in a random direction (patrol)
+static void enemy_patrol(Enemy *e, Map *map, Enemy *all_enemies, int enemy_count) {
+  if (rng_int(0, 100) > ENEMY_PATROL_MOVE_CHANCE)
+    return;
+
+  int dx = rng_int(-1, 1);
+  int dy = rng_int(-1, 1);
+
+  if (dx == 0 && dy == 0)
+    return;
+
+  int new_x = e->position.x + dx;
+  int new_y = e->position.y + dy;
+
+  if (is_floor(map, new_x, new_y) && !is_enemy_at(all_enemies, enemy_count, new_x, new_y)) {
+    e->position.x = new_x;
+    e->position.y = new_y;
+  }
+}
+
+// Move enemy toward last known player position
+static void enemy_move_to_last_known(Enemy *e, Map *map, Enemy *all_enemies, int enemy_count) {
+  int dx = 0, dy = 0;
+
+  if (e->last_known_x > e->position.x)
+    dx = 1;
+  else if (e->last_known_x < e->position.x)
+    dx = -1;
+
+  if (e->last_known_y > e->position.y)
+    dy = 1;
+  else if (e->last_known_y < e->position.y)
+    dy = -1;
+
+  int new_x = e->position.x + dx;
+  int new_y = e->position.y;
+
+  if (dx != 0 && is_floor(map, new_x, new_y) && !is_enemy_at(all_enemies, enemy_count, new_x, new_y)) {
+    e->position.x = new_x;
   } else if (dy != 0) {
-    new_x = e->x;
+    new_x = e->position.x;
-    new_y = e->y + dy;
+    new_y = e->position.y + dy;
-    if (is_floor(map, new_x, new_y) && !is_enemy_at(all_enemies, enemy_count, new_x, new_y) &&
+    if (is_floor(map, new_x, new_y) && !is_enemy_at(all_enemies, enemy_count, new_x, new_y)) {
-        !is_player_at(p, new_x, new_y)) {
+      e->position.x = new_x;
-      e->x = new_x;
+      e->position.y = new_y;
-      e->y = new_y;
+    }
+  }
+
+  if (e->position.x == e->last_known_x && e->position.y == e->last_known_y)
+    e->alert = 0;
+}
+
+// Check if position is within alert radius of another enemy
+static int is_nearby_enemy(const Enemy *enemies, int count, int x, int y, int radius) {
+  for (int i = 0; i < count; i++) {
+    if (!enemies[i].alive)
+      continue;
+    int dx = enemies[i].position.x - x;
+    int dy = enemies[i].position.y - y;
+    if (dx * dx + dy * dy <= radius * radius)
+      return 1;
+  }
+  return 0;
+}
+
+// Propagate alert to nearby enemies
+static void propagate_alert(Enemy *trigger_enemy, Enemy *all_enemies, int enemy_count) {
+  for (int i = 0; i < enemy_count; i++) {
+    Enemy *e = &all_enemies[i];
+    if (!e->alive || e == trigger_enemy)
+      continue;
+    if (e->alert)
+      continue;
+    if (is_nearby_enemy(all_enemies, enemy_count, e->position.x, e->position.y, 5)) {
+      e->alert = 1;
+      e->last_known_x = trigger_enemy->last_known_x;
+      e->last_known_y = trigger_enemy->last_known_y;
     }
   }
 }
 
-// Perform a single action for an enemy (attack if adjacent, otherwise move)
+// Perform a single action for an enemy (attack if visible, otherwise patrol or search)
 void enemy_act(Enemy *e, Player *p, Map *map, Enemy *all_enemies, int enemy_count) {
   if (!e->alive)
     return;
@@ -187,14 +264,37 @@ void enemy_act(Enemy *e, Player *p, Map *map, Enemy *all_enemies, int enemy_coun
   if (combat_has_effect(e->effects, e->effect_count, EFFECT_STUN))
     return;
 
-  // Check if adjacent to player - attack
+  int can_see = can_see_player(e, p, map);
-  if (can_see_player(e, p)) {
+
+  // If we can see the player, update alert state and last known position
+  if (can_see) {
+    e->alert = 1;
+    e->last_known_x = p->position.x;
+    e->last_known_y = p->position.y;
+  }
+
+  // Attack if adjacent to player
+  if (can_see && can_see_entity(map, e->position.x, e->position.y, p->position.x, p->position.y, 1)) {
     combat_enemy_attack(e, p);
+    propagate_alert(e, all_enemies, enemy_count);
     return;
   }
 
-  // Otherwise, move toward player
+  // Move toward player if visible
+  if (can_see) {
     enemy_move_toward_player(e, p, map, all_enemies, enemy_count);
+    propagate_alert(e, all_enemies, enemy_count);
+    return;
+  }
+
+  // If alert but can't see player, move toward last known position
+  if (e->alert) {
+    enemy_move_to_last_known(e, map, all_enemies, enemy_count);
+    return;
+  }
+
+  // Not alert - patrol randomly
+  enemy_patrol(e, map, all_enemies, enemy_count);
 }
 
 void enemy_update_all(Enemy enemies[], int count, Player *p, Map *map) {

src/main.c

@@ -4,6 +4,7 @@
 #include "enemy.h"
 #include "items.h"
 #include "map.h"
+#include "movement.h"
 #include "player.h"
 #include "raylib.h"
 #include "render.h"
@@ -117,11 +118,14 @@ static void init_floor(GameState *gs, int floor_num) {
     gs->floors_reached = 1;
   } else {
     // Move player to new floor position
-    gs->player.x = start_x;
+    gs->player.position.x = start_x;
-    gs->player.y = start_y;
+    gs->player.position.y = start_y;
   }
   gs->player.floor = floor_num;
 
+  // Calculate initial visibility
+  calculate_visibility(&gs->map, gs->player.position.x, gs->player.position.y);
+
   // Spawn enemies
   enemy_spawn(gs->enemies, &gs->enemy_count, &gs->map, &gs->player, floor_num);
 
@@ -137,7 +141,8 @@ static void tick_all_effects(GameState *gs) {
   // Player effects
   int player_effect_dmg = combat_tick_effects(&gs->player);
   if (player_effect_dmg > 0) {
-    spawn_floating_text(gs, gs->player.x * TILE_SIZE + 8, gs->player.y * TILE_SIZE, player_effect_dmg, 0);
+    spawn_floating_text(gs, gs->player.position.x * TILE_SIZE + 8, gs->player.position.y * TILE_SIZE, player_effect_dmg,
+                        0);
     gs->screen_shake = SHAKE_EFFECT_DURATION;
   }
 
@@ -155,7 +160,7 @@ static void tick_all_effects(GameState *gs) {
       continue;
     int enemy_effect_dmg = combat_tick_enemy_effects(e);
     if (enemy_effect_dmg > 0) {
-      spawn_floating_text(gs, e->x * TILE_SIZE + 8, e->y * TILE_SIZE, enemy_effect_dmg, 0);
+      spawn_floating_text(gs, e->position.x * TILE_SIZE + 8, e->position.y * TILE_SIZE, enemy_effect_dmg, 0);
     }
     if (!e->alive) {
       add_log(gs, "Enemy died from effects!");
@@ -173,7 +178,7 @@ static void post_action(GameState *gs, Enemy *attacked_enemy) {
     return;
 
   // Check if stepped on stairs
-  if (gs->map.tiles[gs->player.y][gs->player.x] == TILE_STAIRS) {
+  if (gs->map.tiles[gs->player.position.y][gs->player.position.x] == TILE_STAIRS) {
     gs->awaiting_descend = 1;
     gs->last_message = "Descend to next floor? (Y/N)";
     gs->message_timer = 120;
@@ -182,8 +187,8 @@ static void post_action(GameState *gs, Enemy *attacked_enemy) {
 
   // combat feedback - player attacked an enemy this turn
   if (attacked_enemy != NULL) {
-    int ex = attacked_enemy->x * TILE_SIZE + 8;
+    int ex = attacked_enemy->position.x * TILE_SIZE + 8;
-    int ey = attacked_enemy->y * TILE_SIZE;
+    int ey = attacked_enemy->position.y * TILE_SIZE;
 
     if (combat_was_dodged()) {
       spawn_floating_label(gs, ex, ey, LABEL_DODGE, EFFECT_NONE);
@@ -215,6 +220,9 @@ static void post_action(GameState *gs, Enemy *attacked_enemy) {
     }
   }
 
+  // Update visibility based on player's new position
+  calculate_visibility(&gs->map, gs->player.position.x, gs->player.position.y);
+
   // Enemy turns - uses speed/cooldown system
   enemy_update_all(gs->enemies, gs->enemy_count, &gs->player, &gs->map);
 
@@ -224,8 +232,8 @@ static void post_action(GameState *gs, Enemy *attacked_enemy) {
     gs->screen_shake = SHAKE_PLAYER_DAMAGE_DURATION;
     gs->damage_taken += combat_get_last_damage();
     gs->times_hit++;
-    spawn_floating_text(gs, gs->player.x * TILE_SIZE + 8, gs->player.y * TILE_SIZE, combat_get_last_damage(),
+    spawn_floating_text(gs, gs->player.position.x * TILE_SIZE + 8, gs->player.position.y * TILE_SIZE,
-                        combat_was_critical());
+                        combat_get_last_damage(), combat_was_critical());
   }
 
   // Set message and check game over
@@ -246,6 +254,7 @@ static int handle_stun_turn(GameState *gs) {
   if (gs->game_over)
     return 1;
   enemy_update_all(gs->enemies, gs->enemy_count, &gs->player, &gs->map);
+  calculate_visibility(&gs->map, gs->player.position.x, gs->player.position.y);
   if (gs->player.hp <= 0)
     gs->game_over = 1;
   gs->last_message = "You are stunned!";
@@ -388,7 +397,7 @@ static int handle_movement_input(GameState *gs) {
 
   // Check for manual item pickup (G key)
   if (IsKeyPressed(KEY_G)) {
-    Item *item = get_item_at_floor(gs->items, gs->item_count, gs->player.x, gs->player.y);
+    Item *item = get_item_at_floor(gs->items, gs->item_count, gs->player.position.x, gs->player.position.y);
     if (item != NULL) {
       if (player_pickup(&gs->player, item)) {
         gs->items_collected++;
@@ -417,38 +426,45 @@ static int handle_movement_input(GameState *gs) {
     }
   }
 
-  // Movement: use IsKeyDown for held-key repeat
-  int dx = 0, dy = 0;
-  if (IsKeyDown(KEY_W) || IsKeyDown(KEY_UP))
-    dy = -1;
-  else if (IsKeyDown(KEY_S) || IsKeyDown(KEY_DOWN))
-    dy = 1;
-  else if (IsKeyDown(KEY_A) || IsKeyDown(KEY_LEFT))
-    dx = -1;
-  else if (IsKeyDown(KEY_D) || IsKeyDown(KEY_RIGHT))
-    dx = 1;
 
-  if (dx == 0 && dy == 0)
+  Vec2 direction = {0, 0};
+  if (IsKeyDown(KEY_W) || IsKeyDown(KEY_UP))
+    direction.y = -1;
+  else if (IsKeyDown(KEY_S) || IsKeyDown(KEY_DOWN))
+    direction.y = 1;
+  else if (IsKeyDown(KEY_A) || IsKeyDown(KEY_LEFT))
+    direction.x = -1;
+  else if (IsKeyDown(KEY_D) || IsKeyDown(KEY_RIGHT))
+    direction.x = 1;
+
+  if (direction.x == 0 && direction.y == 0)
     return 0;
 
   // Reset combat event before player acts
   combat_reset_event();
 
-  int new_x = gs->player.x + dx;
+
-  int new_y = gs->player.y + dy;
+  int new_x = gs->player.position.x + direction.x;
+  int new_y = gs->player.position.y + direction.y;
+
+  Enemy *target = NULL;
   int action = 0;
 
-  // Attack enemy at target tile, or move into it
+  MoveResult result =
-  Enemy *target = player_find_enemy_at(gs->enemies, gs->enemy_count, new_x, new_y);
+      try_move_entity(&gs->player.position, direction, &gs->map, &gs->player, gs->enemies, gs->enemy_count, true);
+  if (result == MOVE_RESULT_MOVED) {
+    player_on_move(&gs->player);
+    action = 1;
+  } else if (result == MOVE_RESULT_BLOCKED_ENEMY) {
+    target = player_find_enemy_at(gs->enemies, gs->enemy_count, new_x, new_y);
     if (target != NULL) {
       player_attack(&gs->player, target);
       action = 1;
-  } else {
+    }
-    action = player_move(&gs->player, dx, dy, &gs->map);
   }
 
   if (action)
-    post_action(gs, target);  // target is NULL on move, enemy ptr on attack
+    post_action(gs, target);
 
   return action;
 }
@@ -541,8 +557,8 @@ static void game_loop(void) {
     cam.offset = (Vector2){(float)gs.shake_x, (float)gs.shake_y};
     BeginMode2D(cam);
     render_map(&gs.map);
-    render_items(gs.items, gs.item_count);
+    render_items(gs.items, gs.item_count, gs.map.visible);
-    render_enemies(gs.enemies, gs.enemy_count);
+    render_enemies(gs.enemies, gs.enemy_count, gs.map.visible);
     render_player(&gs.player);
     EndMode2D();
 

src/map.c

@@ -1,6 +1,8 @@
 #include "map.h"
 #include "rng.h"
+#include "settings.h"
 #include "utils.h"
+#include <stdlib.h>
 #include <string.h>
 
 void map_init(Map *map) {
@@ -10,6 +12,8 @@ void map_init(Map *map) {
       map->tiles[y][x] = TILE_WALL;
     }
   }
+  memset(map->visible, 0, sizeof(map->visible));
+  memset(map->remembered, 0, sizeof(map->remembered));
   map->room_count = 0;
 }
 
@@ -186,3 +190,67 @@ void dungeon_generate(Dungeon *d, Map *map, int floor_num) {
   d->room_count = map->room_count;
   memcpy(d->rooms, map->rooms, sizeof(Room) * map->room_count);
 }
+
+int is_in_view_range(int x, int y, int view_x, int view_y, int range) {
+  int dx = x - view_x;
+  int dy = y - view_y;
+  return (dx * dx + dy * dy) <= (range * range);
+}
+
+static int trace_line_of_sight(const Map *map, int x1, int y1, int x2, int y2) {
+  int dx = abs(x2 - x1);
+  int dy = abs(y2 - y1);
+  int sx = (x1 < x2) ? 1 : -1;
+  int sy = (y1 < y2) ? 1 : -1;
+  int err = dx - dy;
+  int x = x1;
+  int y = y1;
+
+  while (1) {
+    if (!in_bounds(x, y, MAP_WIDTH, MAP_HEIGHT))
+      return 0;
+
+    if (x == x2 && y == y2)
+      return 1;
+
+    if (map->tiles[y][x] == TILE_WALL && !(x == x1 && y == y1))
+      return 0;
+
+    int e2 = 2 * err;
+    if (e2 > -dy) {
+      err -= dy;
+      x += sx;
+    }
+    if (e2 < dx) {
+      err += dx;
+      y += sy;
+    }
+  }
+}
+
+int has_line_of_sight(const Map *map, int x1, int y1, int x2, int y2) {
+  if (!in_bounds(x1, y1, MAP_WIDTH, MAP_HEIGHT) || !in_bounds(x2, y2, MAP_WIDTH, MAP_HEIGHT))
+    return 0;
+  return trace_line_of_sight(map, x1, y1, x2, y2);
+}
+
+int can_see_entity(const Map *map, int from_x, int from_y, int to_x, int to_y, int range) {
+  if (!is_in_view_range(to_x, to_y, from_x, from_y, range))
+    return 0;
+  return has_line_of_sight(map, from_x, from_y, to_x, to_y);
+}
+
+void calculate_visibility(Map *map, int x, int y) {
+  memset(map->visible, 0, sizeof(map->visible));
+
+  for (int ty = 0; ty < MAP_HEIGHT; ty++) {
+    for (int tx = 0; tx < MAP_WIDTH; tx++) {
+      if (is_in_view_range(tx, ty, x, y, PLAYER_VIEW_RANGE)) {
+        if (has_line_of_sight(map, x, y, tx, ty)) {
+          map->visible[ty][tx] = 1;
+          map->remembered[ty][tx] = 1;
+        }
+      }
+    }
+  }
+}

src/map.h

@@ -18,4 +18,10 @@ void map_init(Map *map);
 // Get a random floor tile position
 void get_random_floor_tile(Map *map, int *x, int *y, int attempts);
 
+// Visibility / Fog of War
+int is_in_view_range(int x, int y, int view_x, int view_y, int range);
+int has_line_of_sight(const Map *map, int x1, int y1, int x2, int y2);
+void calculate_visibility(Map *map, int x, int y);
+int can_see_entity(const Map *map, int from_x, int from_y, int to_x, int to_y, int range);
+
 #endif  // MAP_H

src/movement.c

@@ -0,0 +1,29 @@
+#include "movement.h"
+#include "enemy.h"
+#include "map.h"
+#include <stdbool.h>
+
+// Check if position is occupied by player
+static int is_player_at(Player *p, int x, int y) {
+  return (p->position.x == x && p->position.y == y);
+}
+
+MoveResult try_move_entity(Vec2 *p, Vec2 direction, Map *map, Player *player, Enemy *enemies, int enemy_count,
+                           bool moving_is_player) {
+  int new_x = p->x + direction.x;
+  int new_y = p->y + direction.y;
+
+  if (!is_floor(map, new_x, new_y))
+    return MOVE_RESULT_BLOCKED_WALL;
+
+  if (is_enemy_at(enemies, enemy_count, new_x, new_y))
+    return MOVE_RESULT_BLOCKED_ENEMY;
+  if (!moving_is_player) {
+    if (is_player_at(player, new_x, new_y))
+      return MOVE_RESULT_BLOCKED_PLAYER;
+  }
+
+  p->x = new_x;
+  p->y = new_y;
+  return MOVE_RESULT_MOVED;
+}

src/movement.h

@@ -0,0 +1,17 @@
+#ifndef MOVEMENT_H
+#define MOVEMENT_H
+
+#include "common.h"
+
+typedef enum {
+  MOVE_RESULT_MOVED,
+  MOVE_RESULT_BLOCKED_WALL,
+  MOVE_RESULT_BLOCKED_PLAYER,
+  MOVE_RESULT_BLOCKED_ENEMY
+} MoveResult;
+
+// Attempts to move entity in a given direction. Returns outcome of action.
+MoveResult try_move_entity(Vec2 *p, Vec2 direction, Map *map, Player *player, Enemy *enemies, int enemy_count,
+                           bool moving_is_player);
+
+#endif  // MOVEMENT_H

src/player.c

@@ -2,15 +2,12 @@
 #include "combat.h"
 #include "common.h"
 #include "items.h"
-#include "map.h"
 #include "settings.h"
-#include "utils.h"
-#include <stdlib.h>
 #include <string.h>
 
 void player_init(Player *p, int x, int y) {
-  p->x = x;
+  p->position.x = x;
-  p->y = y;
+  p->position.y = y;
   p->hp = PLAYER_BASE_HP;
   p->max_hp = PLAYER_BASE_HP;
   p->attack = PLAYER_BASE_ATTACK;
@@ -43,36 +40,20 @@ Enemy *player_find_enemy_at(Enemy *enemies, int count, int x, int y) {
   if (count > MAX_ENEMIES)
     count = MAX_ENEMIES;
   for (int i = 0; i < count; i++) {
-    if (enemies[i].alive && enemies[i].x == x && enemies[i].y == y)
+    if (enemies[i].alive && enemies[i].position.x == x && enemies[i].position.y == y)
       return &enemies[i];
   }
   return NULL;
 }
 
-int player_move(Player *p, int dx, int dy, Map *map) {
+void player_on_move(Player *p) {
-  int new_x = p->x + dx;
-  int new_y = p->y + dy;
-
-  // Check bounds
-  if (!in_bounds(new_x, new_y, MAP_WIDTH, MAP_HEIGHT))
-    return 0;
-
-  // Check if walkable
-  if (!is_floor(map, new_x, new_y))
-    return 0;
-
-  // Move player
-  p->x = new_x;
-  p->y = new_y;
   p->step_count += 1;
-  // Regen suppressed while poisoned, bleeding, or burning
   if (p->step_count % REGEN_STEP_INTERVAL == 0 && p->hp < p->max_hp &&
       !combat_has_effect(p->effects, p->effect_count, EFFECT_POISON) &&
       !combat_has_effect(p->effects, p->effect_count, EFFECT_BLEED) &&
       !combat_has_effect(p->effects, p->effect_count, EFFECT_BURN)) {
     p->hp += 1;
   }
-  return 1;
 }
 
 void player_attack(Player *p, Enemy *e) {
@@ -228,8 +209,8 @@ int player_drop_item(Player *p, int inv_index, Item *items, int item_count) {
     if (items[i].picked_up) {
       // Place dropped item at this position
       items[i] = *item;
-      items[i].x = p->x;
+      items[i].x = p->position.x;
-      items[i].y = p->y;
+      items[i].y = p->position.y;
       items[i].picked_up = 0;
       // Remove from inventory
       player_remove_inventory_item(p, inv_index);

src/player.h

@@ -6,8 +6,8 @@
 // Initialize player at position
 void player_init(Player *p, int x, int y);
 
-// Move player to (x+dx, y+dy); returns 1 if moved, 0 if blocked
+// Apply status effects, healing, etc
-int player_move(Player *p, int dx, int dy, Map *map);
+void player_on_move(Player *p);
 
 // Find a living enemy at tile (x, y); returns NULL if none
 Enemy *player_find_enemy_at(Enemy *enemies, int count, int x, int y);

src/render.c

@@ -11,18 +11,31 @@ void render_map(const Map *map) {
   for (int y = 0; y < MAP_HEIGHT; y++) {
     for (int x = 0; x < MAP_WIDTH; x++) {
       Rectangle rect = {(float)(x * TILE_SIZE), (float)(y * TILE_SIZE), (float)TILE_SIZE, (float)TILE_SIZE};
+      int visible = map->visible[y][x];
+      int remembered = map->remembered[y][x];
+
+      if (!visible && !remembered) {
+        DrawRectangleRec(rect, (Color){5, 5, 10, 255});
+        continue;
+      }
+
+      Color wall_color = visible ? DARKGRAY : (Color){25, 25, 30, 255};
+      Color floor_color = visible ? BLACK : (Color){15, 15, 20, 255};
+      Color stairs_color = visible ? (Color){100, 100, 100, 255} : (Color){40, 40, 45, 255};
 
       switch (map->tiles[y][x]) {
       case TILE_WALL:
-        DrawRectangleRec(rect, DARKGRAY);
+        DrawRectangleRec(rect, wall_color);
         break;
       case TILE_FLOOR:
-        DrawRectangleRec(rect, BLACK);
+        DrawRectangleRec(rect, floor_color);
         break;
       case TILE_STAIRS:
-        DrawRectangleRec(rect, (Color){100, 100, 100, 255});
+        DrawRectangleRec(rect, stairs_color);
-        // Draw stairs marker
+        if (visible)
           DrawText(">", x * TILE_SIZE + 4, y * TILE_SIZE + 2, 12, WHITE);
+        else
+          DrawText(">", x * TILE_SIZE + 4, y * TILE_SIZE + 2, 12, (Color){60, 60, 65, 255});
         break;
       }
     }
@@ -30,17 +43,20 @@ void render_map(const Map *map) {
 }
 
 void render_player(const Player *p) {
-  Rectangle rect = {(float)(p->x * TILE_SIZE), (float)(p->y * TILE_SIZE), (float)TILE_SIZE, (float)TILE_SIZE};
+  Rectangle rect = {(float)(p->position.x * TILE_SIZE), (float)(p->position.y * TILE_SIZE), (float)TILE_SIZE,
+                    (float)TILE_SIZE};
   DrawRectangleRec(rect, BLUE);
 }
 
-void render_enemies(const Enemy *enemies, int count) {
+void render_enemies(const Enemy *enemies, int count, const unsigned char visible[MAP_HEIGHT][MAP_WIDTH]) {
   for (int i = 0; i < count; i++) {
     if (!enemies[i].alive)
       continue;
+    if (!visible[enemies[i].position.y][enemies[i].position.x])
+      continue;
 
-    Rectangle rect = {(float)(enemies[i].x * TILE_SIZE), (float)(enemies[i].y * TILE_SIZE), (float)TILE_SIZE,
+    Rectangle rect = {(float)(enemies[i].position.x * TILE_SIZE), (float)(enemies[i].position.y * TILE_SIZE),
-                      (float)TILE_SIZE};
+                      (float)TILE_SIZE, (float)TILE_SIZE};
 
     // Different colors based on enemy type
     Color enemy_color;
@@ -72,17 +88,19 @@ void render_enemies(const Enemy *enemies, int count) {
         bar_color = (Color){200, 180, 40, 255};  // yellow
       else
         bar_color = (Color){200, 60, 60, 255};  // red
-      Rectangle hp_bar = {(float)(enemies[i].x * TILE_SIZE), (float)(enemies[i].y * TILE_SIZE - 4), (float)hp_pixels,
+      Rectangle hp_bar = {(float)(enemies[i].position.x * TILE_SIZE), (float)(enemies[i].position.y * TILE_SIZE - 4),
-                          3};
+                          (float)hp_pixels, 3};
       DrawRectangleRec(hp_bar, bar_color);
     }
   }
 }
 
-void render_items(const Item *items, int count) {
+void render_items(const Item *items, int count, const unsigned char visible[MAP_HEIGHT][MAP_WIDTH]) {
   for (int i = 0; i < count; i++) {
     if (items[i].picked_up)
       continue;
+    if (!visible[items[i].y][items[i].x])
+      continue;
 
     Rectangle rect = {(float)(items[i].x * TILE_SIZE), (float)(items[i].y * TILE_SIZE), (float)TILE_SIZE,
                       (float)TILE_SIZE};

src/render.h

@@ -80,10 +80,10 @@ void render_map(const Map *map);
 void render_player(const Player *p);
 
 // Render all enemies
-void render_enemies(const Enemy *enemies, int count);
+void render_enemies(const Enemy *enemies, int count, const unsigned char visible[MAP_HEIGHT][MAP_WIDTH]);
 
 // Render all items
-void render_items(const Item *items, int count);
+void render_items(const Item *items, int count, const unsigned char visible[MAP_HEIGHT][MAP_WIDTH]);
 
 // Render UI overlay
 void render_ui(const Player *p);

src/settings.h

@@ -63,4 +63,9 @@
 // Message timer
 #define MESSAGE_TIMER_DURATION 60
 
+// Visibility / Fog of War
+#define PLAYER_VIEW_RANGE 8
+#define ENEMY_VIEW_RANGE 6
+#define ENEMY_PATROL_MOVE_CHANCE 30
+
 #endif  // SETTINGS_H