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;
 
#ifndef KLS_HAS_REGION
#define KLS_REGIONTYPE_MAX 2
#endif // KLS_HAS_REGION

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 13

#define VERSION "1.4.13"
 
#define HELAPORDO_BINSAVEFILE_VERSION "0.0.7"

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