SquirrelModeler/rogged
1
0
Fork 0
forked from NotAShelf/rogged
Code Pull requests Activity

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

Browse source 
Reviewed-on: NotAShelf/rogged#14
Reviewed-by: A.M. Rowsell <amr@noreply.localhost>
This commit is contained in:
raf 2026-04-10 06:07:57 +00:00
commit 09f7e659b5
8 changed files with 238 additions and 21 deletions
Download patch file Download diff file Expand all files Collapse all files

7
src/common.h
View file

@ -34,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
@ -102,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;

127
src/enemy.c
View file

@ -4,6 +4,7 @@
#include "map.h"
#include "movement.h"
#include "rng.h"
#include "settings.h"
#include <string.h>
// Forward declaration
@ -69,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;
@ -86,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;
@ -103,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;
@ -116,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;
@ -135,11 +140,9 @@ int is_enemy_at(const Enemy *enemies, int count, int x, int y) {
return 0;
}
// Check if enemy can see player (adjacent)
static int can_see_player(Enemy *e, Player *p) {
int dx = p->position.x - e->position.x;
int dy = p->position.y - e->position.y;
return (dx >= -1 && dx <= 1 && dy >= -1 && dy <= 1);
// Check if enemy can see player (within view range and line of sight)
static int can_see_player(Enemy *e, Player *p, Map *map) {
return can_see_entity(map, e->position.x, e->position.y, p->position.x, p->position.y, e->vision_range);
}
@ -171,7 +174,88 @@ static void enemy_move_toward_player(Enemy *e, Player *p, Map *map, Enemy *all_e
}
}
// Perform a single action for an enemy (attack if adjacent, otherwise move)
// 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->position.x;
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;
}
}
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 visible, otherwise patrol or search)
void enemy_act(Enemy *e, Player *p, Map *map, Enemy *all_enemies, int enemy_count) {
if (!e->alive)
return;
@ -180,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
if (can_see_player(e, p)) {
int can_see = can_see_player(e, p, map);
// 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
enemy_move_toward_player(e, p, map, all_enemies, enemy_count);
// 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) {

11
src/main.c
View file

@ -123,6 +123,9 @@ static void init_floor(GameState *gs, int floor_num) {
}
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);
@ -217,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);
@ -248,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!";
@ -550,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_enemies(gs.enemies, gs.enemy_count);
render_items(gs.items, gs.item_count, gs.map.visible);
render_enemies(gs.enemies, gs.enemy_count, gs.map.visible);
render_player(&gs.player);
EndMode2D();

68
src/map.c
View file

@ -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;
}
}
}
}
}

6
src/map.h
View file

@ -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

31
src/render.c
View file

@ -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});
// Draw stairs marker
DrawText(">", x * TILE_SIZE + 4, y * TILE_SIZE + 2, 12, WHITE);
DrawRectangleRec(rect, stairs_color);
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;
}
}
@ -35,10 +48,12 @@ void render_player(const Player *p) {
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].position.x * TILE_SIZE), (float)(enemies[i].position.y * TILE_SIZE),
(float)TILE_SIZE, (float)TILE_SIZE};
@ -80,10 +95,12 @@ void render_enemies(const Enemy *enemies, int count) {
}
}
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};

4
src/render.h
View file

@ -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);

5
src/settings.h
View file

@ -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