rogged/src/main.c

#include "audio.h"
#include "combat.h"
#include "common.h"
#include "enemy.h"
#include "items.h"
#include "map.h"
#include "player.h"
#include "raylib.h"
#include "render.h"
#include "rng.h"
#include "settings.h"
#include <stddef.h>
#include <stdio.h>
#include <string.h>

// Add message to action log
static void add_log(GameState *gs, const char *msg) {
  strncpy(gs->action_log[gs->log_head], msg, 127);
  gs->action_log[gs->log_head][127] = '\0';
  gs->log_head = (gs->log_head + 1) % 5;
  if (gs->log_count < 5) {
    gs->log_count++;
  }
}

// spawn floating damage text
static void spawn_floating_text(GameState *gs, int x, int y, int value, int is_critical) {
  // Reuse an expired slot if all slots are taken
  int slot = -1;
  if (gs->floating_count < 8) {
    slot = gs->floating_count;
    gs->floating_count++;
  } else {
    for (int i = 0; i < 8; i++) {
      if (gs->floating_texts[i].lifetime <= 0) {
        slot = i;
        break;
      }
    }
  }
  if (slot < 0)
    return;
  gs->floating_texts[slot].x = x;
  gs->floating_texts[slot].y = y;
  gs->floating_texts[slot].value = value;
  gs->floating_texts[slot].lifetime = 60;
  gs->floating_texts[slot].is_critical = is_critical;
}

// update floating texts and screen shake
static void update_effects(GameState *gs) {
  // update floating texts
  for (int i = 0; i < 8; i++) {
    if (gs->floating_texts[i].lifetime > 0) {
      gs->floating_texts[i].lifetime--;
    }
  }

  // update screen shake
  if (gs->screen_shake > 0) {
    gs->screen_shake--;
    gs->shake_x = rng_int(-4, 4);
    gs->shake_y = rng_int(-4, 4);
  } else {
    gs->shake_x = 0;
    gs->shake_y = 0;
  }
}

// Initialize a new floor
static void init_floor(GameState *gs, int floor_num) {
  // Generate dungeon
  dungeon_generate(&gs->dungeon, &gs->map, floor_num);

  // Seed rng for this floor's content
  rng_seed(floor_num * 54321);

  // Find spawn position
  int start_x, start_y;
  get_random_floor_tile(&gs->map, &start_x, &start_y, 100);

  // Initialize player position if first floor
  if (floor_num == 1) {
    player_init(&gs->player, start_x, start_y);
  } else {
    // Move player to new floor position
    gs->player.x = start_x;
    gs->player.y = start_y;
  }
  gs->player.floor = floor_num;

  // Spawn enemies
  enemy_spawn(gs->enemies, &gs->enemy_count, &gs->map, &gs->player, floor_num);

  // Spawn items
  item_spawn(gs->items, &gs->item_count, &gs->map, floor_num);

  // Reset turn counter
  gs->turn_count = 0;
}

// Tick all status effects at the start of a turn
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);
    gs->screen_shake = 4;
  }

  // Check if player died from effects
  if (gs->player.hp <= 0) {
    gs->player.hp = 0;
    gs->game_over = 1;
    return;
  }

  // Enemy effects
  for (int i = 0; i < gs->enemy_count; i++) {
    Enemy *e = &gs->enemies[i];
    if (!e->alive)
      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);
    }
    if (!e->alive) {
      add_log(gs, "Enemy died from effects!");
    }
  }
}

// Handle player input - returns: 0=continue, 1=acted, -1=quit
static int handle_input(GameState *gs) {
  int dx = 0, dy = 0;

  // Check for quit first (always works)
  if (IsKeyPressed(KEY_Q)) {
    return -1;
  }

  // Check for restart (works during game over)
  if (IsKeyPressed(KEY_R) && gs->game_over) {
    memset(gs, 0, sizeof(GameState));
    init_floor(gs, 1);
    return 0;
  }

  // If player is stunned, wait for any key then consume the turn
  if (combat_has_effect(gs->player.effects, gs->player.effect_count, EFFECT_STUN)) {
    if (!(IsKeyDown(KEY_W) || IsKeyDown(KEY_UP) || IsKeyDown(KEY_S) || IsKeyDown(KEY_DOWN) || IsKeyDown(KEY_A) ||
          IsKeyDown(KEY_LEFT) || IsKeyDown(KEY_D) || IsKeyDown(KEY_RIGHT)))
      return 0;
    gs->turn_count++;
    tick_all_effects(gs);
    if (gs->game_over)
      return 1;
    enemy_update_all(gs->enemies, gs->enemy_count, &gs->player, &gs->map);
    if (gs->player.hp <= 0) {
      gs->game_over = 1;
    }
    gs->last_message = "You are stunned!";
    gs->message_timer = 60;
    add_log(gs, "Stunned! Lost a turn.");
    return 1;
  }

  if (gs->show_inventory) {
    if (IsKeyPressed(KEY_I) || IsKeyPressed(KEY_ESCAPE)) {
      gs->show_inventory = 0;
      return 0;
    }

    if (IsKeyPressed(KEY_DOWN) || IsKeyPressed(KEY_S)) {
      gs->inv_selected++;
      if (gs->inv_selected >= gs->player.inventory_count) {
        gs->inv_selected = 0;
      }
      return 0;
    }
    if (IsKeyPressed(KEY_UP) || IsKeyPressed(KEY_W)) {
      if (gs->inv_selected == 0) {
        gs->inv_selected = (gs->player.inventory_count > 0) ? gs->player.inventory_count - 1 : 0;
      } else {
        gs->inv_selected--;
      }
      return 0;
    }

    if (IsKeyPressed(KEY_ONE))
      gs->inv_selected = 0;
    if (IsKeyPressed(KEY_TWO))
      gs->inv_selected = 1;
    if (IsKeyPressed(KEY_THREE))
      gs->inv_selected = 2;
    if (IsKeyPressed(KEY_FOUR))
      gs->inv_selected = 3;
    if (IsKeyPressed(KEY_FIVE))
      gs->inv_selected = 4;
    if (IsKeyPressed(KEY_SIX))
      gs->inv_selected = 5;
    if (IsKeyPressed(KEY_SEVEN))
      gs->inv_selected = 6;
    if (IsKeyPressed(KEY_EIGHT))
      gs->inv_selected = 7;
    if (IsKeyPressed(KEY_NINE))
      gs->inv_selected = 8;
    if (IsKeyPressed(KEY_ZERO))
      gs->inv_selected = 9;

    // E to equip selected item
    if (IsKeyPressed(KEY_E)) {
      if (player_equip_item(&gs->player, gs->inv_selected)) {
        gs->last_message = "Item equipped!";
        gs->message_timer = 60;
        add_log(gs, "Equipped item");
        if (gs->inv_selected >= gs->player.inventory_count && gs->inv_selected > 0) {
          gs->inv_selected--;
        }
        return 1;
      } else {
        gs->last_message = "Cannot equip that!";
        gs->message_timer = 60;
      }
    }

    // U or Enter to use selected item
    if (IsKeyPressed(KEY_U) || IsKeyPressed(KEY_ENTER)) {
      if (gs->player.inventory_count > 0) {
        Item *item = player_get_inventory_item(&gs->player, gs->inv_selected);
        if (item != NULL) {
          if (item->type == ITEM_POTION) {
            player_use_item(&gs->player, item);
            player_remove_inventory_item(&gs->player, gs->inv_selected);
            gs->last_message = "Used potion!";
            gs->message_timer = 60;
            add_log(gs, "Used potion");
            gs->show_inventory = 0;
            return 1;
          } else {
            gs->last_message = "Equip weapons/armor with E!";
            gs->message_timer = 60;
          }
        }
      }
    }

    // D to drop selected item
    if (IsKeyPressed(KEY_D)) {
      if (gs->player.inventory_count > 0) {
        Item *item = player_get_inventory_item(&gs->player, gs->inv_selected);
        if (item != NULL) {
          char drop_msg[64];
          snprintf(drop_msg, sizeof(drop_msg), "Dropped %s", item_get_name(item));
          if (player_drop_item(&gs->player, gs->inv_selected, gs->items, gs->item_count)) {
            add_log(gs, drop_msg);
            gs->last_message = "Item dropped!";
            gs->message_timer = 60;
            if (gs->inv_selected >= gs->player.inventory_count && gs->inv_selected > 0) {
              gs->inv_selected--;
            }
            return 1;
          } else {
            gs->last_message = "Cannot drop!";
            gs->message_timer = 60;
          }
        }
      }
    }

    return 0;
  }

  // Handle descend confirmation
  if (gs->awaiting_descend) {
    if (IsKeyPressed(KEY_Y)) {
      // Descend
      if (gs->player.floor < NUM_FLOORS) {
        audio_play_stairs();
        init_floor(gs, gs->player.floor + 1);
        gs->last_message = "Descended to next floor!";
        gs->message_timer = 60;
        add_log(gs, "Descended stairs");
        gs->awaiting_descend = 0;
        return 1;
      } else {
        gs->game_won = 1;
        gs->game_over = 1;
        gs->awaiting_descend = 0;
        return 1;
      }
    }
    if (IsKeyPressed(KEY_N)) {
      gs->awaiting_descend = 0;
      gs->last_message = "Stayed on floor.";
      gs->message_timer = 60;
      return 1;
    }
    return 0;
  }

  // Check for inventory toggle (I key)
  if (IsKeyPressed(KEY_I) && !gs->game_over) {
    gs->show_inventory = 1;
    gs->inv_selected = 0;
    return 0;  // don't consume turn
  }

  // Check for manual item pickup (G key)
  if (IsKeyPressed(KEY_G) && !gs->game_over) {
    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)) {
        char pickup_msg[64];
        snprintf(pickup_msg, sizeof(pickup_msg), "Picked up %s", item_get_name(item));
        add_log(gs, pickup_msg);
        gs->last_message = "Picked up item!";
        gs->message_timer = 60;
        audio_play_item_pickup();
        return 1;
      } else {
        gs->last_message = "Inventory full!";
        gs->message_timer = 60;
        return 1;
      }
    }
  }

  // Check for item usage (U key - use first potion)
  if (IsKeyPressed(KEY_U) && !gs->game_over) {
    if (gs->player.inventory_count > 0) {
      if (player_use_first_item(&gs->player)) {
        gs->last_message = "Used potion!";
        gs->message_timer = 60;
        audio_play_item_pickup();
        return 1;  // consume a turn
      }
    }
  }

  // Movement, use iskeydown for held key repeat, with delay
  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) {
    // Reset combat message
    combat_reset_event();

    // Player action
    int action = player_move(&gs->player, dx, dy, &gs->map, gs->enemies, gs->enemy_count);

    if (action) {
      // Increment turn counter
      gs->turn_count++;

      // Tick status effects at the start of this turn
      tick_all_effects(gs);
      if (gs->game_over)
        return 1;

      // Check if stepped on 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;
        return 1;
      }

      // combat feedback - player attacked enemy
      if (combat_get_last_damage() > 0 && !combat_was_player_damage()) {
        // find the enemy we attacked
        for (int i = 0; i < gs->enemy_count; i++) {
          if (!gs->enemies[i].alive && combat_get_last_damage() > 0) {
            spawn_floating_text(gs, gs->enemies[i].x * TILE_SIZE + 8, gs->enemies[i].y * TILE_SIZE,
                                combat_get_last_damage(), combat_was_critical());
            break;
          }
        }
      }

      // Enemy turns - now uses speed/cooldown system (no more % 2 hack)
      enemy_update_all(gs->enemies, gs->enemy_count, &gs->player, &gs->map);

      // Check if player took damage
      if (combat_was_player_damage() && combat_get_last_damage() > 0) {
        audio_play_player_damage();
        gs->screen_shake = 8;
        spawn_floating_text(gs, gs->player.x * TILE_SIZE + 8, gs->player.y * TILE_SIZE, combat_get_last_damage(),
                            combat_was_critical());
      }

      // Set message
      gs->last_message = combat_get_last_message();
      gs->message_timer = 60;

      // Check game over
      if (gs->player.hp <= 0) {
        gs->game_over = 1;
      }
    }
  }

  return 0;
}

// Main game loop
static void game_loop(void) {
  GameState gs;
  memset(&gs, 0, sizeof(GameState));

  // Initialize first floor
  rng_seed(12345);
  init_floor(&gs, 1);

  // Disable esc to exit
  SetExitKey(0);

  while (!WindowShouldClose()) {
    // Handle input
    if (!gs.game_over) {
      // Tick status effects at the start of each frame where input is checked
      // (effects tick once per player action via the acted flag below)
      int quit = handle_input(&gs);
      if (quit == -1)
        break;
    } else {
      // Even during game over, check for q/r
      if (IsKeyPressed(KEY_Q))
        break;
      if (IsKeyPressed(KEY_R)) {
        memset(&gs, 0, sizeof(GameState));
        gs.game_over = 0;
        gs.game_won = 0;
        init_floor(&gs, 1);
      }
    }

    // Update message timer
    if (gs.message_timer > 0)
      gs.message_timer--;

    // Update effects
    update_effects(&gs);

    // Render
    BeginDrawing();
    ClearBackground(BLACK);

    // Draw game elements (with screen shake offset)
    if (gs.screen_shake > 0) {
      // Apply shake offset to drawing
    }

    render_map(&gs.map);
    render_items(gs.items, gs.item_count);
    render_enemies(gs.enemies, gs.enemy_count);
    render_player(&gs.player);
    render_floating_texts(gs.floating_texts, gs.floating_count, gs.shake_x, gs.shake_y);
    render_ui(&gs.player);

    // Draw action log
    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);
    }

    // Draw message if any
    if (gs.last_message != NULL && gs.message_timer > 0) {
      render_message(gs.last_message);
    }

    // Draw game over screen
    if (gs.game_over) {
      render_game_over();
      if (gs.game_won) {
        // Draw win message
        const char *win_msg = "YOU WIN! ESCAPED THE DUNGEON!";
        int msg_w = MeasureText(win_msg, 30);
        DrawText(win_msg, (SCREEN_WIDTH - msg_w) / 2, SCREEN_HEIGHT / 2 - 80, 30, GOLD);
      }
    }

    EndDrawing();

    // small delay for key repeat control
    WaitTime(0.08);
  }
}

int main(void) {
  // Initialize audio
  audio_init();

  // Initialize window
  InitWindow(SCREEN_WIDTH, SCREEN_HEIGHT + 60, "Roguelike");
  SetTargetFPS(60);

  // Run game
  game_loop();

  // Cleanup
  CloseWindow();
  audio_close();

  return 0;
}