ser_core.h

Go to the documentation of this file.

// jgabaut @ github.com/jgabaut
// SPDX-License-Identifier: GPL-3.0-only
/*
    Copyright (C) 2022-2026 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 SER_CORE_H
#define SER_CORE_H
#include <inttypes.h>
#include "../utils/game_utils.h"
 
#ifdef HELAPORDO_RAYLIB_BUILD
#include "../build-rl/game_rl.h"
#endif

#define SERSAVEHEADER_BUFSIZE 15

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerSaveHeader {
#else
#pragma pack(push, 1)
typedef struct SerSaveHeader {
#endif
    int32_t api_level;
    char game_version[SERSAVEHEADER_BUFSIZE+1];
    char save_version[SERSAVEHEADER_BUFSIZE+1];
    char os[SERSAVEHEADER_BUFSIZE+1];
    char machine[SERSAVEHEADER_BUFSIZE+1];
#ifdef __GNUC__
} SerSaveHeader;
#else
} SerSaveHeader;
#pragma pack(pop)
#endif

#define SAVEHEADER_BUFSIZE SERSAVEHEADER_BUFSIZE

typedef struct SaveHeader {
    int32_t api_level;
    char game_version[SAVEHEADER_BUFSIZE+1];
    char save_version[SAVEHEADER_BUFSIZE+1];
    char os[SAVEHEADER_BUFSIZE+1];
    char machine[SAVEHEADER_BUFSIZE+1];
} SaveHeader;
 
bool writeSerSaveHeader(const char* filename, SerSaveHeader* data);
 
bool readSerSaveHeader(const char* filename, SerSaveHeader* data);
 
bool deser_SaveHeader(SerSaveHeader* ser, SaveHeader* deser);
 
SaveHeader* prep_saveHeader(const char* static_path, Koliseo* kls, bool force_init, bool* did_init, int saveslot_index);

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerTurncounter {
#else
#pragma pack(push, 1)
typedef struct SerTurncounter {
#endif
    int32_t count;     
    int32_t innerValue; 
    int32_t type;     
#ifdef __GNUC__
} SerTurncounter;
#else
} SerTurncounter;
#pragma pack(pop)
#endif
 
#define SerTurncounter_Fmt "SerTurncounter { Type: %" PRId32 ", Count: %" PRId32 ", InnerValue: %" PRId32 " }"
 
#define SerTurncounter_Arg(st) (st.type), (st.count), (st.innerValue)

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerPerk {
#else
#pragma pack(push, 1)
typedef struct SerPerk {
#endif
    int32_t class;    
    int32_t innerValue; 
#ifdef __GNUC__
} SerPerk;
#else
} SerPerk;
#pragma pack(pop)
#endif
 
#define SerPerk_Fmt "SerPerk { Class: %s , InnerValue: %" PRId32 " }"
 
#define SerPerk_Arg(sp) (nameStringFromPerk(sp.class)), (sp.innerValue)

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerSkillslot {
#else
#pragma pack(push, 1)
typedef struct SerSkillslot {
#endif
    int32_t class;    
    int8_t enabled; 
#ifdef __GNUC__
} SerSkillslot;
#else
} SerSkillslot;
#pragma pack(pop)
#endif

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerEquip {
#else
#pragma pack(push, 1)
typedef struct SerEquip {
#endif
    int32_t class;    
    int32_t type;   
    int8_t equipped; 
    int8_t level;
    int8_t atk;
    int8_t def;
    int8_t vel;
    int8_t enr;
    int8_t bonus;
    int8_t perksCount;
    int8_t cost;
    quality qual;
    SerPerk perks[EQUIPPERKSMAX];
#ifdef __GNUC__
} SerEquip;
#else
} SerEquip;
#pragma pack(pop)
#endif
 
#define SerEquip_Fmt "SerEquip { Class: %s , Type: %s, Equipped: %" PRId8 ", Level: %" PRId8 ", Atk: %" PRId8 ", Def: %" PRId8 ", Vel: %" PRId8 ", Enr: %" PRId8 ", Bonus: %" PRId8 ", PerksCount: %" PRId8 ", Cost: %" PRId8 ", Quality: %s }"
 
#define SerEquip_Arg(se) (stringFromEquips(se.class)), (stringFromEquipzones(se.type)), (se.equipped), (se.level), (se.atk), (se.def), (se.vel), (se.enr), (se.bonus), (se.perksCount), (se.cost), (stringFromQuality(se.qual))

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerEquipslot {
#else
#pragma pack(push, 1)
typedef struct SerEquipslot {
#endif
    int32_t type;   
    int8_t active; 
#ifdef __GNUC__
} SerEquipslot;
#else
} SerEquipslot;
#pragma pack(pop)
#endif

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerSpecialslot {
#else
#pragma pack(push, 1)
typedef struct SerSpecialslot {
#endif
    int8_t enabled;     
    int8_t move;      
    int8_t cost;      
#ifdef __GNUC__
} SerSpecialslot;
#else
} SerSpecialslot;
#pragma pack(pop)
#endif
 
#define SerSpecialslot_Fmt "SerSpecialslot { Move: %" PRId8 ", Enabled: %s, Cost: %" PRId8 " }"
 
#define SerSpecialslot_Arg(sp) (sp.move), (sp.enabled >= 1 ? "True" : "False"), (sp.cost)

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerConsumable {
#else
#pragma pack(push, 1)
typedef struct SerConsumable {
#endif
    int32_t class;     
    int32_t qty;     
#ifdef __GNUC__
} SerConsumable;
#else
} SerConsumable;
#pragma pack(pop)
#endif
 
#define SerConsumable_Fmt "SerConsumable { Class: %s , Quantity: %" PRId32 " }"
 
#define SerConsumable_Arg(sc) (stringFromConsumables(sc.class)), (sc.qty)

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerArtifact {
#else
#pragma pack(push, 1)
typedef struct SerArtifact {
#endif
    int32_t class;     
    int32_t qty;     
    int32_t active;     
    int32_t innerValue; 
#ifdef __GNUC__
} SerArtifact;
#else
} SerArtifact;
#pragma pack(pop)
#endif
 
#define SerArtifact_Fmt "SerArtifact { Class: %s , Quantity: %" PRId32 ", Active: %" PRId32 ", InnerValue: %" PRId32 " }"
 
#define SerArtifact_Arg(sa) (stringFromArtifacts(sa.class)), (sa.qty), (sa.active), (sa.innerValue)

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerCountstats {
#else
#pragma pack(push, 1)
typedef struct SerCountstats {
#endif
    int32_t enemieskilled;     
    int32_t consumablesfound;     
    int32_t equipsfound;     
    int32_t artifactsfound;     
    int32_t criticalhits;     
    int32_t roomscompleted;     
    int32_t floorscompleted;     
    int32_t specialsunlocked;     
    int32_t coinsfound; 
    int32_t bosseskilled;     
    int8_t unique_enemieskilled;     
    int8_t killed_enemies[ENEMYCLASSESMAX + 1];   
    int8_t unique_bosseskilled;  
    int8_t killed_bosses[BOSSCLASSESMAX + 1];   
    int32_t keysfound;     
#ifdef __GNUC__
} SerCountstats;
#else
} SerCountstats;
#pragma pack(pop)
#endif
 
#define SerCountstats_Fmt "SerCountstats {\n    Enemies killed: %" PRId8 ",\n    Consumables Found: %" PRId8 ",\n    Equips Found: %" PRId8 ",\n    Artifacts found: %" PRId8 ",\n    Critical Hits dealt: %" PRId8",\n    Rooms completed: %" PRId8 ",\n    Floors completed: %" PRId8 ",\n    Specials Unlocked: %" PRId8 ",\n    Coins found: %" PRId8 ",\n    Bosses killed: %" PRId8 ",\n    Unique Bosses Killed: %" PRId8 ",\n    Killed Bosses: [\n        %s: %s,\n        %s: %s,\n        %s: %s,\n        %s: %s,\n        %s: %s\n    ],\n    Keys Found: %" PRId8 "\n  }"
 
#define SerCountstats_Arg(sc) (sc.enemieskilled), (sc.consumablesfound), (sc.equipsfound), (sc.artifactsfound), (sc.criticalhits), (sc.roomscompleted), (sc.floorscompleted), (sc.specialsunlocked), (sc.coinsfound), (sc.bosseskilled), (sc.unique_bosseskilled), (stringFromBossClass(0)), (sc.killed_bosses[0] >= 1 ? "True" : "False"), (stringFromBossClass(1)), (sc.killed_bosses[1] >= 1 ? "True" : "False"), (stringFromBossClass(2)), (sc.killed_bosses[2] >= 1 ? "True" : "False"), (stringFromBossClass(3)), (sc.killed_bosses[3] >= 1 ? "True" : "False"), (stringFromBossClass(4)), (sc.killed_bosses[4] >= 1 ? "True" : "False"), (sc.keysfound)

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerEnemy {
#else
#pragma pack(push, 1)
typedef struct SerEnemy {
#endif
    int8_t index;      
    int32_t class;    
    int8_t hp;  
    int8_t atk;  
    int8_t def;  
    int8_t vel;  
    int8_t level;      
    int8_t luck;      
    int8_t xp;  
    int8_t totalhp;     
 
    int8_t energy;      
    int8_t totalenergy;  
 
    int8_t stamina;     
    int8_t totalstamina;      
 
    int32_t status;     
    int8_t beast;      
 
    SerSkillslot skills[ENEMY_SKILL_SLOTS + 1];   
 
    SerTurncounter counters[COUNTERSMAX + 1];   
    int8_t turnboost_atk;      
    int8_t turnboost_def;      
    int8_t turnboost_vel;      
    int8_t turnboost_enr;      
 
    int8_t prize;      
#ifdef __GNUC__
} SerEnemy;
#else
} SerEnemy;
#pragma pack(pop)
#endif

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerBoss {
#else
#pragma pack(push, 1)
typedef struct SerBoss {
#endif
    int32_t class;   
    int8_t hp;  
    int8_t atk;  
    int8_t def;  
    int8_t vel;  
    int8_t level;      
    int8_t luck;      
    int8_t xp;  
    int8_t totalhp;     
 
    int8_t energy;      
    int8_t totalenergy;  
 
    int8_t stamina;     
    int8_t totalstamina;      
 
    int32_t status;     
    int8_t beast;      
 
    SerSkillslot skills[BOSS_SKILL_SLOTS + 1];   
    SerTurncounter counters[COUNTERSMAX + 1];   
    int8_t turnboost_atk;      
    int8_t turnboost_def;      
    int8_t turnboost_vel;      
    int8_t turnboost_enr;      
 
    int8_t prize;      
#ifdef __GNUC__
} SerBoss;
#else
} SerBoss;
#pragma pack(pop)
#endif

#define SERFIGHTER_NAME_BUFSIZE FIGHTER_NAME_BUFSIZE

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerFighter {
#else
#pragma pack(push, 1)
typedef struct SerFighter {
#endif
    char name[SERFIGHTER_NAME_BUFSIZE];     
    int32_t class;      
    int8_t hp;  
    int8_t atk;  
    int8_t def;  
    int8_t vel;  
    int8_t level;      
    int8_t luck;      
    int8_t totalxp;     
    int8_t currentlevelxp;      
    int8_t totallevelxp;      
    int8_t totalhp;     
    int32_t status;     
 
    int8_t energy;      
    int8_t totalenergy;  
    int8_t stamina;     
    int8_t totalstamina;      
    SerSpecialslot specials[SPECIALSMAX + 1];   
    SerSkillslot skills[FIGHTER_SKILL_SLOTS + 1];   
 
    SerTurncounter counters[COUNTERSMAX + 1];   
    int8_t turnboost_atk;      
    int8_t turnboost_def;      
    int8_t turnboost_vel;      
    int8_t turnboost_enr;      
 
    int8_t perksCount;  
    SerPerk perks[PERKSMAX + 1];     
 
    SerEquipslot equipslots[EQUIPZONES + 1];   
    SerEquip equipsBag[EQUIPSBAGSIZE + 1];    
    SerConsumable consumablesBag[CONSUMABLESMAX + 1];   
    SerArtifact artifactsBag[ARTIFACTSMAX + 1];   
 
    int8_t equipsBagOccupiedSlots;      
    int8_t earliestBagSlot; //TODO To always use the array efficiently (???) I sense linked lists may be better
 
    int8_t permboost_atk;      
    int8_t permboost_def;      
    int8_t permboost_vel;      
    int8_t permboost_enr;      
 
    int8_t equipboost_atk;      
    int8_t equipboost_def;      
    int8_t equipboost_vel;      
    int8_t equipboost_enr;      
 
    SerCountstats stats;        
 
    int32_t balance;     
    int8_t keys_balance;      
 
    int8_t floor_x; 
    int8_t floor_y; 
#ifdef __GNUC__
} SerFighter;
#else
} SerFighter;
#pragma pack(pop)
#endif
 
#define SerFighter_Fmt "SerFighter {\n    Name: %s,\n    Class: %s,\n    Hp: %" PRId8 ",\n    Atk: %" PRId8 ",\n    Def: %" PRId8 ",\n    Vel: %" PRId8 ",\n    Level: %" PRId8 ",\n    Luck: %" PRId8 ",\n    Total xp: %" PRId8 ",\n    Current lvl xp: %" PRId8 ",\n    Total lvl xp: %" PRId8 ",\n    Total hp: %" PRId8 ",\n    Status: %s,\n    Energy: %" PRId8 ",\n    Total energy: %" PRId8 ",\n    Stamina: %" PRId8 ",\n    Total Stamina: %" PRId8 ",\n    Turnboost_Atk: %" PRId8 ",\n    Turnboost_Def: %" PRId8 ",\n    Turnboost_Vel: %" PRId8 ",\n    Turnboost_Enr: %" PRId8 ",\n    PerksCount: %" PRId8 ",\n    EquipsBagOccupiedSlots: %" PRId8 ",\n    EarliestBagSlot: %" PRId8 ",\n    Permboost_Atk: %" PRId8 ",\n    Permboost_Def: %" PRId8 ",\n    Permboost_Vel: %" PRId8 ",\n    Permboost_Enr: %" PRId8 ",\n    Equipboost_Atk: %" PRId8 ",\n    Equipboost_Def: %" PRId8 ",\n    Equipboost_Vel: %" PRId8 ",\n    Equipboost_Enr: %" PRId8 ",\n    Balance: %" PRId32 ",\n    Keys Balance: %" PRId8 ",\n    Floor_x: %" PRId8 ",\n    Floor_y: %" PRId8 "\n  }"
 
#define SerFighter_Arg(sf) (sf.name), (stringFromClass(sf.class)), (sf.hp), (sf.atk), (sf.def), (sf.vel), (sf.level), (sf.luck), (sf.totalxp), (sf.currentlevelxp), (sf.totallevelxp), (sf.totalhp), (stringFromStatus(sf.status)), (sf.energy), (sf.totalenergy), (sf.stamina), (sf.totalstamina), (sf.turnboost_atk), (sf.turnboost_def), (sf.turnboost_vel), (sf.turnboost_enr), (sf.perksCount), (sf.equipsBagOccupiedSlots), (sf.earliestBagSlot), (sf.permboost_atk), (sf.permboost_def), (sf.permboost_vel), (sf.permboost_enr), (sf.equipboost_atk), (sf.equipboost_def), (sf.equipboost_vel), (sf.equipboost_enr), (sf.balance), (sf.keys_balance), (sf.floor_x), (sf.floor_y)

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerFoeParty {
#else
#pragma pack(push, 1)
typedef struct SerFoeParty {
#endif
    int32_t class;     
    int8_t level;      
    SerTurncounter counters[COUNTERSMAX + 1];   
    int8_t turnboost_atk;      
    int8_t turnboost_def;      
    int8_t turnboost_vel;      
    int8_t turnboost_enr;      
    SerEnemy 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??
    SerBoss boss_foes[FOES_BOSSES_MAX + 1];   
    int8_t size;      
    int8_t tot_alive;     
    int8_t current_index;      
    int8_t alive_enemies[ROOM_ENEMIES_MAX + 1];   
    int8_t alive_bosses[FOES_BOSSES_MAX + 1];   
#ifdef __GNUC__
} SerFoeParty;
#else
} SerFoeParty;
#pragma pack(pop)
#endif

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerChest {
#else
#pragma pack(push, 1)
typedef struct SerChest {
#endif
    int32_t class;    
    int32_t consumablesCount;     
 
    SerConsumable consumables[CHEST_CONSUMABLES_MAX];   
    int32_t equipsCount;     
 
    SerEquip equips[CHEST_EQUIPS_MAX];   
#ifdef __GNUC__
} SerChest;
#else
} SerChest;
#pragma pack(pop)
#endif

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerTreasure {
#else
#pragma pack(push, 1)
typedef struct SerTreasure {
#endif
    int32_t class;     
    SerChest chest;     
    SerConsumable consumable;   
    SerArtifact artifact;       
#ifdef __GNUC__
} SerTreasure;
#else
} SerTreasure;
#pragma pack(pop)
#endif

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerShop {
#else
#pragma pack(push, 1)
typedef struct SerShop {
#endif
    int8_t itemCount;     
 
    int8_t equipsCount;  
    SerEquip equips[EQUIP_SHOP_MAX];     
    int8_t equipPrices[EQUIP_SHOP_MAX];  
 
    int8_t consumablesCount;     
    int8_t uniqueConsumablesCount;      
    SerConsumable consumables[CONSUMABLE_SHOP_MAX];     
    int8_t consumablePrices[CONSUMABLE_SHOP_MAX];      
#ifdef __GNUC__
} SerShop;
#else
} SerShop;
#pragma pack(pop)
#endif

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerRoadfork {
#else
#pragma pack(push, 1)
typedef struct SerRoadfork {
#endif
    int32_t options[2];    
#ifdef __GNUC__
} SerRoadfork;
#else
} SerRoadfork;
#pragma pack(pop)
#endif

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerRoom {
#else
#pragma pack(push, 1)
typedef struct SerRoom {
#endif
    int8_t index;      
    int32_t class;   
    SerShop shop;       
    SerRoadfork roadfork;       
    SerTreasure treasure;       
 
    SerBoss boss;       
    int8_t enemyTotal;  
    SerEnemy enemies[ROOM_ENEMIES_MAX];   
    SerFoeParty foes;   
#ifdef __GNUC__
} SerRoom;
#else
} SerRoom;
#pragma pack(pop)
#endif

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerFloor {
#else
#pragma pack(push, 1)
typedef struct SerFloor {
#endif
    int8_t index;      
 
    int32_t class;    
    int8_t floor_layout[FLOOR_MAX_COLS][FLOOR_MAX_ROWS];      
    int8_t area;      
    //SerRoom rooms_matrix[FLOOR_MAX_COLS][FLOOR_MAX_ROWS];     /**< SerRoom matrix for rooms of this floor.*/
    int32_t roomclass_layout[FLOOR_MAX_COLS][FLOOR_MAX_ROWS];       
    int8_t explored_matrix[FLOOR_MAX_COLS][FLOOR_MAX_ROWS];     
    int8_t explored_area;      
    bool from_bsp; 
#ifdef __GNUC__
} SerFloor;
#else
} SerFloor;
#pragma pack(pop)
#endif

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerWincon {
#else
#pragma pack(push, 1)
typedef struct SerWincon {
#endif
    int32_t class;     
    int8_t current_val;  
    int8_t target_val;  
#ifdef __GNUC__
} SerWincon;
#else
} SerWincon;
#pragma pack(pop)
#endif

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerSaveslot {
#else
#pragma pack(push, 1)
typedef struct SerSaveslot {
#endif
    char name[50];     
    char save_path[255];     
    int8_t index; 
#ifdef __GNUC__
} SerSaveslot;
#else
} SerSaveslot;
#pragma pack(pop)
#endif
 
#define SERPATH_SEED_BUFSIZE PATH_SEED_BUFSIZE

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerPath {
#else
#pragma pack(push, 1)
typedef struct SerPath {
#endif
    int8_t length;      
    int8_t luck;      
    int8_t prize;      
    SerWincon win_condition;     
    SerSaveslot current_saveslot;       
    char seed[SERPATH_SEED_BUFSIZE+1]; 
    int64_t rng_advancements; 
#ifdef __GNUC__
} SerPath;
#else
} SerPath;
#pragma pack(pop)
#endif

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerGamestate {
#else
#pragma pack(push, 1)
typedef struct SerGamestate {
#endif
    int64_t start_time; 
 
    SerCountstats stats;       
 
    int8_t current_fighters;     
    int32_t current_roomtype;       
    int8_t current_room_index;  
 
    int8_t current_enemy_index;  
    SerWincon wincon;   
 
    SerPath path;       
 
    SerFighter player;   
 
    int32_t gamemode;      
 
    SerFloor current_floor; 
 
    SerRoom current_room; 
    bool is_seeded; 
#ifdef __GNUC__
} SerGamestate;
#else
} SerGamestate;
#pragma pack(pop)
#endif

#ifdef __GNUC__
typedef struct __attribute__((packed)) SerGameOptions {
#else
#pragma pack(push, 1)
typedef struct SerGameOptions {
#endif
    bool use_default_background; //<** Turn on usage of default terminal background */
    bool do_autosave; //<* Turns on autosave */
    bool use_3x3_fov; //<* Turns on 3x3 fov */
 
    int32_t directional_keys_schema; //* Defines the current schema for cardinal directions movement */
#ifdef __GNUC__
} SerGameOptions;
#else
} SerGameOptions;
#pragma pack(pop)
#endif
 
bool appendSerTurncounter(const char* filename, SerTurncounter* data);
 
bool readSerTurncounter(const char* filename, size_t offset, SerTurncounter* data);
 
bool deser_Turncounter(SerTurncounter* ser, Turncounter* deser);
bool ser_Turncounter(Turncounter* deser, SerTurncounter* ser);
 
bool deser_Perk(SerPerk* ser, Perk* deser);
bool ser_Perk(Perk* deser, SerPerk* ser);
 
bool deser_Skillslot(SerSkillslot* ser, Skillslot* deser);
bool ser_Skillslot(Skillslot* deser, SerSkillslot* ser);
 
bool deser_Equip(SerEquip* ser, Equip* deser);
bool ser_Equip(Equip* deser, SerEquip* ser);
 
bool deser_Equipslot(SerEquipslot* ser, Equipslot* deser);
bool ser_Equipslot(Equipslot* deser, SerEquipslot* ser);
 
bool deser_Specialslot(SerSpecialslot* ser, Specialslot* deser);
bool ser_Specialslot(Specialslot* deser, SerSpecialslot* ser);
 
bool deser_Consumable(SerConsumable* ser, Consumable* deser);
bool ser_Consumable(Consumable* deser, SerConsumable* ser);
 
bool deser_Artifact(SerArtifact* ser, Artifact* deser);
bool ser_Artifact(Artifact* deser, SerArtifact* ser);
 
bool deser_countStats(SerCountstats* ser, countStats* deser);
bool ser_countStats(countStats* deser, SerCountstats* ser);
 
bool deser_Enemy(SerEnemy* ser, Enemy* deser);
bool ser_Enemy(Enemy* deser, SerEnemy* ser);
 
bool deser_Boss(SerBoss* ser, Boss* deser);
bool ser_Boss(Boss* deser, SerBoss* ser);
 
bool deser_Fighter(SerFighter* ser, Fighter* deser);
bool ser_Fighter(Fighter* deser, SerFighter* ser);
 
bool deser_FoeParty(SerFoeParty* ser, FoeParty* deser);
bool ser_FoeParty(FoeParty* deser, SerFoeParty* ser);
 
bool deser_Chest(SerChest* ser, Chest* deser);
bool ser_Chest(Chest* deser, SerChest* ser);
 
bool deser_Treasure(SerTreasure* ser, Treasure* deser);
bool ser_Treasure(Treasure* deser, SerTreasure* ser);
 
bool deser_Shop(SerShop* ser, Shop* deser);
bool ser_Shop(Shop* deser, SerShop* ser);
 
bool deser_Roadfork(SerRoadfork* ser, Roadfork* deser);
bool ser_Roadfork(Roadfork* deser, SerRoadfork* ser);
 
bool deser_Room(SerRoom* ser, Room* deser);
bool ser_Room(Room* deser, SerRoom* ser);
 
bool deser_Floor(SerFloor* ser, Floor* deser);
bool ser_Floor(Floor* deser, SerFloor* ser);
 
bool deser_Wincon(SerWincon* ser, Wincon* deser);
bool ser_Wincon(Wincon* deser, SerWincon* ser);
 
bool deser_Saveslot(SerSaveslot* ser, Saveslot* deser);
bool ser_Saveslot(Saveslot* deser, SerSaveslot* ser);
 
bool deser_Path(SerPath* ser, Path* deser);
bool ser_Path(Path* deser, SerPath* ser);
 
bool writeSerGamestate(const char* filename, SerGamestate* data);
bool appendSerGamestate(const char* filename, SerGamestate* data);
bool readSerGamestate(const char* filename, size_t offset, SerGamestate* data);
 
bool deser_Gamestate(SerGamestate* ser, Gamestate* deser);
bool ser_Gamestate(Gamestate* deser, SerGamestate* ser);
bool prep_Gamestate(Gamestate* gmst, const char* static_path, size_t offset, Koliseo* kls, bool force_init);
bool read_savedir(const char* dirpath);
 
bool deser_GameOptions(SerGameOptions* ser, GameOptions* deser);
bool ser_GameOptions(GameOptions* deser, SerGameOptions* ser);
bool writeSerGameOptions(const char* filename, SerGameOptions* data);
bool appendSerGameOptions(const char* filename, SerGameOptions* data);
bool readSerGameOptions(const char* filename, size_t offset, SerGameOptions* data);
bool prep_GameOptions(GameOptions* game_options, const char* static_path, size_t offset, Koliseo* kls, bool force_init);
#endif // SER_CORE_H