Compare commits
3 commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
dab3e1554c
|
||
|
|
af14fd258b
|
||
|
|
5de711cdaf
|
25 changed files with 399 additions and 792 deletions
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
76
build.zig
76
build.zig
|
|
@ -4,55 +4,8 @@ pub fn build(b: *std.Build) void {
|
|||
const target = b.standardTargetOptions(.{});
|
||||
const optimize = b.standardOptimizeOption(.{});
|
||||
|
||||
const c_flags = [_][]const u8{
|
||||
"-std=c99",
|
||||
"-Wall",
|
||||
"-Wextra",
|
||||
"-O2",
|
||||
};
|
||||
|
||||
// RNG library
|
||||
const rng_lib = b.addLibrary(.{
|
||||
.name = "rng",
|
||||
.root_module = b.createModule(.{
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
.link_libc = true,
|
||||
}),
|
||||
});
|
||||
rng_lib.addCSourceFiles(.{
|
||||
.files = &[_][]const u8{"libs/rng/rng.c"},
|
||||
.flags = &c_flags,
|
||||
});
|
||||
rng_lib.addIncludePath(b.path("libs/rng"));
|
||||
|
||||
// Map library
|
||||
const map_lib = b.addLibrary(.{
|
||||
.name = "map",
|
||||
.root_module = b.createModule(.{
|
||||
.target = target,
|
||||
.optimize = optimize,
|
||||
.link_libc = true,
|
||||
}),
|
||||
});
|
||||
map_lib.addCSourceFiles(.{
|
||||
.files = &[_][]const u8{
|
||||
"libs/map/map.c",
|
||||
"libs/map/utils.c",
|
||||
},
|
||||
.flags = &c_flags,
|
||||
});
|
||||
// map.h includes common.h and settings.h which live in src/
|
||||
map_lib.addIncludePath(b.path("src"));
|
||||
// map.c includes rng/rng.h via libs/ root
|
||||
map_lib.addIncludePath(b.path("libs"));
|
||||
// utils.h is co-located with map.c
|
||||
map_lib.addIncludePath(b.path("libs/map"));
|
||||
|
||||
// Zig combat library. This must be compiled as an object and linked
|
||||
// directly to bypassing the archive step, or it yields a corrupt
|
||||
// archive that forces the user to clear the cache each time.
|
||||
const combat_obj = b.addObject(.{
|
||||
// Zig combat library
|
||||
const combat_lib = b.addLibrary(.{
|
||||
.name = "combat",
|
||||
.root_module = b.createModule(.{
|
||||
.root_source_file = b.path("libs/combat/combat.zig"),
|
||||
|
|
@ -61,20 +14,28 @@ pub fn build(b: *std.Build) void {
|
|||
.link_libc = true,
|
||||
}),
|
||||
});
|
||||
// common.h and settings.h live in src/; rng.h exposed bare from libs/rng
|
||||
combat_obj.addIncludePath(b.path("src"));
|
||||
combat_obj.addIncludePath(b.path("libs/rng"));
|
||||
combat_lib.addIncludePath(b.path("src"));
|
||||
combat_lib.linkSystemLibrary("raylib");
|
||||
|
||||
// C sources remaining in src/
|
||||
// C sources (everything except combat, which is now Zig)
|
||||
const c_sources = [_][]const u8{
|
||||
"src/audio.c",
|
||||
"src/enemy.c",
|
||||
"src/items.c",
|
||||
"src/main.c",
|
||||
"src/movement.c",
|
||||
"src/map.c",
|
||||
"src/player.c",
|
||||
"src/render.c",
|
||||
"src/rng.c",
|
||||
"src/settings.c",
|
||||
"src/utils.c",
|
||||
};
|
||||
|
||||
const c_flags = [_][]const u8{
|
||||
"-std=c99",
|
||||
"-Wall",
|
||||
"-Wextra",
|
||||
"-O2",
|
||||
};
|
||||
|
||||
// Main executable
|
||||
|
|
@ -92,13 +53,8 @@ pub fn build(b: *std.Build) void {
|
|||
.flags = &c_flags,
|
||||
});
|
||||
|
||||
// src/ for own headers; libs/ so "rng/rng.h" and "map/map.h" resolve
|
||||
exe.addIncludePath(b.path("src"));
|
||||
exe.addIncludePath(b.path("libs"));
|
||||
|
||||
exe.linkLibrary(rng_lib);
|
||||
exe.linkLibrary(map_lib);
|
||||
exe.addObject(combat_obj);
|
||||
exe.linkLibrary(combat_lib);
|
||||
exe.linkSystemLibrary("raylib");
|
||||
exe.linkSystemLibrary("m");
|
||||
exe.linkSystemLibrary("pthread");
|
||||
|
|
|
|||
|
|
@ -1,4 +1,6 @@
|
|||
#include "audio.h"
|
||||
#include "raylib.h"
|
||||
#include "common.h"
|
||||
#include <math.h>
|
||||
#include <stddef.h>
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#ifndef AUDIO_H
|
||||
#define AUDIO_H
|
||||
#include "game_state.h"
|
||||
#include "common.h"
|
||||
|
||||
// Initialize audio system
|
||||
void audio_init(void);
|
||||
|
|
|
|||
78
src/common.h
78
src/common.h
|
|
@ -2,11 +2,7 @@
|
|||
#define COMMON_H
|
||||
|
||||
#include "settings.h"
|
||||
#include <stdbool.h>
|
||||
|
||||
typedef struct {
|
||||
int x, y;
|
||||
} Vec2;
|
||||
#include <raylib.h>
|
||||
|
||||
// Tile types
|
||||
typedef enum { TILE_WALL, TILE_FLOOR, TILE_STAIRS } TileType;
|
||||
|
|
@ -34,8 +30,6 @@ 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
|
||||
|
|
@ -63,7 +57,7 @@ typedef struct {
|
|||
|
||||
// Player
|
||||
typedef struct {
|
||||
Vec2 position;
|
||||
int x, y;
|
||||
int hp, max_hp;
|
||||
int attack;
|
||||
int defense;
|
||||
|
|
@ -89,7 +83,7 @@ typedef enum { ENEMY_GOBLIN, ENEMY_SKELETON, ENEMY_ORC } EnemyType;
|
|||
|
||||
// Enemy
|
||||
typedef struct {
|
||||
Vec2 position;
|
||||
int x, y;
|
||||
int hp;
|
||||
int max_hp;
|
||||
int attack;
|
||||
|
|
@ -104,15 +98,71 @@ 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;
|
||||
} Enemy;
|
||||
|
||||
// Floating damage text
|
||||
typedef enum { LABEL_NONE = 0, LABEL_DODGE, LABEL_BLOCK, LABEL_CRIT, LABEL_SLAIN, LABEL_PROC } FloatingLabel;
|
||||
|
||||
typedef struct {
|
||||
int x, y;
|
||||
int value;
|
||||
int lifetime; // frames remaining
|
||||
int is_critical;
|
||||
FloatingLabel label; // label type instead of string
|
||||
StatusEffectType effect_type; // used to pick color for proc labels
|
||||
} FloatingText;
|
||||
|
||||
// AudioAssets
|
||||
typedef struct {
|
||||
Sound attack1, attack2, attack3;
|
||||
Sound pickup;
|
||||
Sound staircase;
|
||||
Sound dodge1, dodge2, dodge3;
|
||||
Sound crit;
|
||||
} AudioAssets;
|
||||
|
||||
// GameState - encapsulates all game state for testability and save/load
|
||||
typedef struct {
|
||||
Player player;
|
||||
Map map;
|
||||
Dungeon dungeon;
|
||||
Enemy enemies[MAX_ENEMIES];
|
||||
int enemy_count;
|
||||
Item items[MAX_ITEMS];
|
||||
int item_count;
|
||||
int game_over;
|
||||
int game_won;
|
||||
const char *last_message;
|
||||
int message_timer;
|
||||
int turn_count;
|
||||
int awaiting_descend; // 0 = normal, 1 = waiting for Y/N
|
||||
int show_inventory; // 0 = hidden, 1 = show overlay
|
||||
int inv_selected; // currently selected inventory index
|
||||
// action log
|
||||
char action_log[5][128];
|
||||
int log_count;
|
||||
int log_head;
|
||||
// visual effects
|
||||
FloatingText floating_texts[8];
|
||||
int floating_count;
|
||||
int screen_shake; // frames of screen shake remaining
|
||||
int shake_x;
|
||||
int shake_y;
|
||||
AudioAssets sounds;
|
||||
// Statistics
|
||||
int total_kills;
|
||||
int items_collected;
|
||||
int damage_dealt;
|
||||
int damage_taken;
|
||||
int crits_landed;
|
||||
int times_hit;
|
||||
int potions_used;
|
||||
int floors_reached;
|
||||
int final_score;
|
||||
} GameState;
|
||||
|
||||
|
||||
#endif // COMMON_H
|
||||
|
|
|
|||
172
src/enemy.c
172
src/enemy.c
|
|
@ -1,10 +1,8 @@
|
|||
#include "enemy.h"
|
||||
#include "combat.h"
|
||||
#include "common.h"
|
||||
#include "map/map.h"
|
||||
#include "movement.h"
|
||||
#include "rng/rng.h"
|
||||
#include "settings.h"
|
||||
#include "map.h"
|
||||
#include "rng.h"
|
||||
#include <string.h>
|
||||
|
||||
// Forward declaration
|
||||
|
|
@ -31,7 +29,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->position.x && ey == p->position.y) {
|
||||
if (ex == p->x && ey == p->y) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -43,8 +41,8 @@ void enemy_spawn(Enemy enemies[], int *count, Map *map, Player *p, int floor) {
|
|||
// Create enemy
|
||||
Enemy e;
|
||||
memset(&e, 0, sizeof(Enemy));
|
||||
e.position.x = ex;
|
||||
e.position.y = ey;
|
||||
e.x = ex;
|
||||
e.y = ey;
|
||||
e.alive = 1;
|
||||
e.type = rng_int(ENEMY_GOBLIN, max_type);
|
||||
e.effect_count = 0;
|
||||
|
|
@ -70,7 +68,6 @@ 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;
|
||||
|
|
@ -88,7 +85,6 @@ 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;
|
||||
|
|
@ -106,7 +102,6 @@ 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;
|
||||
|
|
@ -120,7 +115,6 @@ 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;
|
||||
|
|
@ -133,129 +127,58 @@ 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].position.x == x && enemies[i].position.y == y) {
|
||||
if (enemies[i].alive && enemies[i].x == x && enemies[i].y == y) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// 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);
|
||||
// Check if enemy can see player (adjacent)
|
||||
static int can_see_player(Enemy *e, Player *p) {
|
||||
int dx = p->x - e->x;
|
||||
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->position.x > e->position.x)
|
||||
if (p->x > e->x)
|
||||
dx = 1;
|
||||
else if (p->position.x < e->position.x)
|
||||
else if (p->x < e->x)
|
||||
dx = -1;
|
||||
|
||||
if (p->position.y > e->position.y)
|
||||
if (p->y > e->y)
|
||||
dy = 1;
|
||||
else if (p->position.y < e->position.y)
|
||||
else if (p->y < e->y)
|
||||
dy = -1;
|
||||
|
||||
Vec2 dir = {dx, 0};
|
||||
if (dx != 0) {
|
||||
MoveResult r = try_move_entity(&e->position, dir, map, p, all_enemies, enemy_count, false);
|
||||
if (r == MOVE_RESULT_MOVED)
|
||||
return;
|
||||
}
|
||||
// Try horizontal first, then vertical
|
||||
int new_x = e->x + dx;
|
||||
int new_y = e->y;
|
||||
|
||||
dir.x = 0;
|
||||
dir.y = dy;
|
||||
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;
|
||||
if (dx != 0 && 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->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;
|
||||
new_x = e->x;
|
||||
new_y = e->y + dy;
|
||||
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->x = new_x;
|
||||
e->y = new_y;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Perform a single action for an enemy (attack if visible, otherwise patrol or search)
|
||||
// Perform a single action for an enemy (attack if adjacent, otherwise move)
|
||||
void enemy_act(Enemy *e, Player *p, Map *map, Enemy *all_enemies, int enemy_count) {
|
||||
if (!e->alive)
|
||||
return;
|
||||
|
|
@ -264,37 +187,14 @@ 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;
|
||||
|
||||
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)) {
|
||||
// Check if adjacent to player - attack
|
||||
if (can_see_player(e, p)) {
|
||||
combat_enemy_attack(e, p);
|
||||
propagate_alert(e, all_enemies, enemy_count);
|
||||
return;
|
||||
}
|
||||
|
||||
// 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);
|
||||
// Otherwise, move toward player
|
||||
enemy_move_toward_player(e, p, map, all_enemies, enemy_count);
|
||||
}
|
||||
|
||||
void enemy_update_all(Enemy enemies[], int count, Player *p, Map *map) {
|
||||
|
|
|
|||
|
|
@ -1,70 +0,0 @@
|
|||
#ifndef GAME_STATE_H
|
||||
#define GAME_STATE_H
|
||||
|
||||
#include "common.h"
|
||||
#include <raylib.h>
|
||||
|
||||
// Floating damage text
|
||||
typedef enum { LABEL_NONE = 0, LABEL_DODGE, LABEL_BLOCK, LABEL_CRIT, LABEL_SLAIN, LABEL_PROC } FloatingLabel;
|
||||
|
||||
typedef struct {
|
||||
int x, y;
|
||||
int value;
|
||||
int lifetime; // frames remaining
|
||||
int is_critical;
|
||||
FloatingLabel label; // label type instead of string
|
||||
StatusEffectType effect_type; // used to pick color for proc labels
|
||||
} FloatingText;
|
||||
|
||||
// AudioAssets
|
||||
typedef struct {
|
||||
Sound attack1, attack2, attack3;
|
||||
Sound pickup;
|
||||
Sound staircase;
|
||||
Sound dodge1, dodge2, dodge3;
|
||||
Sound crit;
|
||||
} AudioAssets;
|
||||
|
||||
// GameState - encapsulates all game state for testability and save/load
|
||||
typedef struct {
|
||||
Player player;
|
||||
Map map;
|
||||
Dungeon dungeon;
|
||||
Enemy enemies[MAX_ENEMIES];
|
||||
int enemy_count;
|
||||
Item items[MAX_ITEMS];
|
||||
int item_count;
|
||||
int game_over;
|
||||
int game_won;
|
||||
const char *last_message;
|
||||
int message_timer;
|
||||
int turn_count;
|
||||
int awaiting_descend; // 0 = normal, 1 = waiting for Y/N
|
||||
int show_inventory; // 0 = hidden, 1 = show overlay
|
||||
int inv_selected; // currently selected inventory index
|
||||
// action log
|
||||
char action_log[5][128];
|
||||
int log_count;
|
||||
int log_head;
|
||||
// visual effects
|
||||
FloatingText floating_texts[8];
|
||||
int floating_count;
|
||||
int screen_shake; // frames of screen shake remaining
|
||||
int shake_x;
|
||||
int shake_y;
|
||||
AudioAssets sounds;
|
||||
// Statistics
|
||||
int total_kills;
|
||||
int items_collected;
|
||||
int damage_dealt;
|
||||
int damage_taken;
|
||||
int crits_landed;
|
||||
int times_hit;
|
||||
int potions_used;
|
||||
int floors_reached;
|
||||
int final_score;
|
||||
// Seed for this run
|
||||
unsigned int run_seed;
|
||||
} GameState;
|
||||
|
||||
#endif // GAME_STATE_H
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
#include "common.h"
|
||||
#include "map/map.h"
|
||||
#include "rng/rng.h"
|
||||
#include "map.h"
|
||||
#include "rng.h"
|
||||
#include "settings.h"
|
||||
#include <stddef.h>
|
||||
|
||||
|
|
|
|||
178
src/main.c
178
src/main.c
|
|
@ -1,20 +1,17 @@
|
|||
#include "audio.h"
|
||||
#include "combat.h"
|
||||
#include "game_state.h"
|
||||
#include "common.h"
|
||||
#include "enemy.h"
|
||||
#include "items.h"
|
||||
#include "map/map.h"
|
||||
#include "movement.h"
|
||||
#include "map.h"
|
||||
#include "player.h"
|
||||
#include "raylib.h"
|
||||
#include "render.h"
|
||||
#include "rng/rng.h"
|
||||
#include "rng.h"
|
||||
#include "settings.h"
|
||||
#include <ctype.h>
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
// Add message to action log
|
||||
static void add_log(GameState *gs, const char *msg) {
|
||||
|
|
@ -104,14 +101,11 @@ static void update_effects(GameState *gs) {
|
|||
|
||||
// Initialize a new floor
|
||||
static void init_floor(GameState *gs, int floor_num) {
|
||||
// Seed RNG with run seed combined with floor number for deterministic generation
|
||||
rng_seed(gs->run_seed + floor_num * 54321);
|
||||
|
||||
// Generate dungeon
|
||||
dungeon_generate(&gs->dungeon, &gs->map, floor_num);
|
||||
|
||||
// Seed rng for this floor's content
|
||||
rng_seed(gs->run_seed + floor_num * 98765);
|
||||
rng_seed(floor_num * 54321);
|
||||
|
||||
// Find spawn position
|
||||
int start_x, start_y;
|
||||
|
|
@ -123,14 +117,11 @@ static void init_floor(GameState *gs, int floor_num) {
|
|||
gs->floors_reached = 1;
|
||||
} else {
|
||||
// Move player to new floor position
|
||||
gs->player.position.x = start_x;
|
||||
gs->player.position.y = start_y;
|
||||
gs->player.x = start_x;
|
||||
gs->player.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);
|
||||
|
||||
|
|
@ -146,8 +137,7 @@ 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.position.x * TILE_SIZE + 8, gs->player.position.y * TILE_SIZE, player_effect_dmg,
|
||||
0);
|
||||
spawn_floating_text(gs, gs->player.x * TILE_SIZE + 8, gs->player.y * TILE_SIZE, player_effect_dmg, 0);
|
||||
gs->screen_shake = SHAKE_EFFECT_DURATION;
|
||||
}
|
||||
|
||||
|
|
@ -165,7 +155,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->position.x * TILE_SIZE + 8, e->position.y * TILE_SIZE, enemy_effect_dmg, 0);
|
||||
spawn_floating_text(gs, e->x * TILE_SIZE + 8, e->y * TILE_SIZE, enemy_effect_dmg, 0);
|
||||
}
|
||||
if (!e->alive) {
|
||||
add_log(gs, "Enemy died from effects!");
|
||||
|
|
@ -183,7 +173,7 @@ static void post_action(GameState *gs, Enemy *attacked_enemy) {
|
|||
return;
|
||||
|
||||
// Check if stepped on stairs
|
||||
if (gs->map.tiles[gs->player.position.y][gs->player.position.x] == TILE_STAIRS) {
|
||||
if (gs->map.tiles[gs->player.y][gs->player.x] == TILE_STAIRS) {
|
||||
gs->awaiting_descend = 1;
|
||||
gs->last_message = "Descend to next floor? (Y/N)";
|
||||
gs->message_timer = 120;
|
||||
|
|
@ -192,8 +182,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->position.x * TILE_SIZE + 8;
|
||||
int ey = attacked_enemy->position.y * TILE_SIZE;
|
||||
int ex = attacked_enemy->x * TILE_SIZE + 8;
|
||||
int ey = attacked_enemy->y * TILE_SIZE;
|
||||
|
||||
if (combat_was_dodged()) {
|
||||
spawn_floating_label(gs, ex, ey, LABEL_DODGE, EFFECT_NONE);
|
||||
|
|
@ -225,9 +215,6 @@ 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);
|
||||
|
||||
|
|
@ -237,8 +224,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.position.x * TILE_SIZE + 8, gs->player.position.y * TILE_SIZE,
|
||||
combat_get_last_damage(), combat_was_critical());
|
||||
spawn_floating_text(gs, gs->player.x * TILE_SIZE + 8, gs->player.y * TILE_SIZE, combat_get_last_damage(),
|
||||
combat_was_critical());
|
||||
}
|
||||
|
||||
// Set message and check game over
|
||||
|
|
@ -259,7 +246,6 @@ 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!";
|
||||
|
|
@ -402,7 +388,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.position.x, gs->player.position.y);
|
||||
Item *item = get_item_at_floor(gs->items, gs->item_count, gs->player.x, gs->player.y);
|
||||
if (item != NULL) {
|
||||
if (player_pickup(&gs->player, item)) {
|
||||
gs->items_collected++;
|
||||
|
|
@ -431,45 +417,38 @@ static int handle_movement_input(GameState *gs) {
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
Vec2 direction = {0, 0};
|
||||
// Movement: use IsKeyDown for held-key repeat
|
||||
int dx = 0, dy = 0;
|
||||
if (IsKeyDown(KEY_W) || IsKeyDown(KEY_UP))
|
||||
direction.y = -1;
|
||||
dy = -1;
|
||||
else if (IsKeyDown(KEY_S) || IsKeyDown(KEY_DOWN))
|
||||
direction.y = 1;
|
||||
dy = 1;
|
||||
else if (IsKeyDown(KEY_A) || IsKeyDown(KEY_LEFT))
|
||||
direction.x = -1;
|
||||
dx = -1;
|
||||
else if (IsKeyDown(KEY_D) || IsKeyDown(KEY_RIGHT))
|
||||
direction.x = 1;
|
||||
dx = 1;
|
||||
|
||||
if (direction.x == 0 && direction.y == 0)
|
||||
if (dx == 0 && dy == 0)
|
||||
return 0;
|
||||
|
||||
// Reset combat event before player acts
|
||||
combat_reset_event();
|
||||
|
||||
|
||||
int new_x = gs->player.position.x + direction.x;
|
||||
int new_y = gs->player.position.y + direction.y;
|
||||
|
||||
Enemy *target = NULL;
|
||||
int new_x = gs->player.x + dx;
|
||||
int new_y = gs->player.y + dy;
|
||||
int action = 0;
|
||||
|
||||
MoveResult result =
|
||||
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);
|
||||
// Attack enemy at target tile, or move into it
|
||||
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 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);
|
||||
post_action(gs, target); // target is NULL on move, enemy ptr on attack
|
||||
|
||||
return action;
|
||||
}
|
||||
|
|
@ -483,13 +462,7 @@ static int handle_input(GameState *gs) {
|
|||
// Check for restart (works during game over)
|
||||
if (IsKeyPressed(KEY_R) && gs->game_over) {
|
||||
memset(gs, 0, sizeof(GameState));
|
||||
// Generate a new random seed for the new run
|
||||
gs->run_seed = (unsigned int)time(NULL);
|
||||
init_floor(gs, 1);
|
||||
// Update window title with new seed
|
||||
char title[128];
|
||||
snprintf(title, sizeof(title), "Roguelike - Seed: %u", gs->run_seed);
|
||||
SetWindowTitle(title);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -519,16 +492,12 @@ void load_audio_assets(GameState *gs) {
|
|||
}
|
||||
|
||||
// Main game loop
|
||||
static void game_loop(unsigned int run_seed) {
|
||||
static void game_loop(void) {
|
||||
GameState gs;
|
||||
memset(&gs, 0, sizeof(GameState));
|
||||
gs.run_seed = run_seed;
|
||||
// load external assets
|
||||
// sound
|
||||
load_audio_assets(&gs);
|
||||
// font
|
||||
Font fontTTF = LoadFontEx("./assets/fonts/spartan_500.ttf", 36, NULL, 0);
|
||||
// Initialize first floor
|
||||
rng_seed(12345);
|
||||
init_floor(&gs, 1);
|
||||
|
||||
// Disable esc to exit
|
||||
|
|
@ -548,16 +517,10 @@ static void game_loop(unsigned int run_seed) {
|
|||
break;
|
||||
if (IsKeyPressed(KEY_R)) {
|
||||
memset(&gs, 0, sizeof(GameState));
|
||||
// Generate a new random seed for the new run
|
||||
gs.run_seed = (unsigned int)time(NULL);
|
||||
gs.game_over = 0;
|
||||
gs.game_won = 0;
|
||||
load_audio_assets(&gs);
|
||||
init_floor(&gs, 1);
|
||||
// Update window title with new seed
|
||||
char title[128];
|
||||
snprintf(title, sizeof(title), "Roguelike - Seed: %u", gs.run_seed);
|
||||
SetWindowTitle(title);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -578,31 +541,28 @@ static void game_loop(unsigned int run_seed) {
|
|||
cam.offset = (Vector2){(float)gs.shake_x, (float)gs.shake_y};
|
||||
BeginMode2D(cam);
|
||||
render_map(&gs.map);
|
||||
render_items(gs.items, gs.item_count, gs.map.visible);
|
||||
render_enemies(gs.enemies, gs.enemy_count, gs.map.visible);
|
||||
render_items(gs.items, gs.item_count);
|
||||
render_enemies(gs.enemies, gs.enemy_count);
|
||||
render_player(&gs.player);
|
||||
EndMode2D();
|
||||
|
||||
// Floating texts follow world shake
|
||||
render_floating_texts(gs.floating_texts, gs.floating_count, gs.shake_x, gs.shake_y);
|
||||
render_ui(&gs.player, &fontTTF);
|
||||
render_ui(&gs.player);
|
||||
|
||||
// Draw action log
|
||||
render_action_log(gs.action_log, gs.log_count, gs.log_head, &fontTTF);
|
||||
render_action_log(gs.action_log, gs.log_count, gs.log_head);
|
||||
|
||||
// Draw inventory overlay if active
|
||||
if (gs.show_inventory) {
|
||||
render_inventory_overlay(&gs.player, gs.inv_selected, &fontTTF);
|
||||
render_inventory_overlay(&gs.player, gs.inv_selected);
|
||||
}
|
||||
|
||||
// Draw message if any
|
||||
if (gs.last_message != NULL && gs.message_timer > 0) {
|
||||
render_message(gs.last_message, &fontTTF);
|
||||
render_message(gs.last_message);
|
||||
}
|
||||
|
||||
// Draw persistent seed display in top right
|
||||
render_seed_display(gs.run_seed);
|
||||
|
||||
// Draw game over screen
|
||||
if (gs.game_over) {
|
||||
// Compute final score
|
||||
|
|
@ -613,7 +573,7 @@ static void game_loop(unsigned int run_seed) {
|
|||
}
|
||||
render_end_screen(gs.game_won, gs.total_kills, gs.items_collected, gs.damage_dealt, gs.damage_taken,
|
||||
gs.crits_landed, gs.times_hit, gs.potions_used, gs.floors_reached, gs.turn_count,
|
||||
gs.final_score, gs.run_seed, &fontTTF);
|
||||
gs.final_score);
|
||||
}
|
||||
|
||||
EndDrawing();
|
||||
|
|
@ -623,67 +583,17 @@ static void game_loop(unsigned int run_seed) {
|
|||
}
|
||||
}
|
||||
|
||||
// Check if a string is a valid unsigned integer
|
||||
static int is_valid_uint(const char *str) {
|
||||
if (str == NULL || *str == '\0')
|
||||
return 0;
|
||||
// Check for optional leading +
|
||||
if (*str == '+')
|
||||
str++;
|
||||
// Must have at least one digit
|
||||
if (*str == '\0')
|
||||
return 0;
|
||||
// All characters must be digits
|
||||
for (const char *p = str; *p != '\0'; p++) {
|
||||
if (!isdigit((unsigned char)*p))
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
// Parse command-line arguments
|
||||
unsigned int run_seed = 0;
|
||||
int seed_provided = 0;
|
||||
|
||||
for (int i = 1; i < argc; i++) {
|
||||
if (strcmp(argv[i], "--seed") == 0) {
|
||||
if (i + 1 >= argc) {
|
||||
fprintf(stderr, "Error: --seed requires a value\n");
|
||||
fprintf(stderr, "Usage: %s [--seed <number>]\n", argv[0]);
|
||||
return 1;
|
||||
}
|
||||
const char *seed_str = argv[i + 1];
|
||||
if (!is_valid_uint(seed_str)) {
|
||||
fprintf(stderr, "Error: Invalid seed value: %s\n", seed_str);
|
||||
fprintf(stderr, "Seed must be a non-negative integer\n");
|
||||
return 1;
|
||||
}
|
||||
run_seed = (unsigned int)strtoul(seed_str, NULL, 10);
|
||||
seed_provided = 1;
|
||||
i++; // Skip the value
|
||||
}
|
||||
}
|
||||
|
||||
// If no seed provided, generate random seed from time
|
||||
if (!seed_provided) {
|
||||
run_seed = (unsigned int)time(NULL);
|
||||
}
|
||||
|
||||
printf("Starting game with seed: %u\n", run_seed);
|
||||
|
||||
int main(void) {
|
||||
// Initialize audio
|
||||
audio_init();
|
||||
// Initialize random number generator
|
||||
SetRandomSeed(88435);
|
||||
// Initialize window with seed in title
|
||||
char title[128];
|
||||
snprintf(title, sizeof(title), "Roguelike - Seed: %u", run_seed);
|
||||
InitWindow(SCREEN_WIDTH, SCREEN_HEIGHT + 60, title);
|
||||
// Initialize window
|
||||
InitWindow(SCREEN_WIDTH, SCREEN_HEIGHT + 60, "Roguelike");
|
||||
SetTargetFPS(60);
|
||||
|
||||
// Run game
|
||||
game_loop(run_seed);
|
||||
game_loop();
|
||||
|
||||
// Cleanup
|
||||
CloseWindow();
|
||||
|
|
|
|||
|
|
@ -1,8 +1,6 @@
|
|||
#include "map.h"
|
||||
#include "rng/rng.h"
|
||||
#include "settings.h"
|
||||
#include "rng.h"
|
||||
#include "utils.h"
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
void map_init(Map *map) {
|
||||
|
|
@ -12,8 +10,6 @@ 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;
|
||||
}
|
||||
|
||||
|
|
@ -170,6 +166,9 @@ void get_random_floor_tile(Map *map, int *x, int *y, int attempts) {
|
|||
}
|
||||
|
||||
void dungeon_generate(Dungeon *d, Map *map, int floor_num) {
|
||||
// Seed RNG with floor number for deterministic generation
|
||||
rng_seed(floor_num * 12345);
|
||||
|
||||
// Initialize map to all walls
|
||||
map_init(map);
|
||||
|
||||
|
|
@ -187,67 +186,3 @@ 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -18,10 +18,4 @@ 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
|
||||
|
|
@ -1,29 +0,0 @@
|
|||
#include "movement.h"
|
||||
#include "enemy.h"
|
||||
#include "map/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;
|
||||
}
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
#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
|
||||
31
src/player.c
31
src/player.c
|
|
@ -2,12 +2,15 @@
|
|||
#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->position.x = x;
|
||||
p->position.y = y;
|
||||
p->x = x;
|
||||
p->y = y;
|
||||
p->hp = PLAYER_BASE_HP;
|
||||
p->max_hp = PLAYER_BASE_HP;
|
||||
p->attack = PLAYER_BASE_ATTACK;
|
||||
|
|
@ -40,20 +43,36 @@ 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].position.x == x && enemies[i].position.y == y)
|
||||
if (enemies[i].alive && enemies[i].x == x && enemies[i].y == y)
|
||||
return &enemies[i];
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void player_on_move(Player *p) {
|
||||
int player_move(Player *p, int dx, int dy, Map *map) {
|
||||
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) {
|
||||
|
|
@ -209,8 +228,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->position.x;
|
||||
items[i].y = p->position.y;
|
||||
items[i].x = p->x;
|
||||
items[i].y = p->y;
|
||||
items[i].picked_up = 0;
|
||||
// Remove from inventory
|
||||
player_remove_inventory_item(p, inv_index);
|
||||
|
|
|
|||
|
|
@ -6,8 +6,8 @@
|
|||
// Initialize player at position
|
||||
void player_init(Player *p, int x, int y);
|
||||
|
||||
// Apply status effects, healing, etc
|
||||
void player_on_move(Player *p);
|
||||
// Move player to (x+dx, y+dy); returns 1 if moved, 0 if blocked
|
||||
int player_move(Player *p, int dx, int dy, Map *map);
|
||||
|
||||
// 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);
|
||||
|
|
|
|||
420
src/render.c
420
src/render.c
|
|
@ -1,5 +1,7 @@
|
|||
#include "render.h"
|
||||
#include "common.h"
|
||||
#include "items.h"
|
||||
#include "raylib.h"
|
||||
#include "settings.h"
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
|
|
@ -9,31 +11,18 @@ 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, wall_color);
|
||||
DrawRectangleRec(rect, DARKGRAY);
|
||||
break;
|
||||
case TILE_FLOOR:
|
||||
DrawRectangleRec(rect, floor_color);
|
||||
DrawRectangleRec(rect, BLACK);
|
||||
break;
|
||||
case TILE_STAIRS:
|
||||
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});
|
||||
DrawRectangleRec(rect, (Color){100, 100, 100, 255});
|
||||
// Draw stairs marker
|
||||
DrawText(">", x * TILE_SIZE + 4, y * TILE_SIZE + 2, 12, WHITE);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -41,20 +30,17 @@ void render_map(const Map *map) {
|
|||
}
|
||||
|
||||
void render_player(const Player *p) {
|
||||
Rectangle rect = {(float)(p->position.x * TILE_SIZE), (float)(p->position.y * TILE_SIZE), (float)TILE_SIZE,
|
||||
(float)TILE_SIZE};
|
||||
Rectangle rect = {(float)(p->x * TILE_SIZE), (float)(p->y * TILE_SIZE), (float)TILE_SIZE, (float)TILE_SIZE};
|
||||
DrawRectangleRec(rect, BLUE);
|
||||
}
|
||||
|
||||
void render_enemies(const Enemy *enemies, int count, const unsigned char visible[MAP_HEIGHT][MAP_WIDTH]) {
|
||||
void render_enemies(const Enemy *enemies, int count) {
|
||||
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};
|
||||
Rectangle rect = {(float)(enemies[i].x * TILE_SIZE), (float)(enemies[i].y * TILE_SIZE), (float)TILE_SIZE,
|
||||
(float)TILE_SIZE};
|
||||
|
||||
// Different colors based on enemy type
|
||||
Color enemy_color;
|
||||
|
|
@ -86,19 +72,17 @@ void render_enemies(const Enemy *enemies, int count, const unsigned char visible
|
|||
bar_color = (Color){200, 180, 40, 255}; // yellow
|
||||
else
|
||||
bar_color = (Color){200, 60, 60, 255}; // red
|
||||
Rectangle hp_bar = {(float)(enemies[i].position.x * TILE_SIZE), (float)(enemies[i].position.y * TILE_SIZE - 4),
|
||||
(float)hp_pixels, 3};
|
||||
Rectangle hp_bar = {(float)(enemies[i].x * TILE_SIZE), (float)(enemies[i].y * TILE_SIZE - 4), (float)hp_pixels,
|
||||
3};
|
||||
DrawRectangleRec(hp_bar, bar_color);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void render_items(const Item *items, int count, const unsigned char visible[MAP_HEIGHT][MAP_WIDTH]) {
|
||||
void render_items(const Item *items, int count) {
|
||||
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};
|
||||
|
|
@ -124,36 +108,33 @@ void render_items(const Item *items, int count, const unsigned char visible[MAP_
|
|||
}
|
||||
}
|
||||
|
||||
void render_ui(const Player *p, Font *font) {
|
||||
// HUD Panel
|
||||
const int hud_y = MAP_HEIGHT * TILE_SIZE;
|
||||
const int hud_height = 60;
|
||||
const Color hud_bg = {25, 20, 15, 255}; // dark parchment
|
||||
const Color hud_border = {139, 119, 89, 255}; // bronze/brown border
|
||||
const Color text_dim = {160, 150, 140, 255}; // dimmed text
|
||||
const Color text_bright = {240, 230, 220, 255}; // bright text
|
||||
static void draw_hud_background(int hud_y, int hud_height, Color hud_bg, Color hud_border, Color magic_a, Color magic_b ) {
|
||||
// Main HUD background with border
|
||||
Rectangle ui_bg = {0, (float)hud_y, (float)SCREEN_WIDTH, (float)hud_height};
|
||||
DrawRectangleRec(ui_bg, hud_bg);
|
||||
DrawRectangleLines(0, hud_y, SCREEN_WIDTH, hud_height, hud_border);
|
||||
DrawLine(0, hud_y + 1, SCREEN_WIDTH, hud_y + 1, magic_a);
|
||||
DrawLine(0, hud_y + hud_height - 2, SCREEN_WIDTH, hud_y + hud_height - 2, magic_b); // Magic number 2, probably offset from window bottom
|
||||
}
|
||||
|
||||
// Main HUD background with border
|
||||
Rectangle ui_bg = {0, (float)hud_y, (float)SCREEN_WIDTH, (float)hud_height};
|
||||
DrawRectangleRec(ui_bg, hud_bg);
|
||||
DrawRectangleLines(0, hud_y, SCREEN_WIDTH, hud_height, hud_border);
|
||||
DrawLine(0, hud_y + 1, SCREEN_WIDTH, hud_y + 1, (Color){60, 55, 50, 255});
|
||||
DrawLine(0, hud_y + hud_height - 2, SCREEN_WIDTH, hud_y + hud_height - 2, (Color){15, 12, 10, 255});
|
||||
|
||||
// Section dividers
|
||||
int section1_end = 180; // after portrait + HP bar
|
||||
int section2_end = 310; // after stats
|
||||
int section3_end = 480; // after equipment
|
||||
|
||||
DrawLine(section1_end, hud_y + 5, section1_end, hud_y + hud_height - 5, (Color){60, 55, 50, 255});
|
||||
DrawLine(section1_end + 1, hud_y + 5, section1_end + 1, hud_y + hud_height - 5, (Color){15, 12, 10, 255});
|
||||
|
||||
DrawLine(section2_end, hud_y + 5, section2_end, hud_y + hud_height - 5, (Color){60, 55, 50, 255});
|
||||
DrawLine(section2_end + 1, hud_y + 5, section2_end + 1, hud_y + hud_height - 5, (Color){15, 12, 10, 255});
|
||||
static void draw_section_divider(int hud_y, int section_x, int border_gap, int hud_height, Color magic_a, Color magic_b) {
|
||||
DrawLine(section_x, hud_y + border_gap, section_x, hud_y + hud_height - border_gap, magic_a);
|
||||
DrawLine(section_x + 1, hud_y + border_gap, section_x + 1, hud_y + hud_height - border_gap, magic_b);
|
||||
}
|
||||
|
||||
static void draw_player_life(
|
||||
const Player *p, int hud_y, Color text_bright, Color text_dim, Color full_health,
|
||||
Color low_health, Color crit_health, Color hp_background, Color hp_outline
|
||||
) {
|
||||
// HP Bar, to the right of portrait
|
||||
int portrait_x = 8;
|
||||
int portrait_y = hud_y + 8;
|
||||
int portrait_size = 44;
|
||||
int bar_x = portrait_x + portrait_size + 8;
|
||||
int bar_y = hud_y + 22;
|
||||
int bar_width = 100;
|
||||
int bar_height = 16;
|
||||
|
||||
|
||||
// FIXME: for now this is just a blue square indicating the player. Once we
|
||||
// model the player, add classes, sprites, etc. this will need to be revisited.
|
||||
|
|
@ -161,30 +142,23 @@ void render_ui(const Player *p, Font *font) {
|
|||
DrawRectangle(portrait_x + 2, portrait_y + 2, portrait_size - 4, portrait_size - 4, BLUE);
|
||||
DrawRectangleLines(portrait_x, portrait_y, portrait_size, portrait_size, (Color){139, 119, 89, 255});
|
||||
|
||||
// HP Bar, to the right of portrait
|
||||
int bar_x = portrait_x + portrait_size + 8;
|
||||
int bar_y = hud_y + 20;
|
||||
int bar_width = 100;
|
||||
int bar_height = 16;
|
||||
|
||||
// HP Label, above bar
|
||||
// Vector2 hp_width = MeasureTextEx(*font, "HP", BIG_FONT, NAR_CHAR_SPACE);
|
||||
DrawTextEx(*font, "HP", (Vector2){bar_x, bar_y - 17}, BIG_FONT, NAR_CHAR_SPACE, text_dim);
|
||||
DrawText("HP", bar_x, bar_y - 11, 9, text_dim);
|
||||
|
||||
// HP Bar background
|
||||
DrawRectangle(bar_x, bar_y, bar_width, bar_height, (Color){20, 15, 15, 255});
|
||||
DrawRectangleLines(bar_x, bar_y, bar_width, bar_height, (Color){80, 70, 60, 255});
|
||||
DrawRectangle(bar_x, bar_y, bar_width, bar_height, hp_background);
|
||||
DrawRectangleLines(bar_x, bar_y, bar_width, bar_height, hp_outline);
|
||||
|
||||
// HP Bar fill
|
||||
float hp_percent = (float)p->hp / p->max_hp;
|
||||
int fill_width = (int)(bar_width * hp_percent);
|
||||
Color hp_color;
|
||||
if (hp_percent > 0.6f) {
|
||||
hp_color = (Color){60, 180, 60, 255};
|
||||
hp_color = full_health;
|
||||
} else if (hp_percent > 0.3f) {
|
||||
hp_color = (Color){200, 180, 40, 255};
|
||||
hp_color = low_health;
|
||||
} else {
|
||||
hp_color = (Color){200, 60, 60, 255};
|
||||
hp_color = crit_health;
|
||||
}
|
||||
|
||||
if (fill_width > 0) {
|
||||
|
|
@ -194,9 +168,8 @@ void render_ui(const Player *p, Font *font) {
|
|||
// HP text, centered in bar
|
||||
char hp_text[32];
|
||||
snprintf(hp_text, sizeof(hp_text), "%d/%d", p->hp, p->max_hp);
|
||||
int hp_text_w = MeasureText(hp_text, 12);
|
||||
DrawTextEx(*font, hp_text, (Vector2){bar_x + (bar_width - hp_text_w) / 2.0f, bar_y + 2}, MEDIUM_FONT,
|
||||
SMALL_CHAR_SPACE, WHITE);
|
||||
int hp_text_w = MeasureText(hp_text, 10);
|
||||
DrawText(hp_text, bar_x + (bar_width - hp_text_w) / 2, bar_y + 3, 10, WHITE);
|
||||
|
||||
// Status effects
|
||||
int effect_x = bar_x;
|
||||
|
|
@ -231,80 +204,118 @@ void render_ui(const Player *p, Font *font) {
|
|||
if (p->effects[i].duration > 0) {
|
||||
char eff_text[16];
|
||||
snprintf(eff_text, sizeof(eff_text), "%s%d", eff_label, p->effects[i].duration);
|
||||
DrawTextEx(*font, eff_text, (Vector2){effect_x, effect_y}, SMALL_FONT, NAR_CHAR_SPACE, eff_color);
|
||||
DrawText(eff_text, effect_x, effect_y, 9, eff_color);
|
||||
effect_x += 28;
|
||||
}
|
||||
}
|
||||
|
||||
int stats_x = section1_end + 15;
|
||||
int stats_y = hud_y + 12;
|
||||
int stat_spacing = 40;
|
||||
|
||||
// Floor
|
||||
char floor_text[16];
|
||||
snprintf(floor_text, sizeof(floor_text), "F%d", p->floor);
|
||||
DrawTextEx(*font, floor_text, (Vector2){stats_x, stats_y}, 16, NORM_CHAR_SPACE, text_bright);
|
||||
DrawTextEx(*font, "Floor", (Vector2){stats_x, stats_y + 16}, 12, NAR_CHAR_SPACE, text_dim);
|
||||
|
||||
// ATK
|
||||
char atk_text[16];
|
||||
snprintf(atk_text, sizeof(atk_text), "%d", p->attack);
|
||||
DrawTextEx(*font, atk_text, (Vector2){stats_x + stat_spacing, stats_y}, 16, NORM_CHAR_SPACE, YELLOW);
|
||||
DrawTextEx(*font, "ATK", (Vector2){stats_x + stat_spacing, stats_y + 16}, 12, NAR_CHAR_SPACE, text_dim);
|
||||
|
||||
// DEF
|
||||
char def_text[16];
|
||||
snprintf(def_text, sizeof(def_text), "%d", p->defense);
|
||||
DrawTextEx(*font, def_text, (Vector2){stats_x + stat_spacing * 2, stats_y}, 16, NORM_CHAR_SPACE,
|
||||
(Color){100, 150, 255, 255});
|
||||
DrawTextEx(*font, "DEF", (Vector2){stats_x + stat_spacing * 2, stats_y + 16}, 12, NAR_CHAR_SPACE, text_dim);
|
||||
|
||||
int equip_x = section2_end + 15;
|
||||
int equip_y = hud_y + 8;
|
||||
|
||||
// Weapon slot
|
||||
DrawTextEx(*font, "WEAPON", (Vector2){equip_x, equip_y}, MEDIUM_FONT, NAR_CHAR_SPACE, text_dim);
|
||||
if (p->has_weapon) {
|
||||
const char *weapon_name = item_get_name(&p->equipped_weapon);
|
||||
if (weapon_name) {
|
||||
char weapon_text[64];
|
||||
snprintf(weapon_text, sizeof(weapon_text), "%s +%d [%s]", weapon_name, p->equipped_weapon.power,
|
||||
dmg_class_get_short(p->equipped_weapon.dmg_class));
|
||||
DrawTextEx(*font, weapon_text, (Vector2){equip_x, equip_y + 11}, 10, NAR_CHAR_SPACE, (Color){255, 220, 100, 255});
|
||||
}
|
||||
} else {
|
||||
DrawTextEx(*font, "None [IMP]", (Vector2){equip_x, equip_y + 11}, 10, NAR_CHAR_SPACE, (Color){80, 75, 70, 255});
|
||||
}
|
||||
|
||||
// Armor slot
|
||||
DrawTextEx(*font, "ARMOR", (Vector2){equip_x, equip_y + 26}, MEDIUM_FONT, NAR_CHAR_SPACE, text_dim);
|
||||
if (p->has_armor) {
|
||||
const char *armor_name = item_get_name(&p->equipped_armor);
|
||||
if (armor_name) {
|
||||
char armor_text[48];
|
||||
snprintf(armor_text, sizeof(armor_text), "%s +%d", armor_name, p->equipped_armor.power);
|
||||
DrawTextEx(*font, armor_text, (Vector2){equip_x, equip_y + 37}, 10, NAR_CHAR_SPACE, (Color){100, 150, 255, 255});
|
||||
}
|
||||
} else {
|
||||
DrawTextEx(*font, "None", (Vector2){equip_x, equip_y + 37}, 10, NAR_CHAR_SPACE, (Color){80, 75, 70, 255});
|
||||
}
|
||||
|
||||
int ctrl_x = section3_end + 20;
|
||||
int ctrl_y = hud_y + 14;
|
||||
|
||||
DrawTextEx(*font, "[WASD] Move [G] Pickup [I] Inventory [U] Use", (Vector2){ctrl_x, ctrl_y}, MEDIUM_FONT,
|
||||
MED_CHAR_SPACE, (Color){139, 119, 89, 255});
|
||||
DrawTextEx(*font, "[E] Equip [D] Drop [Q] Quit", (Vector2){ctrl_x, ctrl_y + 16}, MEDIUM_FONT, MED_CHAR_SPACE,
|
||||
(Color){139, 119, 89, 255});
|
||||
|
||||
// INV count in top-right corner of HUD
|
||||
char inv_text[16];
|
||||
snprintf(inv_text, sizeof(inv_text), "INV: %d/%d", p->inventory_count, MAX_INVENTORY);
|
||||
int inv_width = MeasureText(inv_text, 10);
|
||||
DrawTextEx(*font, inv_text, (Vector2){SCREEN_WIDTH - inv_width - 10, hud_y + 5}, 10, NAR_CHAR_SPACE, GREEN);
|
||||
}
|
||||
|
||||
void render_action_log(const char log[5][128], int count, int head, Font *font) {
|
||||
static void draw_player_stats(
|
||||
const Player *p, int hud_y, int stats_x, Color text_bright, Color text_dim
|
||||
) {
|
||||
int stats_y = hud_y + 12;
|
||||
int stat_spacing = 40;
|
||||
|
||||
char floor_text[16];
|
||||
snprintf(floor_text, sizeof(floor_text), "F%d", p->floor);
|
||||
DrawText(floor_text, stats_x, stats_y, 14, text_bright);
|
||||
DrawText("Floor", stats_x, stats_y + 16, 9, text_dim);
|
||||
|
||||
char atk_text[16];
|
||||
snprintf(atk_text, sizeof(atk_text), "%d", p->attack);
|
||||
DrawText(atk_text, stats_x + stat_spacing, stats_y, 14, YELLOW);
|
||||
DrawText("ATK", stats_x + stat_spacing, stats_y + 16, 9, text_dim);
|
||||
|
||||
char def_text[16];
|
||||
snprintf(def_text, sizeof(def_text), "%d", p->defense);
|
||||
DrawText(def_text, stats_x + stat_spacing * 2, stats_y, 14, (Color){100, 150, 255, 255});
|
||||
DrawText("DEF", stats_x + stat_spacing * 2, stats_y + 16, 9, text_dim);
|
||||
}
|
||||
|
||||
static void draw_equipment(
|
||||
const Player *p, int hud_y, int equip_x, Color text_dim
|
||||
) {
|
||||
int equip_y = hud_y + 8;
|
||||
|
||||
DrawText("WEAPON", equip_x, equip_y, 9, text_dim);
|
||||
if (p->has_weapon) {
|
||||
const char *weapon_name = item_get_name(&p->equipped_weapon);
|
||||
if (weapon_name) {
|
||||
char weapon_text[64];
|
||||
snprintf(weapon_text, sizeof(weapon_text), "%s +%d [%s]",
|
||||
weapon_name, p->equipped_weapon.power,
|
||||
dmg_class_get_short(p->equipped_weapon.dmg_class));
|
||||
DrawText(weapon_text, equip_x, equip_y + 11, 10, (Color){255, 220, 100, 255});
|
||||
}
|
||||
} else {
|
||||
DrawText("None [IMP]", equip_x, equip_y + 11, 10, (Color){80, 75, 70, 255});
|
||||
}
|
||||
|
||||
DrawText("ARMOR", equip_x, equip_y + 26, 9, text_dim);
|
||||
if (p->has_armor) {
|
||||
const char *armor_name = item_get_name(&p->equipped_armor);
|
||||
if (armor_name) {
|
||||
char armor_text[48];
|
||||
snprintf(armor_text, sizeof(armor_text), "%s +%d",
|
||||
armor_name, p->equipped_armor.power);
|
||||
DrawText(armor_text, equip_x, equip_y + 37, 10, (Color){100, 150, 255, 255});
|
||||
}
|
||||
} else {
|
||||
DrawText("None", equip_x, equip_y + 37, 10, (Color){80, 75, 70, 255});
|
||||
}
|
||||
}
|
||||
|
||||
static void draw_controls_inv(const Player *p, int hud_y, int ctrl_x, Color controls_color) {
|
||||
int ctrl_y = hud_y + 14;
|
||||
DrawText("[WASD] Move [G] Pickup [I] Inventory [U] Use",
|
||||
ctrl_x, ctrl_y, 11, controls_color);
|
||||
DrawText("[E] Equip [D] Drop [Q] Quit",
|
||||
ctrl_x, ctrl_y + 16, 11, controls_color);
|
||||
|
||||
char inv_text[16];
|
||||
snprintf(inv_text, sizeof(inv_text), "INV: %d/%d", p->inventory_count, MAX_INVENTORY);
|
||||
int inv_width = MeasureText(inv_text, 10);
|
||||
DrawText(inv_text, SCREEN_WIDTH - inv_width - 10, hud_y + 5, 10, GREEN);
|
||||
}
|
||||
|
||||
void render_ui(const Player *p) {
|
||||
// HUD Panel
|
||||
const int hud_y = MAP_HEIGHT * TILE_SIZE;
|
||||
const int hud_height = 60;
|
||||
const Color hud_bg = {25, 20, 15, 255}; // dark parchment
|
||||
const Color hud_border = {139, 119, 89, 255}; // bronze/brown border
|
||||
const Color text_dim = {160, 150, 140, 255}; // dimmed text
|
||||
const Color text_bright = {240, 230, 220, 255}; // bright text
|
||||
const Color magic_color_a = {60, 55, 50, 255}; // I don't know what exactly this is (may be top/left colouring)
|
||||
const Color magic_color_b = {15, 12, 10, 255}; // See above (may be bottom/right colouring)
|
||||
const Color full_health = {60, 180, 60, 255};
|
||||
const Color low_health = {200, 180, 40, 255};
|
||||
const Color crit_health = {200, 60, 60, 255};
|
||||
const Color health_bar_background = {20, 15, 15, 255};
|
||||
const Color health_bar_outline = {80, 70, 60, 255};
|
||||
|
||||
draw_hud_background(hud_y, hud_height, hud_bg, hud_border, magic_color_a, magic_color_b);
|
||||
|
||||
// Section dividers
|
||||
int section1_end = 180; // after portrait + HP bar
|
||||
int section2_end = 310; // after stats
|
||||
int section3_end = 480; // after equipment
|
||||
|
||||
draw_section_divider(hud_y, section1_end, 5, hud_height, magic_color_a, magic_color_b);
|
||||
draw_section_divider(hud_y, section2_end, 5, hud_height, magic_color_a, magic_color_b);
|
||||
|
||||
draw_player_life(p, hud_y, text_bright, text_dim, full_health, low_health,
|
||||
crit_health, health_bar_background, health_bar_outline);
|
||||
|
||||
draw_player_stats(p, hud_y, section1_end + 15, text_bright, text_dim);
|
||||
|
||||
draw_equipment(p, hud_y, section2_end + 15, text_dim);
|
||||
|
||||
draw_controls_inv(p, hud_y, section3_end + 20, hud_border);
|
||||
}
|
||||
|
||||
void render_action_log(const char log[5][128], int count, int head) {
|
||||
// Roguelike scroll/log panel styling
|
||||
const int log_width = 250;
|
||||
const int log_height = 90;
|
||||
|
|
@ -326,11 +337,10 @@ void render_action_log(const char log[5][128], int count, int head, Font *font)
|
|||
|
||||
// Title bar
|
||||
DrawRectangle(log_x + 4, log_y + 4, log_width - 8, 16, (Color){30, 25, 20, 255});
|
||||
DrawTextEx(*font, "MESSAGE LOG", (Vector2){log_x + 8, log_y + 6}, MEDIUM_FONT, NAR_CHAR_SPACE,
|
||||
(Color){180, 160, 130, 255});
|
||||
DrawText("MESSAGE LOG", log_x + 8, log_y + 6, 10, (Color){180, 160, 130, 255});
|
||||
|
||||
// Separator line under title
|
||||
DrawLine(log_x + 4, log_y + 22, log_x + log_width - 5, log_y + 22, log_border_dark);
|
||||
DrawLine(log_x + 4, log_y + 22, log_x + log_width - 4, log_y + 22, log_border_dark);
|
||||
|
||||
// Log entries
|
||||
int text_x = log_x + 8;
|
||||
|
|
@ -352,16 +362,15 @@ void render_action_log(const char log[5][128], int count, int head, Font *font)
|
|||
} else {
|
||||
text_color = (Color){120, 110, 100, 200}; // oldest: dim
|
||||
}
|
||||
DrawTextEx(*font, log[idx], (Vector2){text_x, text_start_y + i * line_height}, NORM_FONT, SMALL_CHAR_SPACE,
|
||||
text_color);
|
||||
DrawText(log[idx], text_x, text_start_y + i * line_height, 10, text_color);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void render_inventory_overlay(const Player *p, int selected, Font *font) {
|
||||
void render_inventory_overlay(const Player *p, int selected) {
|
||||
// Overlay dimensions
|
||||
int ov_width = 360;
|
||||
int ov_height = 320;
|
||||
int ov_height = 337;
|
||||
Rectangle overlay = {(float)(SCREEN_WIDTH - ov_width) / 2, (float)(SCREEN_HEIGHT - ov_height) / 2 - 60,
|
||||
(float)ov_width, (float)ov_height};
|
||||
DrawRectangleRec(overlay, (Color){12, 12, 12, 252});
|
||||
|
|
@ -369,15 +378,13 @@ void render_inventory_overlay(const Player *p, int selected, Font *font) {
|
|||
|
||||
// Title
|
||||
const char *title = "INVENTORY";
|
||||
// int title_w = MeasureText(title, 24);
|
||||
Vector2 t_w = MeasureTextEx(*font, title, 30, NORM_CHAR_SPACE);
|
||||
DrawTextEx(*font, title, (Vector2){overlay.x + (overlay.width - t_w.x) / 2, overlay.y + 10}, HUGE_FONT,
|
||||
NORM_CHAR_SPACE, WHITE);
|
||||
int title_w = MeasureText(title, 24);
|
||||
DrawText(title, overlay.x + (overlay.width - title_w) / 2, overlay.y + 12, 24, WHITE);
|
||||
|
||||
// Draw each inventory slot
|
||||
char slot_text[64];
|
||||
int row_height = 26;
|
||||
int start_y = overlay.y + 40;
|
||||
int start_y = overlay.y + 50;
|
||||
|
||||
for (int i = 0; i < MAX_INVENTORY; i++) {
|
||||
int y_pos = start_y + (i * row_height);
|
||||
|
|
@ -387,15 +394,14 @@ void render_inventory_overlay(const Player *p, int selected, Font *font) {
|
|||
|
||||
// Selection highlight
|
||||
if (i == selected) {
|
||||
DrawRectangle((int)overlay.x + 6, y_pos, (int)overlay.width - 12, row_height - 2, (Color){45, 45, 45, 255});
|
||||
DrawRectangleLines((int)overlay.x + 6, y_pos, (int)overlay.width - 12, row_height - 2,
|
||||
DrawRectangle((int)overlay.x + 6, y_pos - 2, (int)overlay.width - 12, row_height - 2, (Color){45, 45, 45, 255});
|
||||
DrawRectangleLines((int)overlay.x + 6, y_pos - 2, (int)overlay.width - 12, row_height - 2,
|
||||
(Color){180, 160, 80, 255});
|
||||
}
|
||||
|
||||
// Slot number
|
||||
snprintf(slot_text, sizeof(slot_text), "%d.", i + 1);
|
||||
DrawTextEx(*font, slot_text, (Vector2){overlay.x + 16, y_pos + 4}, MEDIUM_FONT, SMALL_CHAR_SPACE,
|
||||
(Color){80, 80, 80, 255});
|
||||
DrawText(slot_text, overlay.x + 16, y_pos + 4, 14, (Color){80, 80, 80, 255});
|
||||
|
||||
// Item name
|
||||
const char *name = item_get_name(item);
|
||||
|
|
@ -403,31 +409,31 @@ void render_inventory_overlay(const Player *p, int selected, Font *font) {
|
|||
Color name_color = (item->type == ITEM_POTION) ? (Color){255, 140, 140, 255}
|
||||
: (item->type == ITEM_WEAPON) ? (Color){255, 255, 140, 255}
|
||||
: (Color){140, 140, 255, 255};
|
||||
DrawTextEx(*font, name, (Vector2){overlay.x + 45, y_pos + 4}, NORM_FONT, SMALL_CHAR_SPACE, name_color);
|
||||
DrawText(name, overlay.x + 45, y_pos + 4, 14, name_color);
|
||||
}
|
||||
|
||||
// Power
|
||||
snprintf(slot_text, sizeof(slot_text), "+%d", item->power);
|
||||
DrawTextEx(*font, slot_text, (Vector2){overlay.x + 150, y_pos + 4}, NORM_FONT, SMALL_CHAR_SPACE, YELLOW);
|
||||
DrawText(slot_text, overlay.x + 150, y_pos + 4, 14, YELLOW);
|
||||
|
||||
// Action
|
||||
if (item->type == ITEM_POTION) {
|
||||
DrawTextEx(*font, "[U]se", (Vector2){overlay.x + 200, y_pos + 4}, NORM_FONT, SMALL_CHAR_SPACE, GREEN);
|
||||
DrawText("[U]se", overlay.x + 200, y_pos + 4, 14, GREEN);
|
||||
} else {
|
||||
DrawTextEx(*font, "[E]quip [D]rop", (Vector2){overlay.x + 200, y_pos + 4}, NORM_FONT, SMALL_CHAR_SPACE, GOLD);
|
||||
DrawText("[E]quip [D]rop", overlay.x + 200, y_pos + 4, 14, GOLD);
|
||||
}
|
||||
} else {
|
||||
// Empty slot
|
||||
snprintf(slot_text, sizeof(slot_text), "%d.", i + 1);
|
||||
DrawTextEx(*font, slot_text, (Vector2){overlay.x + 16, y_pos + 4}, MEDIUM_FONT, SMALL_CHAR_SPACE,
|
||||
(Color){40, 40, 40, 255});
|
||||
DrawText(slot_text, overlay.x + 16, y_pos + 4, 14, (Color){40, 40, 40, 255});
|
||||
}
|
||||
}
|
||||
|
||||
// Instructions at bottom
|
||||
const char *hint = "[1-0] Select [E] Equip [U] Use [D] Drop [I/ESC] Close";
|
||||
Vector2 hint_w = MeasureTextEx(*font, hint, SMALL_FONT, NAR_CHAR_SPACE);
|
||||
DrawTextEx(*font, hint, (Vector2){overlay.x + (overlay.width - hint_w.x) / 2.0f, overlay.y + overlay.height - 22},
|
||||
SMALL_FONT, NAR_CHAR_SPACE, (Color){80, 80, 80, 255});
|
||||
int hint_w = MeasureText(hint, 12);
|
||||
DrawText(hint, overlay.x + (overlay.width - hint_w) / 2, overlay.y + overlay.height - 22, 12,
|
||||
(Color){65, 65, 65, 255});
|
||||
}
|
||||
|
||||
static Color label_color(FloatingText *ft, int alpha) {
|
||||
|
|
@ -515,7 +521,7 @@ void render_floating_texts(FloatingText *texts, int count, int shake_x, int shak
|
|||
}
|
||||
|
||||
void render_end_screen(int is_victory, int kills, int items, int damage_dealt, int damage_taken, int crits,
|
||||
int times_hit, int potions, int floors, int turns, int score, unsigned int seed, Font *font) {
|
||||
int times_hit, int potions, int floors, int turns, int score) {
|
||||
// Semi-transparent overlay
|
||||
Rectangle overlay = {0, 0, (float)SCREEN_WIDTH, (float)SCREEN_HEIGHT};
|
||||
DrawRectangleRec(overlay, (Color){0, 0, 0, 210});
|
||||
|
|
@ -525,14 +531,13 @@ void render_end_screen(int is_victory, int kills, int items, int damage_dealt, i
|
|||
int title_font_size = 60;
|
||||
Color title_color = is_victory ? GOLD : RED;
|
||||
int title_width = MeasureText(title, title_font_size);
|
||||
DrawTextEx(*font, title, (Vector2){(SCREEN_WIDTH - title_width) / 2.0f, 30}, title_font_size, NORM_CHAR_SPACE,
|
||||
title_color);
|
||||
DrawText(title, (SCREEN_WIDTH - title_width) / 2, 30, title_font_size, title_color);
|
||||
|
||||
// Stats box
|
||||
int box_x = SCREEN_WIDTH / 2 - 200;
|
||||
int box_y = 110;
|
||||
int box_w = 400;
|
||||
int box_h = 350;
|
||||
int box_h = 320;
|
||||
DrawRectangle(box_x, box_y, box_w, box_h, (Color){20, 20, 20, 240});
|
||||
DrawRectangleLines(box_x, box_y, box_w, box_h, (Color){100, 100, 100, 255});
|
||||
|
||||
|
|
@ -546,80 +551,72 @@ void render_end_screen(int is_victory, int kills, int items, int damage_dealt, i
|
|||
Color value_color = WHITE;
|
||||
|
||||
// Column 1
|
||||
DrawTextEx(*font, "Kills:", (Vector2){col1_x, row_y}, 18, NORM_CHAR_SPACE, label_color);
|
||||
DrawText("Kills:", col1_x, row_y, 18, label_color);
|
||||
snprintf(line, sizeof(line), "%d", kills);
|
||||
DrawTextEx(*font, line, (Vector2){col1_x + 80, row_y}, 18, NORM_CHAR_SPACE, value_color);
|
||||
DrawText(line, col1_x + 80, row_y, 18, value_color);
|
||||
row_y += line_height;
|
||||
|
||||
DrawTextEx(*font, "Items:", (Vector2){col1_x, row_y}, 18, NORM_CHAR_SPACE, label_color);
|
||||
DrawText("Items:", col1_x, row_y, 18, label_color);
|
||||
snprintf(line, sizeof(line), "%d", items);
|
||||
DrawTextEx(*font, line, (Vector2){col1_x + 80, row_y}, 18, NORM_CHAR_SPACE, value_color);
|
||||
DrawText(line, col1_x + 80, row_y, 18, value_color);
|
||||
row_y += line_height;
|
||||
|
||||
DrawTextEx(*font, "Damage Dealt:", (Vector2){col1_x, row_y}, 18, NORM_CHAR_SPACE, label_color);
|
||||
DrawText("Damage Dealt:", col1_x, row_y, 18, label_color);
|
||||
snprintf(line, sizeof(line), "%d", damage_dealt);
|
||||
DrawTextEx(*font, line, (Vector2){col1_x + 140, row_y}, 18, NORM_CHAR_SPACE, value_color);
|
||||
DrawText(line, col1_x + 140, row_y, 18, value_color);
|
||||
row_y += line_height;
|
||||
|
||||
DrawTextEx(*font, "Damage Taken:", (Vector2){col1_x, row_y}, 18, NORM_CHAR_SPACE, label_color);
|
||||
DrawText("Damage Taken:", col1_x, row_y, 18, label_color);
|
||||
snprintf(line, sizeof(line), "%d", damage_taken);
|
||||
DrawTextEx(*font, line, (Vector2){col1_x + 140, row_y}, 18, NORM_CHAR_SPACE, value_color);
|
||||
DrawText(line, col1_x + 140, row_y, 18, value_color);
|
||||
row_y += line_height;
|
||||
|
||||
DrawTextEx(*font, "Crits:", (Vector2){col1_x, row_y}, 18, NORM_CHAR_SPACE, label_color);
|
||||
DrawText("Crits:", col1_x, row_y, 18, label_color);
|
||||
snprintf(line, sizeof(line), "%d", crits);
|
||||
DrawTextEx(*font, line, (Vector2){col1_x + 80, row_y}, 18, NORM_CHAR_SPACE, value_color);
|
||||
DrawText(line, col1_x + 80, row_y, 18, value_color);
|
||||
row_y += line_height;
|
||||
|
||||
DrawTextEx(*font, "Times Hit:", (Vector2){col1_x, row_y}, 18, NORM_CHAR_SPACE, label_color);
|
||||
DrawText("Times Hit:", col1_x, row_y, 18, label_color);
|
||||
snprintf(line, sizeof(line), "%d", times_hit);
|
||||
DrawTextEx(*font, line, (Vector2){col1_x + 80, row_y}, 18, NORM_CHAR_SPACE, value_color);
|
||||
DrawText(line, col1_x + 80, row_y, 18, value_color);
|
||||
row_y += line_height;
|
||||
|
||||
// Column 2
|
||||
int col2_row_y = box_y + 20;
|
||||
DrawTextEx(*font, "Potions:", (Vector2){col2_x, col2_row_y}, 18, NORM_CHAR_SPACE, label_color);
|
||||
DrawText("Potions:", col2_x, col2_row_y, 18, label_color);
|
||||
snprintf(line, sizeof(line), "%d", potions);
|
||||
DrawTextEx(*font, line, (Vector2){col2_x + 80, col2_row_y}, 18, NORM_CHAR_SPACE, value_color);
|
||||
DrawText(line, col2_x + 80, col2_row_y, 18, value_color);
|
||||
col2_row_y += line_height;
|
||||
|
||||
DrawTextEx(*font, "Floors:", (Vector2){col2_x, col2_row_y}, 18, NORM_CHAR_SPACE, label_color);
|
||||
DrawText("Floors:", col2_x, col2_row_y, 18, label_color);
|
||||
snprintf(line, sizeof(line), "%d", floors);
|
||||
DrawTextEx(*font, line, (Vector2){col2_x + 80, col2_row_y}, 18, NORM_CHAR_SPACE, value_color);
|
||||
DrawText(line, col2_x + 80, col2_row_y, 18, value_color);
|
||||
col2_row_y += line_height;
|
||||
|
||||
DrawTextEx(*font, "Turns:", (Vector2){col2_x, col2_row_y}, 18, NORM_CHAR_SPACE, label_color);
|
||||
DrawText("Turns:", col2_x, col2_row_y, 18, label_color);
|
||||
snprintf(line, sizeof(line), "%d", turns);
|
||||
DrawTextEx(*font, line, (Vector2){col2_x + 80, col2_row_y}, 18, NORM_CHAR_SPACE, value_color);
|
||||
DrawText(line, col2_x + 80, col2_row_y, 18, value_color);
|
||||
col2_row_y += line_height;
|
||||
|
||||
// Score: placed below the last row of the longer column (6 items, row_y is already there)
|
||||
row_y += 10;
|
||||
DrawTextEx(*font, "SCORE:", (Vector2){col1_x, row_y}, 22, NORM_CHAR_SPACE, GOLD);
|
||||
DrawText("SCORE:", col1_x, row_y, 22, GOLD);
|
||||
snprintf(line, sizeof(line), "%d", score);
|
||||
DrawTextEx(*font, line, (Vector2){col1_x + 90, col2_row_y}, 22, NORM_CHAR_SPACE, GOLD);
|
||||
row_y += 35;
|
||||
DrawText(line, col1_x + 90, row_y, 22, GOLD);
|
||||
|
||||
// Seed display
|
||||
DrawTextEx(*font, "SEED:", (Vector2){col1_x, row_y}, 18, SMALL_CHAR_SPACE, label_color);
|
||||
snprintf(line, sizeof(line), "%u", seed);
|
||||
DrawTextEx(*font, line, (Vector2){col1_x + 60, row_y}, 18, SMALL_CHAR_SPACE, END_SEED);
|
||||
|
||||
// Instructions
|
||||
if (is_victory) {
|
||||
const char *subtitle = "Press R to play again or Q to quit";
|
||||
int sub_width = MeasureText(subtitle, 20);
|
||||
DrawTextEx(*font, subtitle, (Vector2){(SCREEN_WIDTH - sub_width) / 2.0f, SCREEN_HEIGHT - 50}, 20, NORM_CHAR_SPACE,
|
||||
LIGHTGRAY);
|
||||
DrawText(subtitle, (SCREEN_WIDTH - sub_width) / 2, SCREEN_HEIGHT - 50, 20, LIGHTGRAY);
|
||||
} else {
|
||||
const char *subtitle = "Press R to restart or Q to quit";
|
||||
int sub_width = MeasureText(subtitle, 20);
|
||||
DrawTextEx(*font, subtitle, (Vector2){(SCREEN_WIDTH - sub_width) / 2.0f, SCREEN_HEIGHT - 50}, 20, NORM_CHAR_SPACE,
|
||||
LIGHTGRAY);
|
||||
DrawText(subtitle, (SCREEN_WIDTH - sub_width) / 2, SCREEN_HEIGHT - 50, 20, LIGHTGRAY);
|
||||
}
|
||||
}
|
||||
|
||||
void render_message(const char *message, Font *font) {
|
||||
// Floating message popup
|
||||
void render_message(const char *message) {
|
||||
if (message == NULL)
|
||||
return;
|
||||
|
||||
|
|
@ -654,8 +651,8 @@ void render_message(const char *message, Font *font) {
|
|||
longest_line_width = current_line_width;
|
||||
|
||||
// Measure full message
|
||||
Vector2 total_msg_width = MeasureTextEx(*font, message, font_size, NORM_CHAR_SPACE);
|
||||
int box_width = total_msg_width.x + (padding_x * 2);
|
||||
int total_msg_width = MeasureText(message, font_size);
|
||||
int box_width = total_msg_width + (padding_x * 2);
|
||||
|
||||
// If message is too long, use wrapped width
|
||||
if (box_width > max_box_width) {
|
||||
|
|
@ -679,7 +676,7 @@ void render_message(const char *message, Font *font) {
|
|||
DrawRectangleLines((int)msg_bg.x, (int)msg_bg.y, (int)msg_bg.width, (int)msg_bg.height, (Color){180, 180, 180, 255});
|
||||
|
||||
// Draw text centered
|
||||
int text_x = (SCREEN_WIDTH - total_msg_width.x) / 2;
|
||||
int text_x = (SCREEN_WIDTH - total_msg_width) / 2;
|
||||
int text_y = (SCREEN_HEIGHT - font_size) / 2;
|
||||
|
||||
// For wrapped text, draw at box center with padding
|
||||
|
|
@ -688,20 +685,5 @@ void render_message(const char *message, Font *font) {
|
|||
text_y = (int)box_y + padding_y;
|
||||
}
|
||||
|
||||
DrawTextEx(*font, message, (Vector2){text_x, text_y}, font_size, NORM_CHAR_SPACE, WHITE);
|
||||
}
|
||||
|
||||
void render_seed_display(unsigned int seed) {
|
||||
char seed_text[64];
|
||||
snprintf(seed_text, sizeof(seed_text), "Seed: %u", seed);
|
||||
|
||||
const int font_size = 14;
|
||||
int text_width = MeasureText(seed_text, font_size);
|
||||
|
||||
// Position at top right with padding
|
||||
int x = SCREEN_WIDTH - text_width - 10;
|
||||
int y = 5;
|
||||
|
||||
// Draw with non-obstructive dim text color
|
||||
DrawText(seed_text, x, y, font_size, TEXT_DIM);
|
||||
DrawText(message, text_x, text_y, font_size, WHITE);
|
||||
}
|
||||
|
|
|
|||
21
src/render.h
21
src/render.h
|
|
@ -1,8 +1,7 @@
|
|||
|
||||
#ifndef RENDER_H
|
||||
#define RENDER_H
|
||||
|
||||
#include "game_state.h"
|
||||
#include "common.h"
|
||||
|
||||
// HUD colors
|
||||
#define HUD_BG (Color){25, 20, 15, 255}
|
||||
|
|
@ -69,7 +68,6 @@
|
|||
#define END_OVERLAY (Color){0, 0, 0, 210}
|
||||
#define END_BOX_BG (Color){20, 20, 20, 240}
|
||||
#define END_BOX_BORDER (Color){100, 100, 100, 255}
|
||||
#define END_SEED (Color){150, 200, 255, 255}
|
||||
|
||||
// Portrait placeholder
|
||||
// FIXME: remove when player sprites are available
|
||||
|
|
@ -82,31 +80,28 @@ void render_map(const Map *map);
|
|||
void render_player(const Player *p);
|
||||
|
||||
// Render all enemies
|
||||
void render_enemies(const Enemy *enemies, int count, const unsigned char visible[MAP_HEIGHT][MAP_WIDTH]);
|
||||
void render_enemies(const Enemy *enemies, int count);
|
||||
|
||||
// Render all items
|
||||
void render_items(const Item *items, int count, const unsigned char visible[MAP_HEIGHT][MAP_WIDTH]);
|
||||
void render_items(const Item *items, int count);
|
||||
|
||||
// Render UI overlay
|
||||
void render_ui(const Player *p, Font *font);
|
||||
void render_ui(const Player *p);
|
||||
|
||||
// Render action log (bottom left corner)
|
||||
void render_action_log(const char log[5][128], int count, int head, Font *font);
|
||||
void render_action_log(const char log[5][128], int count, int head);
|
||||
|
||||
// Render inventory selection overlay
|
||||
void render_inventory_overlay(const Player *p, int selected, Font *font);
|
||||
void render_inventory_overlay(const Player *p, int selected);
|
||||
|
||||
// Render floating damage text
|
||||
void render_floating_texts(FloatingText *texts, int count, int shake_x, int shake_y);
|
||||
|
||||
// Render end screen (victory or death) with stats breakdown
|
||||
void render_end_screen(int is_victory, int kills, int items, int damage_dealt, int damage_taken, int crits,
|
||||
int times_hit, int potions, int floors, int turns, int score, unsigned int seed, Font *font);
|
||||
int times_hit, int potions, int floors, int turns, int score);
|
||||
|
||||
// Render a message popup
|
||||
void render_message(const char *message, Font *font);
|
||||
|
||||
// Render seed display at top right of screen
|
||||
void render_seed_display(unsigned int seed);
|
||||
void render_message(const char *message);
|
||||
|
||||
#endif // RENDER_H
|
||||
|
|
|
|||
|
|
@ -8,21 +8,6 @@
|
|||
#define SCREEN_WIDTH (MAP_WIDTH * TILE_SIZE)
|
||||
#define SCREEN_HEIGHT (MAP_HEIGHT * TILE_SIZE)
|
||||
|
||||
// Font constants
|
||||
#define NORM_CHAR_SPACE 4.0f
|
||||
#define MED_CHAR_SPACE 2.5f
|
||||
#define SMALL_CHAR_SPACE 1.6f
|
||||
#define NAR_CHAR_SPACE 1.0f
|
||||
#define CRAMPED_CHAR_SPACE 0.5f
|
||||
|
||||
#define TINY_FONT 8
|
||||
#define SMALL_FONT 10
|
||||
#define NORM_FONT 12
|
||||
#define MEDIUM_FONT 14
|
||||
#define LARGE_FONT 18
|
||||
#define BIG_FONT 22
|
||||
#define HUGE_FONT 30
|
||||
|
||||
// Game Limits
|
||||
#define MAX_ENEMIES 64
|
||||
#define MAX_ITEMS 128
|
||||
|
|
@ -78,9 +63,4 @@
|
|||
// 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
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue