Subversion Repositories spk

#pragma once
#include "BaseFile.h"

tstruct SSettingType {
        CyString        sKey;
        int             iType;
} SSettingType;

typedef struct SWaresText {
        int             iLang;
        CyString  sName;
        CyString  sDesc;
} SWaresText;

typedef struct SWares {
        CyString  sID;
        char    cType;
        long    iPrice;
        int             iSize;
        int             iVolumn;
        int             iNotority;
        bool    bEnabled;
        int             iPosID;
        int             iDescID;
        int             iTextID;
        int             iTextPage;
        CLinkList<SWaresText> lText;
        int             iUsed;
} SWares;


class SPKEXPORT CSpkFile : public CBaseFile
{
public:
        enum {
                SCRIPTTYPE_CUSTOM,
                SCRIPTTYPE_OTHER,
                SCRIPTTYPE_NAVIGATION,
                SCRIPTTYPE_COMBAT,
                SCRIPTTYPE_MISSION,
                SCRIPTTYPE_ALPLUGIN,
                SCRIPTTYPE_HOTKEY,
                SCRIPTTYPE_SHIPUPGRADE,
                SCRIPTTYPE_SHIPCOMMAND,
                SCRIPTTYPE_STATIONCOMMAND,
                SCRIPTTYPE_FLEET,
                SCRIPTTYPE_TRADE,
                SCRIPTTYPE_PIRACY,
                SCRIPTTYPE_CHEAT,
                SCRIPTTYPE_EXTENSION,
                SCRIPTTYPE_REBALANCE,
                SCRIPTTYPE_FIX,
                SCRIPTTYPE_GENERALMOD,
                SCRIPTTYPE_TOTAL,
                SCRIPTTYPE_WINGCOMMAND,
                SCRIPTTYPE_MAX
        };

private:
        enum {
                SETTING_INTEGER,
                SETTING_STRING,
                SETTING_CHECK
        };

        typedef struct SSettingString : public SSettingType {
                SSettingString () { iType = SETTING_STRING; }
                CyString sValue;
        } SSettingString;

        typedef struct SSettingInteger : public SSettingType {
                SSettingInteger () { iType = SETTING_INTEGER; }
                int iValue;
        } SSettingInteger;

        typedef struct SSettingCheck : public SSettingType {
                SSettingCheck () { iType = SETTING_CHECK; }
                bool bValue ;
        } SSettingCheck;

public:
        static int ConvertScriptType(CyString sType);
        static CyString GetScriptTypeStringStatic(int type);
        static CyString GetWareText(SWares *w, int lang);
        static CyString GetWareDesc(SWares *w, int lang);

        // get functions
        CyString GetScriptTypeString(int lang);
        CyString GetCustomScriptType () { return m_sScriptType; }
        CyString GetCustomScriptType (int lang);
        CyString GetOtherName ()                { return m_sOtherName; }
        CyString GetOtherAuthor ()      { return m_sOtherAuthor; }
        CLinkList<SWares> *GetWaresList() { return &m_lWares; }
        CLinkList<SSettingType> *GetSettingsList() { return &m_lSettings; }

        bool CheckValidReadmes ();

        bool   IsCustomStart () { return (m_iPackageType == PACKAGETYPE_CUSTOMSTART) ? true : false;  }
        bool   IsPackageUpdate () { return (m_iPackageType == PACKAGETYPE_UPDATE) ? true : false; }
        bool   IsPatch ()               { return (m_iPackageType == PACKAGETYPE_PATCH) ? true: false; }
        bool   IsLibrary ()             { return (m_iPackageType == PACKAGETYPE_LIBRARY) ? true: false; }
        bool   IsAnotherMod()   { if ( (m_sOtherName.Empty()) || (m_sOtherAuthor.Empty()) ) return false; return true; }
        bool   IsForceProfile() { return m_bForceProfile; }
        int             GetScriptType() { return m_iScriptType; }
        int             GetPackageType() { return m_iPackageType; }

        // Custom Start
        CyString GetCustomStartName();

