game_core.h

Go to the documentation of this file.

// jgabaut @ github.com/jgabaut
// SPDX-License-Identifier: GPL-3.0-only
/*
    Copyright (C) 2022-2024 jgabaut
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, version 3 of the License.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
 
#ifndef GAME_CORE_H
#define GAME_CORE_H
 
#ifndef HELAPORDO_OS
#define HELAPORDO_OS "unknown"
#endif
 
#ifndef HELAPORDO_MACHINE
#define HELAPORDO_MACHINE "unknown"
#endif
 
#include "../../ringabuf/src/ringabuf.h"
 
#ifdef HELAPORDO_CURSES_BUILD
#ifdef _WIN32
#include <ncursesw/panel.h>
#define S4C_WIN_BG 0
#define S4C_WIN_RED 1
#define S4C_WIN_GREEN 2
#define S4C_WIN_BLUE 3
#define S4C_WIN_CYAN 4
#define S4C_WIN_WHITE 5
#define S4C_WIN_YELLOW 6
#define S4C_WIN_BLACK_ON_WHITE 7
#define S4C_WIN_PURPLE 8
#define S4C_WIN_WHITE_ON_RED 9
#define S4C_WIN_WHITE_ON_PURPLE 10
#else
#include <panel.h>
#endif // _WIN32
 
typedef struct GameScreen {
    WINDOW* win; 
    int colors; 
    int color_pairs; 
    int cols; 
    int rows; 
    int escape_delay; 
    int tabsize; 
} GameScreen;
 
#else
#ifndef HELAPORDO_RAYLIB_BUILD
#error "HELAPORDO_CURSES_BUILD and HELAPORDO_RAYLIB_BUILD are both undefined."
#else
typedef enum GameScreen { LOGO = 0, TITLE, SAVES_VIEW, NAMEPICK_VIEW, CLASSPICK_VIEW, FLOOR_VIEW, ROOM_VIEW, ENDING, DOOR_ANIM } GameScreen;
// Add more includes for rl-build here
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN // We don't want no playsound
#define NOGDI // We don't want Rectangle from Windows
#define NOUSER // We don't want no user routines
#endif // _WIN32
#endif // HELAPORDO_RAYLIB_BUILD
#endif // HELAPORDO_CURSES_BUILD
 
#include "../../koliseo/src/koliseo.h"
 
#ifdef near
#undef near
#endif
#ifdef far
#undef far
#endif
 
#include "../palette.h" 
extern const char* helapordo_title_string; 
extern const char* helapordo_build_string;
 
typedef enum HLPD_KeyClass {
    HLPD_KEY_UP = 0,
    HLPD_KEY_RIGHT,
    HLPD_KEY_DOWN,
    HLPD_KEY_LEFT,
    HLPD_KEY_DWNPAGE,
    HLPD_KEY_UPPAGE,
    HLPD_KEY_CONFIRM,
    HLPD_KEY_QUIT,
    HLPD_KEY_MENU,
} HLPD_KeyClass;
 
#define HLPD_KEYCLASS_MAX 8
 
extern char *hlpd_keyclass_strings[HLPD_KEYCLASS_MAX + 1];
 
typedef struct HLPD_Key {
    int val;
    HLPD_KeyClass class;
} HLPD_Key;
 
extern HLPD_Key hlpd_default_keybinds[HLPD_KEYCLASS_MAX+1];
 
typedef enum HLPD_DirectionalKeys_Schema {
    HLPD_ARROW_KEYS=0,
    HLPD_VIM_KEYS,
    HLPD_WASD_KEYS,
} HLPD_DirectionalKeys_Schema;
 
#define HLPD_DIRECTIONALKEYS_SCHEMAS_MAX 2
 
extern char *hlpd_directionalkeyschemas_strings[HLPD_DIRECTIONALKEYS_SCHEMAS_MAX + 1];
 
typedef struct HLPD_DirectionalKeys {
    HLPD_Key up;
    HLPD_Key right;
    HLPD_Key down;
    HLPD_Key left;
} HLPD_DirectionalKeys;
 
extern HLPD_DirectionalKeys hlpd_default_directional_keys[HLPD_DIRECTIONALKEYS_SCHEMAS_MAX+1];
 
typedef struct GameOptions {
    bool use_default_background; //<** Turn on usage of default terminal background */
    bool do_autosave; //<* Turns on autosave */
    HLPD_DirectionalKeys_Schema directional_keys_schema; //* Defines the current schema for cardinal directions movement */
} GameOptions;
 
extern const GameOptions default_GameOptions;
 
typedef enum HLP_Region_Type {
    HR_Path = KLS_REGIONTYPE_MAX + 100, //Start counting from last index of Koliseo's own Region_Type values
    HR_Wincon,
    HR_Room,
    HR_Floor,
    HR_turnOP_args,
    HR_Fighter,
    HR_Enemy,
    HR_Boss,
    HR_FoeParty,
    HR_Equip,
    HR_Equipslot,
    HR_Specialslot,
    HR_Skillslot,
    HR_Turncounter,
    HR_Perk,
    HR_Consumable,
    HR_Artifact,
    HR_Chest,
    HR_Treasure,
    HR_Shop,
    HR_Roadfork,
    HR_Turncounter_desc,
    HR_Room_desc,
    HR_countStats,
    HR_Saveslot,
    HR_Gamestate,
    HR_Gamescreen,
    HR_GameOptions,
    HR_BSP_Room,
    HR_Notification,
    HR_RingaBuf,
    HR_loadInfo,
} HLP_Region_Type;
 
#define HLP_MAX_INDEX (HR_loadInfo-100+KLS_REGIONTYPE_MAX)
 
extern char *hlp_regiontype_strings[HLP_MAX_INDEX + 1];
 
extern Koliseo *default_kls;
extern Koliseo *temporary_kls;
extern Koliseo *support_kls;
 
extern int G_PRELOAD_ANIMATIONS_ON;
extern int G_DEBUG_ON;
extern int G_LOG_ON;
extern int G_EXPERIMENTAL_ON;
extern int G_FASTQUIT_ON;
extern int G_GODMODE_ON;
extern int G_DEBUG_ROOMTYPE;
extern int G_DEBUG_ROOMTYPE_ON;
extern char *G_DEBUG_ROOMTYPE_ARG;
extern int G_DEBUG_ENEMYTYPE;
extern int G_DEBUG_ENEMYTYPE_ON;
extern char *G_DEBUG_ENEMYTYPE_ARG;
extern int GS_AUTOSAVE_ON;
extern int G_DOTUTORIAL_ON;
 
extern int G_USE_CURRENTDIR;
 
extern int G_USE_DEFAULT_BACKGROUND;
 
extern int G_USE_VIM_DIRECTIONAL_KEYS;
 
extern int G_USE_WASD_DIRECTIONAL_KEYS;
 
 
extern int64_t G_RNG_ADVANCEMENTS;
 
extern int G_SEEDED_RUN_ON;
extern char *G_SEEDED_RUN_ARG;
 
#define HELAPORDO_MAJOR_VERSION 1
 
#define HELAPORDO_MINOR_VERSION 4
 
#define HELAPORDO_PATCH_VERSION 12
 
#define VERSION "1.4.12"
 
#define HELAPORDO_BINSAVEFILE_VERSION "0.0.6"
 
static const int HELAPORDO_API_VERSION_INT =
    (HELAPORDO_MAJOR_VERSION * 1000000 + HELAPORDO_MINOR_VERSION * 10000 + HELAPORDO_PATCH_VERSION * 100);
#define EXPECTED_NCURSES_VERSION_MAJOR 6 
#define EXPECTED_NCURSES_VERSION_MINOR 4 
#define EXPECTED_NCURSES_VERSION_PATCH 20230520 
#define EXPECTED_RAYLIB_VERSION_MAJOR 4 
#define EXPECTED_RAYLIB_VERSION_MINOR 5 
#define EXPECTED_RAYLIB_VERSION_PATCH 0 
typedef struct {
    char name[50];     
    char save_path[255];     
    int index; 
} Saveslot;
 
#define MAX_SAVESLOTS 3
 
extern Saveslot default_saveslots[MAX_SAVESLOTS + 1];
 
#define MAXPLAYERLUCK 30
 
#define MAXLENGTH 100
 
#define MAXLUCK 50
 
typedef enum {
    Rogue = 0,
} Gamemode;
 
#define GAMEMODE_MAX 0
 
extern char *gamemodenamestrings[GAMEMODE_MAX + 1];
 
#define LORES_MAX 2
 
extern Gamemode GAMEMODE;
 
typedef enum {
    Potion = 0,
    Rock = 1,
    Bread = 2,
    Coffee = 3,
    Powergem = 4,
    Magicbean = 5
} consumableClass;
 
#define CONSUMABLESMAX 5
 
typedef struct {
    consumableClass class;     
    char name[25];     
    char desc[50];     
    int qty;     
    char sprite[8][20];     
} Consumable;
 
extern char *consumablestrings[CONSUMABLESMAX + 1];
 
extern Consumable consumablesBase[CONSUMABLESMAX + 1];
 
typedef enum {
    THKSKULL = 0,
    TWINKIE = 1,
    WRISTBAND = 2,
    BOARTAIL = 3,
    CHAOSORB = 4,
    POWERSYPHON = 5,
    GIANTFOSSILE = 6
} artifactClass;
 
#define ARTIFACTSMAX 6
 
typedef struct Artifact {
    artifactClass class;     
    char name[25];     
    char desc[50];     
    int qty;     
    int active;     
    int innerValue; 
    char sprite[8][20];     
} Artifact;
 
extern char *artifactstrings[ARTIFACTSMAX + 1];
 
extern Artifact artifactsBase[ARTIFACTSMAX + 1];
 
#define ENEMY_ARTIFACTDROP_CHANCE 1001 
typedef enum {
    Normal,
    Poison,
    Frozen,
    Burned,
    Weak,
    Strong
} fighterStatus;
 
#define STATUSMAX 5
 
typedef enum {
    Knight = 0,
    Archer = 1,
    Mage = 2,
    Assassin = 3
} fighterClass;
 
#define CLASSESMAX 3
 
extern char *classesstrings[CLASSESMAX + 1];
 
typedef enum {
    ATK,
    DEF,
    VEL,
    ENR
} Stat;
 
#define STATMAX 3
 
typedef struct BaseStats {
    fighterClass class;     
    int hp; 
    int atk;     
    int def;     
    int vel;     
    int level;     
    int totalxp;     
    int totallevelxp;     
    int currentlevelxp;     
    int totalhp;     
    int totalenergy;     
    int totalstamina;     
} BaseStats;
 
extern BaseStats basestats[CLASSESMAX + 1];
 
typedef enum {
    Mummy = 0,
    Ghost = 1,
    Zombie = 2,
    Goblin = 3,
    Imp = 4,
    Troll = 5,
    Boar = 6,
    Werewolf = 7
} enemyClass;
 
#define ENEMYCLASSESMAX 7
 
extern char *classenemystrings[ENEMYCLASSESMAX + 1];
 
typedef struct EnemyBaseStats {
    enemyClass class;     
    int hp; 
    int atk;     
    int def;     
    int vel;     
    int level;     
    int xp; 
    int totalhp;     
    int beast;     
    int totalenergy;    
    int totalstamina;    
} EnemyBaseStats;
 
extern EnemyBaseStats baseenemystats[ENEMYCLASSESMAX + 1];
 
typedef enum {
    Blue_Troll = 0,
    Headless_Ninja = 1,
    Crawling_Dude = 2,
    Sr_Warthog = 3,
    Doppelganger = 4
} bossClass;
 
#define BOSSCLASSESMAX 4
 
extern char *classbossstrings[BOSSCLASSESMAX + 1];
 
typedef struct BossBaseStats {
    bossClass class;     
    int hp; 
    int atk;     
    int def;     
    int vel;     
    int level;     
    int xp; 
    int totalhp;     
    int beast;     
    int totalenergy;    
    int totalstamina;    
} BossBaseStats;
 
extern BossBaseStats basebossstats[BOSSCLASSESMAX + 1];
 
typedef struct {
    int enemieskilled;     
    int consumablesfound;     
    int equipsfound;     
    int artifactsfound;     
    int criticalhits;     
    int roomscompleted;     
    int floorscompleted;     
    int specialsunlocked;     
    int coinsfound; 
    int bosseskilled;     
    int unique_bosseskilled;     
    int killed_bosses[BOSSCLASSESMAX + 1];   
    int keysfound;     
} countStats;
 
typedef enum {
    KSlash = 0,
    KCover = 1,
    KArmordrop = 2,
    KBerserk = 3,
    AHeadshot = 4,
    AQuivercheck = 5,
    APoisonshot = 6,
    AFireshot = 7,
    MFatewarp = 8,
    MPowerup = 9,
    MSpellstrike = 10,
    MFlamering = 11,
    XGrimdagger = 12,
    XLeechknife = 13,
    XDisguise = 14,
    XVenomblade = 15
} specialMove;
 
#define SPECIALSMAX 3       //num of specials per class (0 inclusive)
 
extern char *specialsnamestrings[CLASSESMAX + 1][SPECIALSMAX + 1];
 
extern char *specialsdescstrings[CLASSESMAX + 1][SPECIALSMAX + 1];
 
extern int specialscosts[CLASSESMAX + 1][SPECIALSMAX + 1];
 
typedef struct {
    int enabled;     
    specialMove move;     
    char name[80];     
    char desc[80];     
    int cost;     
} Specialslot;
 
typedef enum {
    SKILL_TYPE_ATKBOOST=0,
    SKILL_TYPE_LAST_UNLOCKABLE,
    SKILL_TYPE_IDLE,
    SKILL_TYPE_MAX,
} skillType;
 
#define SKILLSTOTAL SKILL_TYPE_MAX
 
#define FIGHTER_SKILL_SLOTS SKILLSTOTAL
#define ENEMY_SKILL_SLOTS SKILLSTOTAL
#define BOSS_SKILL_SLOTS SKILLSTOTAL
 
extern char *skillsnamestrings[SKILLSTOTAL + 1];
 
extern char *skillsdescstrings[SKILLSTOTAL + 1];
 
extern int skillscosts[SKILLSTOTAL + 1];
 
typedef struct {
    int enabled;     
    skillType class;      
    char name[80];     
    char desc[80];     
    int cost;     
} Skillslot;
 
//Forward declarations for counter fields in entities
struct Turncounter;
 
typedef enum {
    NORMAL = 0,
    POISON = 1,
    BURNED = 2,
    FROZEN = 3,
    WEAK = 4,
    STRONG = 5,
    TURNBOOST_ATK = 6,
    TURNBOOST_DEF = 7,
    TURNBOOST_VEL = 8,
    TURNBOOST_ENR = 9
} counterIndexes;
//Number of counters per entity
 
#define COUNTERSMAX 9
 
//Forward declarations for equipslot fields in entities
struct Equipslot;
struct Equip;
 
typedef enum {
    HEAD = 0,
    TORSO = 1,
    LEGS = 2
} Equipzone;
 
#define EQUIPZONES 2
 
extern char *equipzonestrings[EQUIPZONES + 1];
 
/* Ceiling for Fighter equipsBag indexes.
 * @see Fighter
 */
#define EQUIPSBAGSIZE 20
 
typedef enum {
    CRITBOOST_DMG = 0,
    CRITBOOST_CHANCE = 1,
    VAMPIRISM = 2,
    RUNIC_MAGNET = 3,
    HARVESTER = 4,
    HOT_BODY = 5,
    BIOHAZARD = 6,
    ORACLE_GIFT = 7,
    PENICILLIN = 8
} perkClass;
 
#define PERKSMAX 8
 
#define EQUIPPERKSMAX 2
 
extern char *perksnamestrings[PERKSMAX + 1];
 
extern char *perksdescstrings[PERKSMAX + 1];
 
typedef struct {
    perkClass class;     
    char name[25];     
    char desc[50];     
    int innerValue; 
} Perk;
 
//Macros for special moves callback
struct Fighter;
struct Enemy;
struct Boss;
struct Path;
struct FoeParty;
 
//Macros for counters callback
 
//#define REGISTER_COUNTER_CALLBACK(c,x,f) register_counter_callback(c, (callback_void_t)x,f)
//#define GET_COUNTER_CALLBACK(c,C) ((C)callback_counter_ptrs[c])
 
//Macro to get size of an array
#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
 
typedef void (*callback_turncounter_fighter_t)(struct Fighter *);
 
typedef void (*callback_turncounter_enemy_t)(struct Enemy *);
 
#ifdef HELAPORDO_CURSES_BUILD
typedef void (*callback_special_t)(WINDOW *, struct Fighter *, struct Enemy *,
                                   struct Boss *, struct Path *, int, int, int);
#else
#ifndef HELAPORDO_RAYLIB_BUILD
#error "HELAPORDO_CURSES_BUILD and HELAPORDO_RAYLIB_BUILD are both undefined."
#else
typedef void (*callback_special_t)(Rectangle* r, struct Fighter *, struct Enemy *,
                                   struct Boss *, struct Path *, int, int, int);
#endif // HELAPORDO_RAYLIB_BUILD
#endif // HELAPORDO_CURSES_BUILD
 
typedef void (*callback_artifact_t)(struct Fighter *, struct Enemy *,
                                    struct Boss *, int isBoss);
 
typedef void (*callback_void_t)(void);
 
#define FIGHTER_NAME_BUFSIZE 50
 
typedef struct Fighter {
    char name[FIGHTER_NAME_BUFSIZE];     
    fighterClass class;     
    int hp; 
    int atk;     
    int def;     
    int vel;     
    int level;     
    int luck;     
    int totalxp;     
    int currentlevelxp;     
    int totallevelxp;     
    int totalhp;     
    fighterStatus status;     
    int energy;     
    int totalenergy;     
    int stamina;     
    int totalstamina;     
    Specialslot *specials[SPECIALSMAX + 1];   
    Skillslot *skills[FIGHTER_SKILL_SLOTS + 1];   
    struct Turncounter *counters[COUNTERSMAX + 1];   
    int turnboost_atk;     
    int turnboost_def;     
    int turnboost_vel;     
    int turnboost_enr;     
    int perksCount; 
    Perk *perks[PERKSMAX + 1];   
    struct Equipslot *equipslots[EQUIPZONES + 1];   
    struct Equip *equipsBag[EQUIPSBAGSIZE + 1];   
    Consumable *consumablesBag[CONSUMABLESMAX + 1];   
    struct Artifact *artifactsBag[ARTIFACTSMAX + 1];   
    int equipsBagOccupiedSlots;     
    int earliestBagSlot;    //TODO To always use the array efficiently (???) I sense linked lists may be better
 
    int permboost_atk;     
    int permboost_def;     
    int permboost_vel;     
    int permboost_enr;     
    int equipboost_atk;     
    int equipboost_def;     
    int equipboost_vel;     
    int equipboost_enr;     
    countStats *stats;      
    int balance;     
    int keys_balance;     
    char sprite[8][20];     
    int floor_x; 
    int floor_y; 
    //TODO eval this callback bit if we need to have some without nesting in another turncounter
    //callback_void_t callback_counter_ptrs[COUNTERSMAX]; /**< Array of callbacks for turnCounter functions.*/
} Fighter;
 
typedef struct Enemy {
    int index;     
    enemyClass class;     
    int hp; 
    int atk;     
    int def;     
    int vel;     
    int level;     
    int luck;     
    int xp; 
    int totalhp;     
    int energy;     
    int totalenergy;     
    int stamina;     
    int totalstamina;     
    fighterStatus status;     
    int beast;     
    Skillslot *skills[ENEMY_SKILL_SLOTS + 1];   
    struct Turncounter *counters[COUNTERSMAX + 1];   
    int turnboost_atk;     
    int turnboost_def;     
    int turnboost_vel;     
    int turnboost_enr;     
    int prize;     
    char sprite[8][20];     
} Enemy;
 
typedef struct Boss {
    bossClass class;     
    int hp; 
    int atk;     
    int def;     
    int vel;     
    int level;     
    int luck;     
    int xp; 
    int totalhp;     
    int energy;     
    int totalenergy;     
    int stamina;     
    int totalstamina;     
    fighterStatus status;     
    int beast;     
    Skillslot *skills[BOSS_SKILL_SLOTS + 1];   
    struct Turncounter *counters[COUNTERSMAX + 1];   
    int turnboost_atk;     
    int turnboost_def;     
    int turnboost_vel;     
    int turnboost_enr;     
    int prize;     
    char sprite[8][20];     
} Boss;
 
typedef void (*effect_fun)(Fighter *);
typedef void (*effect_e_fun)(Enemy *);
typedef void (*effect_b_fun)(Boss *);
typedef void (*effect_fp_fun)(struct FoeParty *);
 
typedef void (*boost_fun)(Fighter *, int boost);
typedef void (*boost_e_fun)(Enemy *, int boost);
typedef void (*boost_b_fun)(Boss *, int boost);
typedef void (*boost_fp_fun)(struct FoeParty *, int boost);
 
typedef enum {
    CNT_STATUS,     
    CNT_ATKBOOST,     
    CNT_DEFBOOST,      
    CNT_VELBOOST,     
    CNT_ENRBOOST      
} Countertype;
 
typedef struct Turncounter {
    int count;     
    char *desc;     
    int innerValue; 
    Countertype type;     
    void (*effect_fun)(Fighter *);     
    void (*effect_e_fun)(Enemy *);     
    void (*effect_b_fun)(Boss *);     
    void (*effect_fp_fun)(struct FoeParty *);     
    void (*boost_fun)(Fighter *, int);     
    void (*boost_e_fun)(Enemy *, int);     
    void (*boost_b_fun)(Boss *, int);     
    void (*boost_fp_fun)(struct FoeParty *, int);     
} Turncounter;
 
typedef enum {
    ALL_ARTIFACTS = 0,   
    FULL_PATH = 1,   
    ALL_BOSSES = 2    
} winconClass;
 
#define WINCON_CLASS_MAX 2
 
typedef struct Wincon {
    winconClass class;     
    int current_val;     
    int target_val; 
} Wincon;
 
extern char *winconstrings[WINCON_CLASS_MAX + 1];
 
#define PATH_SEED_BUFSIZE 20
 
typedef struct Path {
    int length;     
    int luck;     
    int prize;     
    Wincon *win_condition;     
    Saveslot *current_saveslot;     
    char seed[PATH_SEED_BUFSIZE+1]; 
    int64_t* rng_advancements; 
} Path;
 
typedef enum {
    Vest = 0,
    Helmet = 1,
    Boots = 2,
    Cape = 3,
    Tophat = 4,
    Loafers = 5
} equipClass;
 
#define EQUIPSMAX 5
 
typedef enum {
    Bad = 0,
    Average = 1,
    Good = 2,
} quality;
 
#define QUALITIESMAX 2
 
extern char *qualitytrings[QUALITIESMAX + 1];
 
typedef struct Equip {
    equipClass class;     
    Equipzone type; 
    char name[25];     
    char desc[50];     
    int qty;     
    int equipped;     
    int level;     
    //Modifiers
    //  modifier
    int atk;     
    int def;     
    int vel;     
    int enr;     
    int bonus;     
    int perksCount; 
    int cost;     
    quality qual;     
    void (*equip_fun)(Fighter *, Enemy *, Path *);
    Perk *perks[EQUIPPERKSMAX];     
    char sprite[8][20];     
} Equip;
 
extern char *equipstrings[EQUIPSMAX + 1];
 
extern Equip equips[EQUIPSMAX + 1];
 
typedef void (*equip_fun)(Fighter *, Enemy *);
 
typedef struct Equipslot {
    int active;     
    char *desc;     
    Equipzone type; 
    char sprite[8][20];     
    Equip *item;     
    //void (*equip_fun)( Fighter*,Enemy*); /**< Pointer to temp boost function applying to Enemy, takes a int
} Equipslot;
 
#define ITEM_SHOP_MAX 20
 
#define EQUIP_SHOP_MAX 2
 
#define CONSUMABLE_SHOP_MAX 3
 
#define SINGLE_CONSUMABLE_SHOP_MAX 3
 
typedef struct Shop {
 
    char *desc;     
    int itemCount;     
    int equipsCount;     
    Equip *equips[EQUIP_SHOP_MAX];     
    int equipPrices[EQUIP_SHOP_MAX];     
    int consumablesCount;     
    int uniqueConsumablesCount;     
    Consumable *consumables[CONSUMABLE_SHOP_MAX];     
    int consumablePrices[CONSUMABLE_SHOP_MAX];     
} Shop;
 
typedef enum {
    CHEST_BASE = 0,
    CHEST_BEAST = 1
} chestClass;
 
#define CHEST_CLASS_MAX 1
 
#define CHEST_CONSUMABLES_MAX 5
#define CHEST_EQUIPS_MAX 5
 
extern char *chestdescstrings[CHEST_CLASS_MAX + 1];
 
typedef struct Chest {
 
    char desc[80];     
    chestClass class;     
    int consumablesCount;     
    Consumable *consumables[CHEST_CONSUMABLES_MAX]; 
    int equipsCount;     
    Equip *equips[CHEST_EQUIPS_MAX];     
    char sprite[8][20];     
} Chest;
 
typedef enum {
    TREASURE_CHEST = 0,
    TREASURE_CONSUMABLE = 1,
    TREASURE_ARTIFACT = 2
} treasureClass;
 
#define TREASURE_CLASS_MAX 3
 
extern char *treasuredescstrings[TREASURE_CLASS_MAX + 1];
 
typedef struct Treasure {
 
    char desc[80];     
    treasureClass class;     
    Chest *chest;     
    Consumable *consumable; 
    Artifact *artifact;     
} Treasure;
 
typedef enum {
    ROADFORK_BOSS = 0,
    ROADFORK_SHOP = 1,
    ROADFORK_TREASURE = 2,
    ROADFORK_ENEMIES = 3,
    ROADFORK_ROADFORK = 4
} roadforkOption;
 
#define ROADFORK_OPTIONS_MAX 4
 
extern char *roadforkoptionstrings[ROADFORK_OPTIONS_MAX + 1];
 
typedef struct Roadfork {
 
    char *desc;     
    roadforkOption options[2];     
} Roadfork;
 
typedef enum {
    ENEMIES = 0,
    SHOP = 1,
    BOSS = 2,
    TREASURE = 3,
    ROADFORK = 4,
    HOME = 5,
    WALL = 6,
    BASIC = 7
} roomClass;
 
#define ROOM_CLASS_MAX 7
 
extern char *roomnamestrings[ROOM_CLASS_MAX + 1];
 
#define ROOM_ENEMIES_MAX 4
 
#define FOES_BOSSES_MAX 2
 
typedef enum {
    Enemies = 0,
    Bosses = 1,
} foePartyClass;
 
#define FOEPARTY_CLASS_MAX 1
 
extern char *foepartystrings[FOEPARTY_CLASS_MAX + 1];
 
typedef struct FoeParty {
    foePartyClass class;     
    int level;     
    struct Turncounter *counters[COUNTERSMAX + 1];   
    int turnboost_atk;     
    int turnboost_def;     
    int turnboost_vel;     
    int turnboost_enr;     
    Enemy *enemy_foes[ROOM_ENEMIES_MAX + 1];   
    //TODO: this is not ideal. Could we ever need to have a different max for enemy_foes? Only if the group is not in a Room??
    Boss *boss_foes[FOES_BOSSES_MAX + 1];   
    int size;     
    int tot_alive;     
    int current_index;     
    int alive_enemies[ROOM_ENEMIES_MAX + 1];   
    int alive_bosses[FOES_BOSSES_MAX + 1];   
} FoeParty;
 
typedef struct FoePartyBaseStats {
    foePartyClass class;     
    int level;     
} FoePartyBaseStats;
 
extern FoePartyBaseStats basefoepartystats[FOEPARTY_CLASS_MAX + 1];
 
typedef struct Room {
 
    int index;     
    char *desc;     
    roomClass class;     
    Shop *shop;     
    Roadfork *roadfork;     
    Treasure *treasure;     
    Boss *boss;     
    int enemyTotal; 
    Enemy *enemies[ROOM_ENEMIES_MAX];     
    FoeParty *foes; 
} Room;
 
typedef enum {
    STD_FLOOR = 0,
    DBG_FLOOR = 1,
} floorClass;
 
#define FLOOR_CLASS_MAX 1
 
extern char *floornamestrings[FLOOR_CLASS_MAX + 1];
 
#define FLOOR_MAX_COLS 24
 
#define FLOOR_MAX_ROWS 24
 
typedef struct Floor {
 
    int index;     
    char *desc;     
    floorClass class;     
    int floor_layout[FLOOR_MAX_COLS][FLOOR_MAX_ROWS];     
    int area;     
    Room *rooms_matrix[FLOOR_MAX_COLS][FLOOR_MAX_ROWS];     
    roomClass roomclass_layout[FLOOR_MAX_COLS][FLOOR_MAX_ROWS];     
    int explored_matrix[FLOOR_MAX_COLS][FLOOR_MAX_ROWS];     
    int explored_area;     
    bool from_bsp; 
    //TODO: add some pointer to a loot instance, initialised for floors having some flag active.*/
} Floor;
 
#define MAX_ROGUE_FLOORS 17
 
typedef enum saveType {
    HOME_SAVE = 0,
    ENEMIES_SAVE = 1,
    FLOORMENU_SAVE = 2,
} saveType;
 
#define SAVETYPE_MAX 2
 
extern char *savetypestrings[SAVETYPE_MAX + 1];
 
typedef struct loadInfo {
 
    int is_new_game;
    int done_loading;
    int enemy_index;
    int total_foes;
    Enemy *loaded_enemy;
    int *ptr_to_roomtotalenemies;
    int *ptr_to_roomindex;
    saveType save_type;
 
} loadInfo;
 
typedef struct {
 
    clock_t start_time; 
    countStats *stats;     
    int current_fighters;     
    roomClass current_roomtype;     
    int current_room_index; 
    int current_enemy_index;     
    Wincon *wincon; 
    Path *path;     
    Fighter *player;     
    Gamemode gamemode;     
    Floor *current_floor; 
    Room *current_room; 
#ifdef HELAPORDO_CURSES_BUILD
    GameScreen *screen; 
#else
#ifndef HELAPORDO_RAYLIB_BUILD
#error "HELAPORDO_CURSES_BUILD and HELAPORDO_RAYLIB_BUILD are both undefined.\n"
#else
#endif // HELAPORDO_RAYLIB_BUILD
#endif // HELAPORDO_CURSES_BUILD
 
    GameOptions *options; 
    bool is_seeded; 
} Gamestate;
 
#ifndef KOLISEO_HAS_REGION
extern Gamestate* G_GAMESTATE;
#endif
 
typedef enum turnOption {
    NEW_GAME = 0,
    LOAD_GAME = 1,
    INVALID = 69,
    FIGHT = 100,
    SPECIAL = 101,
    QUIT = 102,
    CONSUMABLE = 103,
    ARTIFACTS = 104,
    EQUIPS = 105,
    PERKS = 106,
    STATS = 107,
    SAVE = 108,
    EXPLORE = 109,
    DEBUG = 1337,
    TUTORIAL = 777,
    CLOSE_MENU = 110,
    SKILL = 111,
    GAME_OPTIONS = 112,
} turnOption;
 
typedef enum turnOption_OP {
    OP_NEW_GAME = 0,
    OP_LOAD_GAME = 1,
    OP_INVALID = 2,
    OP_FIGHT = 3,
    OP_SPECIAL = 4,
    OP_QUIT = 5,
    OP_CONSUMABLE = 6,
    OP_ARTIFACTS = 7,
    OP_EQUIPS = 8,
    OP_PERKS = 9,
    OP_STATS = 10,
    OP_SAVE = 11,
    OP_EXPLORE = 12,
    OP_DEBUG = 13,
    OP_LOAD_ENEMYROOM = 14,
    OP_LOAD_HOMEROOM = 15,
    OP_SKILL = 16,
    OP_CHANGE_OPTIONS = 17,
} turnOption_OP;
 
turnOption_OP turnOP_from_turnOption(turnOption t);
 
#define TURNOP_MAX 17
extern char *turnopstrings[TURNOP_MAX + 1];
 
typedef enum foeTurnOption {
    FOE_INVALID = 0,
    FOE_IDLE = 1,
    FOE_FIGHT = 2,
    FOE_SPECIAL = 3,
} foeTurnOption;
 
typedef enum foeTurnOption_OP {
    FOE_OP_INVALID = 0,
    FOE_OP_IDLE = 1,
    FOE_OP_FIGHT = 2,
    FOE_OP_SPECIAL = 3,
} foeTurnOption_OP;
 
foeTurnOption_OP foeTurnOP_from_foeTurnOption(foeTurnOption ft);
 
#define FOETURNOP_MAX 3
extern char *foeturnopstrings[FOETURNOP_MAX + 1];
 
#define OPS_LOGFILE "OPS_log.txt"
 
typedef enum OP_res {
    OP_OK = 0,
    INVALID_OP = 1,
    NO_OP = 2,
    OP_CANNOT_OPEN_SAVEFILE = 3,
    OP_RES_KILL_DONE = 4,   
    OP_RES_DMG_DEALT = 5,   
    OP_RES_DMG_TAKEN = 6,   
    OP_RES_DEATH = 7,   
    OP_RES_NO_DMG = 8,   
    OP_RES_CLASH = 9,   
    OP_RES_LOADED_ENEMYROOM = 10,   
} OP_res;
 
#define OP_RES_MAX 10
 
extern char *opresstrings[OP_RES_MAX + 1];
 
typedef struct {
    Fighter *actor; 
    Path *path;     
    Room *room;     
    loadInfo *load_info;     
    Enemy *enemy;     
    Boss *boss;     
    FILE *save_file;     
#ifdef HELAPORDO_CURSES_BUILD
    WINDOW *notify_win;     
#else
#ifndef HELAPORDO_RAYLIB_BUILD
#error "HELAPORDO_CURSES_BUILD and HELAPORDO_RAYLIB_BUILD are both undefined."
#else
    Rectangle *notify_win; 
#endif // HELAPORDO_RAYLIB_BUILD
#endif // HELAPORDO_CURSES_BUILD
    RingaBuf* rb_notifications; 
    Koliseo_Temp *t_kls;     
    Gamestate *gmst;     
    foeTurnOption_OP foe_op;     
    skillType picked_skill;  
} turnOP_args;
 
#define SHOPROOM 4
#define BOSSROOM 5
#define HOMEROOM 6
#define BEASTROOM 3
#define BSTFACTOR 1.5
 
#define ENEMYLVLRATIO 2
#define SPECIALLVLRATIO 2
#define EQUIPLVLBOOSTRATIO 3
 
typedef enum {
    FIGHTRES_INVALID = 0,   
    FIGHTRES_KILL_DONE = 1,   
    FIGHTRES_DMG_DEALT = 2,   
    FIGHTRES_DMG_TAKEN = 3,   
    FIGHTRES_DEATH = 4,   
    FIGHTRES_NO_DMG = 5,   
    FIGHTRES_CLASH = 6,   
} fightResult;
 
#define FIGHT_RES_TOT 7
 
extern char *fightresultstrings[FIGHT_RES_TOT + 1];
 
OP_res OP_res_from_fightResult(fightResult fr);
 
#define CHEST_FRAMES 25 
#define CHEST_ROWS 18 
#define CHEST_COLS 18 
#define CHEST_FRAMETIME 67 
#define CURSES_BINSAVE_NAME "save-nc.bin" 
#define RL_BINSAVE_NAME "save-rl.bin" 
#define CURSES_GMSTSAVE_NAME "run-nc.bin" 
#define RL_GMSTSAVE_NAME "run-rl.bin" 
#define CURSES_SETTINGS_SAVE_NAME "settings-nc.bin" 
#define RL_SETTINGS_SAVE_NAME "settings-rl.bin" 
extern const wchar_t HEAD_CHAR_ICON;
extern const wchar_t TORSO_CHAR_ICON;
extern const wchar_t LEGS_CHAR_ICON;
 
#define NOTIFICATION_BUFFER_SIZE 200 
typedef struct Notification {
    char buf[NOTIFICATION_BUFFER_SIZE+1];
    int8_t color;
    bool displayed;
} Notification;
 
#define NOTIFICATIONS_RINGBUFFER_SIZE 7 
#endif // GAME_CORE_H