ModConfigResource.h

Go to the documentation of this file.

/*
  Cavestory Multiplayer API
  Copyright (C) 2021 Johnny Ledger
 
  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.
 
  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:
 
  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
*/
 
#if defined(_CAVESTORY_MULTIPLAYER) || !defined(_CAVEEDITOR)
#include <CSMAPI_begincode.h>
#endif
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
#pragma once
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
static const char* g_PXMOD_MUSIC_TYPE_EXTENSION_LIST[] = { "", "org", "ptcop", "wav", "mp3", "ogg" };
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
#define PXMOD_HEADER_STRING     "PXMOD"
#define PXMOD_VERSION           22
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
enum PXMOD_BUILD_TYPE : unsigned char
{
    PXMOD_BUILD_DEBUG   = 0,
    PXMOD_BUILD_RELEASE = 1,
 
    PXMOD_BUILD_COUNT
};
 
enum PXMOD_DIRECTIONS : unsigned char
{
    PXMOD_DIRECT_LEFT       = 0,
    PXMOD_DIRECT_UP         = 1,
    PXMOD_DIRECT_RIGHT      = 2,
    PXMOD_DIRECT_DOWN       = 3,
    PXMOD_DIRECT_CENTER     = 4,
    PXMOD_DIRECT_RIGHT_UP   = 5,
    PXMOD_DIRECT_DOWN_RIGHT = 6,
 
    // This should always be at the bottom of this enum.
    PXMOD_DIRECT_COUNT
};
 
enum PXMOD_BK_TYPE : unsigned char
{
    PXMOD_BK_FIXED             = 0,
    PXMOD_BK_MOVE_SLOW         = 1,
    PXMOD_BK_FOLLOW_FOREGROUND = 2,
    PXMOD_BK_HIDE              = 3,
    PXMOD_BK_SCROLL_FAST       = 5,
    PXMOD_BK_SCROLL_GRAVITY    = 6,
    PXMOD_BK_SCROLL_LAYERED    = 7,
 
    PXMOD_BK_COUNT             = 7
};
 
enum PXMOD_BOSS_TYPE : unsigned char
{
    PXMOD_BOSS_NONE           = 0,
    PXMOD_BOSS_OMEGA          = 1,
    PXMOD_BOSS_BALFROG        = 2,
    PXMOD_BOSS_WEAPON_X       = 3,
    PXMOD_BOSS_CORE           = 4,
    PXMOD_BOSS_IRONHEAD       = 5,
    PXMOD_BOSS_DRAGON_SISTERS = 6,
    PXMOD_BOSS_UNDEAD_CORE    = 7,
    PXMOD_BOSS_HEAVY_PRESS    = 8,
    PXMOD_BOSS_BALLOS         = 9,
 
    PXMOD_BOSS_COUNT          = 9
};
 
enum PXMOD_BULLET_FLAGS : unsigned short
{
    PXMOD_BULLET_FLAG_IGNORE_SOLID          = 0x004,
    PXMOD_BULLET_FLAG_DONT_DESTROY_SOLID    = 0x008,
    PXMOD_BULLET_FLAG_PROJECTILE            = 0x010,
    PXMOD_BULLET_FLAG_BREAK_BLOCKS          = 0x020,
    PXMOD_BULLET_FLAG_PIERCE_BLOCKS         = 0x040
};
 
enum PXMOD_MUSIC_TYPE : unsigned char
{
    PXMOD_MUSIC_TYPE_INVALID = 0,
    PXMOD_MUSIC_TYPE_ORGANYA = 1,
    PXMOD_MUSIC_TYPE_PTCOP   = 2,
    PXMOD_MUSIC_TYPE_WAV     = 3,
    PXMOD_MUSIC_TYPE_MP3     = 4,
    PXMOD_MUSIC_TYPE_OGG     = 5,
 
    PXMOD_MUSIC_TYPE_COUNT   = 6
};
 
enum PXMOD_WEAPON_TYPE : unsigned char
{
    PXMOD_WEAPON_CUSTOM      = 0,
    PXMOD_WEAPON_AGILITY     = 1,
    PXMOD_WEAPON_NOTHING     = 2,
    PXMOD_WEAPON_RESERVED_3  = 3,
    PXMOD_WEAPON_RESERVED_4  = 4,
    PXMOD_WEAPON_RESERVED_5  = 5,
    PXMOD_WEAPON_RESERVED_6  = 6,
    PXMOD_WEAPON_RESERVED_7  = 7,
    PXMOD_WEAPON_RESERVED_8  = 8,
    PXMOD_WEAPON_RESERVED_9  = 9,
    PXMOD_WEAPON_RESERVED_10 = 10,
 
