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
        };

private:
        enum {
                SETTING_INTEGER,
                SETTING_STRING,
                SETTING_CHECK
        };

        typedef struct SSettingString : public SSettingType {
                SSettingString () { iType = SETTING_STRING; }
                Utils::String 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(const Utils::String &sType);
        static Utils::String GetScriptTypeStringStatic(int type);
        static Utils::String GetWareText(SWares *w, int lang);
        static Utils::String GetWareDesc(SWares *w, int lang);

        // get functions
        Utils::String GetScriptTypeString(int lang) const;
        Utils::String GetCustomScriptType () const { return m_sScriptType; }
        Utils::String GetCustomScriptType (int lang) const;
        Utils::String GetOtherName () const     { return m_sOtherName; }
        Utils::String GetOtherAuthor () const { return m_sOtherAuthor; }
        CLinkList<SWares> *GetWaresList() { return &m_lWares; }
        CLinkList<SSettingType> *GetSettingsList() { 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   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::String &empWares);

        // Custom Start
        Utils::String GetCustomStartName() const;

        // set functions
        void SetScriptType       ( const Utils::String &str ) { m_sScriptType = str; _changed(); }
        void SetAnotherMod   ( const Utils::String &name, const Utils::String &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("<package>", "<author>") )
                                this->AddNeededLibrary("<package>", "<author>", "1.00");
                }
                else
                        this->RemovePackageNeeded("<package>", "<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::String &sFfirst, const Utils::String &sRest, const Utils::String &sMainGame, Utils::CStringList &otherGames);
        virtual bool GeneratePackagerScript(bool wildcard, CyStringList *list, bool datafile = false);

        CSpkFile();
        virtual ~CSpkFile();

        bool IsMatchingMod(const Utils::String &mod) const;

        /// reading of files
        virtual bool ParseValueLine(const Utils::String &line);

        // writing of files
        virtual Utils::String CreateValuesLine () const;
        bool WriteHeader(CFileIO &file, int iHeader, int iLength);

        SWares *FindWare(const Utils::String &id) const;
        void AddWare(const Utils::String &sWareLine);
        void AddWareText(const Utils::String &sText);
        void AddWare(SWares *pWare);
        void AddWareText(SWares *pWare, int iLang, const Utils::String &sName, const Utils::String &sDesc);
        void RemoveWare(const Utils::String &sWare);
        void RemoveWareText(const Utils::String &sName, int iLang);
        void ClearWareText(SWares *pWare);
        void ClearWareText(const Utils::String &sWare);
        void ClearWares ();
        bool AnyWares() const { return !m_lWares.empty(); }

        int CheckValidCustomStart () const;

        bool UpdateSigned (bool updateFiles);

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

        // installer usage
        Utils::String GetLastReadme () const { return m_sLastReadme; }
        Utils::String GetCustomMap () const { return m_sCustomMap; }

        void SetCustomMap ( const Utils::String &map ) { m_sCustomMap = map; }
        void SetLastReadme ( const Utils::String &r ) { m_sLastReadme = r; }

        virtual int GetType () { return TYPE_SPK; }

        void MergePackage(CBaseFile *p);

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

protected:
        virtual void Delete ();
        virtual void SetDefaults ();
        virtual bool CheckHeader(const Utils::String header) const;

        // old conversion functions
        unsigned char *_convert_uncompressFile(const Utils::String &sOldFilename, int *pLen);
        void _convert_parse(const Utils::String &sCmd, const Utils::String &sRest);
        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);

        // varibles
        Utils::String m_sOtherAuthor;
        Utils::String m_sOtherName;
        Utils::String 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::String m_sLastReadme;
        Utils::String m_sCustomMap;
};