Subversion Repositories spk

#pragma once
#include "BaseFile.h"
#include "spkdefines.h"

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,
                SCRIPTTYPE_UNKNOWN,
                SCRIPTTYPE_LIBRARY,
                SCRIPTTYPE_UPDATE,
                SCRIPTTYPE_CUSTOMSTART,
                SCRIPTTYPE_PATCH,
                SCRIPTTYPE_FAKEPATCH,
        };

private:
        enum {
                SETTING_INTEGER,
                SETTING_STRING,
                SETTING_CHECK
        };

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

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

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


public:
        static int ConvertScriptType(const Utils::WString &sType);
        static Utils::WString GetScriptTypeStringStatic(int type, int iLang);
        static Utils::WString GetWareText(SWares *w, int lang);
        static Utils::WString GetWareDesc(SWares *w, int lang);

        // get functions
        Utils::WString scriptTypeString(int lang) const;
        Utils::WString customScriptType () const { return m_sScriptType; }
        Utils::WString customScriptType (int lang) const;
        const Utils::WString &otherName() const { return m_sOtherName; }
        const Utils::WString &otherAuthor()     const { return m_sOtherAuthor; }
        CLinkList<SWares> *GetWaresList() { return &m_lWares; }
        CLinkList<SSettingType> *settingsList() { return &m_lSettings; }

        bool CheckValidReadmes () const;

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

        virtual bool readWares(int iLang, CLinkList<SWareEntry> &list, const Utils::WString &empWares);

        // Custom Start
        Utils::WString customStartName() const;

        // set functions
        void setScriptType       ( const Utils::WString &str ) { m_sScriptType = str; _changed(); }
        void setAnotherMod   ( const Utils::WString &name, const Utils::WString &author ) { m_sOtherName = name; m_sOtherAuthor = author; _changed(); }
        void SetForceProfile ( bool p ) { m_bForceProfile = p; _changed(); }

        void SetPackageType(int i)
        {
                m_iPackageType = i;
                if ( i == PACKAGETYPE_UPDATE )
                {
                        if ( !this->findPackageNeeded(L"<package>", L"<author>") )
                                this->addNeededLibrary(L"<package>", L"<author>", L"1.00");
                }
                else
                        this->removePackageNeeded(L"<package>", L"<author>");
                _changed();
        }
        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; _changed(); }

        virtual bool loadPackageData(const Utils::WString &sFirst, const Utils::WString &sRest, const Utils::WString &sMainGame, Utils::WStringList &otherGames, Utils::WStringList &gameAddons, CProgressInfo *progress = NULL) override;
        virtual bool GeneratePackagerScript(bool wildcard, Utils::WStringList *list, int game, const Utils::WStringList &gameAddons, bool datafile = false) override;

        CSpkFile();
        virtual ~CSpkFile();

        bool isMatchingMod(const Utils::WString &mod) const;

        /// reading of files
        virtual bool parseValueLine(const Utils::WString &line) override;

        // writing of files
        virtual Utils::WString createValuesLine() const override;
        bool writeHeader(CFileIO &file, int iHeader, int iLength) const override;

        SWares *findWare(const Utils::WString &id) const;
        void addWare(const Utils::WString &sWareLine);
        void addWareText(const Utils::WString &sText);
        void addWare(SWares *pWare);
        void addWareText(SWares *pWare, int iLang, const Utils::WString &sName, const Utils::WString &sDesc);
        void removeWare(const Utils::WString &sWare);
        void removeWareText(const Utils::WString &sName, int iLang);
        void clearWareText(SWares *pWare);
        void clearWareText(const Utils::WString &sWare);
        void clearWares ();
        bool anyWares() const { return !m_lWares.empty(); }

        int CheckValidCustomStart () const;

        virtual bool computeSigned(bool updateFiles) const override;

        SSettingType *addSetting(const Utils::WString &key, int type);
        void clearSettings ();
        void convertSetting(SSettingType *t, const Utils::WString &set) const;
        Utils::WString getSetting(SSettingType *t) const;
        bool anySettings() const { return !m_lSettings.empty(); }

        // installer usage
        const Utils::WString &lastReadme () const { return m_sLastReadme; }
        const Utils::WString &customMap () const { return m_sCustomMap; }

        void setCustomMap ( const Utils::WString &map ) { m_sCustomMap = map; }
        void setLastReadme ( const Utils::WString &r ) { m_sLastReadme = r; }

        virtual int GetType () { return TYPE_SPK; }
        virtual BaseFileType type() const override { return BaseFileType::TYPE_SPK; }

        void MergePackage(CBaseFile *p);

        // old conversion functions
        bool convertOld(const Utils::WString &sOldFilename);
        static CSpkFile *convertFromOld(const Utils::WString &sOldFilename);

protected:
        virtual void Delete ();
        virtual void SetDefaults ();
        virtual bool _checkHeader(const Utils::WString &header) const override;

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

        // varibles
        Utils::WString m_sOtherAuthor;
        Utils::WString m_sOtherName;
        Utils::WString m_sScriptType;

        bool m_bForceProfile;
        int m_iPackageType;
        int m_iScriptType;

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

        SWares *m_pLastWare;

        // installer varibles
        Utils::WString m_sLastReadme;
        Utils::WString m_sCustomMap;
};