    PXMOD_WEAPON_COUNT       = 10
};
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
struct PXMOD_BACKGROUND_STRUCT
{
    char name[16];
};
 
struct PXMOD_SPRITESHEET_STRUCT
{
    char name[16];
};
 
struct PXMOD_TILESET_STRUCT
{
    char name[16];
};
 
struct PXMOD_STAGE_STRUCT
{
    char file[32];
 
    int tileset;
 
    PXMOD_BK_TYPE bkType;
 
    int background;
 
    int npc_sheet;
 
    int boss_sheet;
    
    int area_index;
 
    PXMOD_BOSS_TYPE boss_no;
 
    char name[34];
 
    bool focus_center_x;
 
    bool focus_center_y;
    
    bool share_pickups;
};
 
struct PXMOD_VERSION_STRUCT
{
    unsigned char data[4];
 
    inline int operator[](int idx) { return (int)data[idx % sizeof(data)]; }
 
    PXMOD_VERSION_STRUCT()
    {
        data[0] = 1;
        data[1] = 0;
        data[2] = 0;
        data[3] = 0;
    }
 
    PXMOD_VERSION_STRUCT(int season, int major, int minor, int patch)
    {
        data[0] = season;
        data[1] = major;
        data[2] = minor;
        data[3] = patch;
    }
};
 
struct PXMOD_AREA_STRUCT
{
    char name[32];
 
    int stage_idx;
 
    bool singleplayer_only;
 
    bool keep_on_release;
    
    bool allow_downloading;
};
 
struct PXMOD_MUSIC_STRUCT
{
    char name[16];
 
    PXMOD_MUSIC_TYPE type;
};
 
struct PXMOD_BULLET_STRUCT
{
    unsigned short flags;
 
    int damage;
 
    int hit_life;
 
    int range;
 
    struct
    {
        int w;
        int h;
    } bullet_size;
 
    struct
    {
        int w;
        int h;
    } collision_size;
 
    struct
    {
        int left;
        int right;
        int top;
        int bottom;
    } sprite;
 
    char name[64];
};
 
struct PXMOD_WEAPON_STRUCT
{
    struct WEAPON_LEVEL_INFO
    {
        int bullet_index;
 
        int exp;
 
        struct
        {
            int left;
            int top;
            int right;
            int bottom;
        } view;
    } level_info[3];
 
    struct WEAPON_DISPLAY_INFO
    {
        int left;
        int top;
        int right;
        int bottom;
 
        int hold_offset_x;
        int hold_offset_y;
    } display_info;
 
    char name[64];
 
    PXMOD_WEAPON_TYPE type;
};
 
struct PXMOD_NPC_ACT_STRUCT
{
    char name[64];
 
    int act_no;
    unsigned long long int nodes;
    unsigned long long int transmit_nodes;
};
 
struct PXMOD_NPC_DEFAULT_PROPERTY_STRUCT
{
    char name[256];
    char default_value[256];
};
 
struct PXMOD_NPC_STRUCT
{
    char name[64];
 
    unsigned long long int nodes;
    unsigned long long int transmit_nodes;
    unsigned int bits;
    unsigned short life;
    unsigned char surf;
    unsigned char hit_voice;
    unsigned char destroy_voice;
    unsigned char size;
    long exp;
    long damage;
 
    struct
    {
        unsigned char front;
        unsigned char back;
        unsigned char top;
        unsigned char bottom;
    } hit;
 
    struct
    {
        unsigned char front;
        unsigned char back;
        unsigned char top;
        unsigned char bottom;
    } view;
 
    struct
    {
        int left;
        int top;
        int right;
        int bottom;
    } sprite;
 
    int spritesheet_index;
 
    bool useNewColMethod;
    bool canBreakTile47;
 
    char category[64];
    char option1[256];
    char option2[256];
    char option3[256];
    char option4[256];
    char shortname1[8];
    char shortname2[8];
 
    struct
    {
        PXMOD_NPC_ACT_STRUCT* list;
        unsigned int count;
        unsigned int highest_act_no;
    } acts;
 
    struct
    {
        PXMOD_NPC_DEFAULT_PROPERTY_STRUCT* list;
        unsigned int count;
    } default_properties;
};
 