        // set functions
        void SetScriptType              ( CyString str ) { m_sScriptType = str; m_bChanged = true; }
        void SetAnotherMod ( CyString name, CyString author ) { m_sOtherName = name; m_sOtherAuthor = author; m_bChanged = true; }
        void SetForceProfile ( bool p ) { m_bForceProfile = p; m_bChanged = true; }

        void SetPackageType(int i)
        {
                m_iPackageType = i;
                if ( i == PACKAGETYPE_UPDATE )
                {
                        if ( !this->FindPackageNeeded("<package>", "<author>") )
                                this->AddNeededLibrary("<package>", "<author>", "1.00");
                }
                else
                        this->RemovePackageNeeded("<package>", "<author>");
                m_bChanged = true;
        }
        void SetPatch() { this->SetPackageType(PACKAGETYPE_PATCH); }
        void SetLibrary() { this->SetPackageType(PACKAGETYPE_LIBRARY); }
        void SetCustomStart() { this->SetPackageType(PACKAGETYPE_CUSTOMSTART); }
        void SetPackageUpdate() { this->SetPackageType(PACKAGETYPE_UPDATE); }
        void SetNormalPackage() { this->SetPackageType(PACKAGETYPE_NORMAL); }
        void SetScriptType(int i) { SetNormalPackage(); m_iScriptType = i; m_bChanged = true; }

        virtual bool LoadPackageData(CyString first, CyString rest);
        virtual bool GeneratePackagerScript(bool wildcard, CyStringList *list, bool datafile = false);

        CSpkFile();
        virtual ~CSpkFile();

        bool IsMatchingMod ( CyString mod );

        /// reading of files
        virtual bool ReadFileToMemory ( C_File *file );
        virtual bool ParseValueLine ( CyString line );

        // writing of files
        CyString CreateValuesLine ();
        bool WriteHeader ( FILE *id, int, int );

        SWares *FindWare ( CyString id );
        void AddWare ( CyString  );
        void AddWareText ( CyString );
        void AddWare ( SWares * );
        void AddWareText ( SWares *, int, CyString, CyString );
        void RemoveWare ( CyString );
        void RemoveWareText ( CyString, int );
        void ClearWareText ( SWares * );
        void ClearWareText ( CyString );
        void ClearWares ();
        bool AnyWares() { return !m_lWares.empty(); }

        int CheckValidCustomStart ();

        bool UpdateSigned (bool updateFiles);

        SSettingType *AddSetting ( CyString key, int type );
        void ClearSettings ();
        void ConvertSetting ( SSettingType *t, CyString set );
        CyString GetSetting ( SSettingType *t );
        bool AnySettings() { return !m_lSettings.empty(); }

        // installer usage
        CyString GetLastReadme () { return m_sLastReadme; }
        CyString GetCustomMap () { return m_sCustomMap; }

        void SetCustomMap ( CyString map ) { m_sCustomMap = map; }
        void SetLastReadme ( CyString r ) { m_sLastReadme = r; }

        virtual int GetType () { return TYPE_SPK; }

        void MergePackage(CBaseFile *p);

        // old conversion functions
        bool convertOld(const Utils::String &sOldFilename);

protected:
        virtual void Delete ();
        virtual void SetDefaults ();
        virtual bool CheckHeader(CyString header);

        // old conversion functions
        unsigned char *_convert_uncompressFile(const Utils::String &sOldFilename, int *pLen);
        void _convert_parse(const Utils::String &sCmd, const Utils::String &sRest, bool bVerbose);
        Utils::String _convert_fileEndString(const Utils::String &sFile);
        int _convert_fileType(const Utils::String &sFile);
        Utils::String _convert_parseFilename(const Utils::String &sRest, float fVersion, Utils::String *pDir);
        unsigned char *_convert_parseFile(const Utils::String &s_Cmd, const Utils::String &s_Rest, float fVersion, unsigned char *d, bool bVerbose );

        // varibles
        CyString m_sOtherAuthor;
        CyString m_sOtherName;
        CyString m_sScriptType;

        bool m_bForceProfile;
        int m_iPackageType;
        int m_iScriptType;

        CLinkList<SWares> m_lWares;
        CLinkList<SSettingType> m_lSettings;

        SWares *m_pLastWare;

        // installer varibles
        CyString m_sLastReadme;
        CyString m_sCustomMap;
};