struct PXMOD_ITEM_STRUCT
{
    char name[64];
    char desc[2048];
    int sprite_index;
    char set_flag_count;
    int set_flag_list[8];
};
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
struct PXMOD_HEADER_STRUCT
{
    char                    title[128];
    char                    author[128];
    PXMOD_VERSION_STRUCT    version;
    PXMOD_BUILD_TYPE        build_type;
    unsigned short          max_save_files;
 
    struct
    {
        bool allow_carrying_players;
        bool allow_agility;
        bool allow_fishing;
    } gameplay;
 
    struct
    {
        bool draw_hp_bar;
        bool draw_hp;
        bool draw_weapons;
        bool draw_ammo;
        bool draw_exp_bar;
        bool draw_level;
    } hud;
 
    struct
    {
        bool enabled;
        int surface_id;
        struct
        {
            int left;
            int top;
            int right;
            int bottom;
        } sprite_rect;
    } collectables;
 
    struct
    {
        unsigned short drown_core_flag;
        unsigned short drown_core;
        unsigned short everyone_died;
        unsigned short drown;
        unsigned short death;
    } events;
 
    struct
    {
        unsigned int title;
        unsigned int netmenu;
    } music;
};
 
struct PXMOD_START_CHUNK
{
    unsigned int map;
    unsigned short x;
    unsigned short y;
    unsigned short event;
    unsigned char hp;
    unsigned char max_hp;
    PXMOD_DIRECTIONS direct;
    unsigned int flags;
};
 
struct PXMOD_TITLE_CHUNK
{
    unsigned int map;
    unsigned short event;
    unsigned short x;
    unsigned short y;
};
 
struct PXMOD_BACKGROUND_CHUNK
{
    PXMOD_BACKGROUND_STRUCT* list;
    unsigned int count;
};
 
struct PXMOD_SPRITESHEET_CHUNK
{
    PXMOD_SPRITESHEET_STRUCT* list;
    unsigned int count;
};
 
struct PXMOD_TILESET_CHUNK
{
    PXMOD_TILESET_STRUCT* list;
    unsigned int count;
};
 
struct PXMOD_STAGE_CHUNK
{
    PXMOD_STAGE_STRUCT* list;
    unsigned short count;
};
 
struct PXMOD_AREA_CHUNK
{
    PXMOD_AREA_STRUCT* list;
    unsigned int count;
};
 
struct PXMOD_MUSIC_CHUNK
{
    PXMOD_MUSIC_STRUCT* list;
    unsigned int count;
};
 
struct PXMOD_BULLET_CHUNK
{
    PXMOD_BULLET_STRUCT* list;
    unsigned short count;
};
 
struct PXMOD_WEAPON_CHUNK
{
    PXMOD_WEAPON_STRUCT* list;
    unsigned int count;
};
 
struct PXMOD_NPC_CHUNK
{
    PXMOD_NPC_STRUCT* list;
    unsigned int count;
};
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
#if defined(_CAVESTORY_MULTIPLAYER) || defined(CAVESTORYMULTIPLAYERBASEDLL_EXPORTS)
class CAVESTORY_MOD_API ModConfigResource
#else
class ModConfigResource
#endif
{
public: // Public map info
 
    char mModPath[260];
 
    PXMOD_HEADER_STRUCT mHeader;
 
    PXMOD_START_CHUNK mStart;
 
    PXMOD_TITLE_CHUNK mTitle;
 
    PXMOD_BACKGROUND_CHUNK mBackgrounds;
 
    PXMOD_SPRITESHEET_CHUNK mSpritesheets;
 
    PXMOD_TILESET_CHUNK mTilesets;
 
    PXMOD_STAGE_CHUNK mStages;
 
    PXMOD_AREA_CHUNK mAreas;
 
    PXMOD_MUSIC_CHUNK mMusic;
 
    PXMOD_WEAPON_CHUNK mWeapons;
 
    PXMOD_BULLET_CHUNK mBullets;
 
    PXMOD_NPC_CHUNK mNpcs;
 
public: // Public constructor
 
    ModConfigResource();
 
    ~ModConfigResource();
 
public: // Map manipulation
 
    bool CreateMod(const char* pModPath, bool bAutoScan = true, const char* pModTitle = "My Mod", const char* pModAuthor = "Me", PXMOD_VERSION_STRUCT pVersion = PXMOD_VERSION_STRUCT(), bool bUseDefaultAssets = false);
 
    bool Load(const char* pModPath, bool bOnlyValidate = false, bool bForceRelease = false, bool bShowError = true);
 
    bool Save(bool bRelease = false);
    
    bool CreateFromMod(const char* pModPath);
 
public: // General cleanup
 
    void Reset();
 
public: // Header setting
 
    void SetTitle(const char* title);
 
    void SetAuthor(const char* author);
    
    void SetVersion(const PXMOD_VERSION_STRUCT& pNewVersion);
 
public: // Header gettings
 
    const char* GetTitle();
 
    const char* GetInternalName();
 
    const char* GetAuthor();
 
    PXMOD_VERSION_STRUCT GetVersion();
 
public: // Background editing
 
    int AddBackground(const char* pFileName);
 
    bool RemoveBackground(const char* pFileName);
 
    int FindBackground(const char* pFileName);
 
public: // Tileset editing
 
    int AddTileset(const char* pFileName);
 
    bool RemoveTileset(const char* pFileName);
 
    int FindTileset(const char* pFileName);
 
public: // Spritesheet editing
 
    int AddSpritesheet(const char* pFileName);
 
    bool RemoveSpritesheet(const char* pFileName);
 
    int FindSpritesheet(const char* pFileName);
 
public: // Stage editing
 
    int AddStage(const char* pFileName, const char* pMapName, const char* pTileset, const char* pNpcSheet, const char* pBossSheet, const char* pBackground, PXMOD_BK_TYPE iBkType, PXMOD_BOSS_TYPE iBossType, unsigned int iInsertIndex = 0xFFFFFFFF);
    
    int SetStage(int iIndex, const char* pFileName, const char* pMapName, const char* pTileset, const char* pNpcSheet, const char* pBossSheet, const char* pBackground, PXMOD_BK_TYPE iBkType, PXMOD_BOSS_TYPE iBossType);
 
    bool RemoveStage(const char* pFileName);
 
    int FindStage(const char* pFileName);
 
public: // Spritesheet editing
 
    int AddArea(const char* pAreaName);
 
    bool RemoveArea(const char* pAreaName);
 
    int FindArea(const char* pAreaName);
 
public: // Music editing
 
    int AddMusic(const char* pMusicName, PXMOD_MUSIC_TYPE eMusicType = PXMOD_MUSIC_TYPE::PXMOD_MUSIC_TYPE_INVALID);
 
    bool MoveMusic(const char* pMusicName, bool bMoveUp);
 
    bool RemoveMusic(const char* pMusicName);
 
    int FindMusic(const char* pMusicName);
 
public: // Weapon editing
 
    int AddWeapon(const char* pWeaponName);
 
    bool RemoveWeapon(const char* pWeaponName);
 
    int FindWeapon(const char* pWeaponName);
 
public: // Bullet editing
 
    int AddBullet(const char* pBulletNmae);
 
    bool RemoveBullet(const char* pBulletName);
 
    int FindBullet(const char* pBulletName);
 
public: // NPC editing
 
    int AddNPC(const char* pNpcName);
 
    bool RemoveNPC(const char* pNpcName);
 
    int FindNPC(const char* pNpcName);
 
public: // Act editing
 
    int AddNpcAct(int iNpcIndex, int iActNo, const char* pActName, unsigned long long int iNodeFlags, unsigned long long int iTransmitNodeFlags);
 
    bool RemoveNpcAct(int iNpcIndex, int iActNo);
 
public: // Getting defaults methods
 
    static const PXMOD_NPC_STRUCT* GetDefaultNpc(int iIndex);
    
    static const PXMOD_WEAPON_STRUCT* GetDefaultWeapon(int iIndex);
    
    static const PXMOD_WEAPON_STRUCT* GetDefaultTemplateWeapon(PXMOD_WEAPON_TYPE eType);
    
    static const PXMOD_BULLET_STRUCT* GetDefaultBullet(int iIndex);
 
public: // Defaulting
 
    void DefaultWeapons();
};
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
inline const char* ModConfigResource::GetTitle()
{
    return mHeader.title;
}
 
inline const char* ModConfigResource::GetAuthor()
{
    return mHeader.author;
}
 
inline PXMOD_VERSION_STRUCT ModConfigResource::GetVersion()
{
    return mHeader.version;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
#if defined(_CAVESTORY_MULTIPLAYER) || !defined(_CAVEEDITOR)
extern CAVESTORY_MOD_API ModConfigResource gCaveMod;
 
#include <CSMAPI_endcode.h>
#endif