Subversion Repositories spk

#ifndef _XSPFILE_H__
#define _XSPFILE_H__

#include "BaseFile.h"
#include "ShipData.h"
#include "StringList.h"
#include "VirtualFileSystem.h"

class CCatFile;

#define SHIPYARD_NONE             0
#define SHIPYARD_ARGON            1
#define SHIPYARD_BORON            2
#define SHIPYARD_PARANID          4
#define SHIPYARD_SPLIT            8
#define SHIPYARD_TELADI          16
#define SHIPYARD_PIRATES         32
#define SHIPYARD_FRIEND          64
#define SHIPYARD_XENON          128
#define SHIPYARD_TERRAN         256
#define SHIPYARD_ATF            512
#define SHIPYARD_YAKI           1024

#define SHIPYARD_MAX    SHIPYARD_TERRAN

enum {TAT_NONE, TAT_SINGLE, TAT_3};

#define TSHIPPOS_CLASS          53

enum {IMPORTSHIP_NONE, IMPORTSHIP_SCENE, IMPORTSHIP_EXTRACTSCENE, IMPORTSHIP_DUMMIES, IMPORTSHIP_COMPONANT, IMPORTSHIP_MODELS, IMPORTSHIP_TEXTURES, IMPORTSHIP_TEXTS, IMPORTSHIP_BODIES, IMPORTSHIP_COCKPITS, IMPORTSHIP_PACK, IMPORTSHIP_DONE};

int              SPKEXPORT GetMaxShipyards ();
Utils::WString SPKEXPORT GetShipyardName (int s);

typedef struct STypesSection {
        Utils::WString          sSection;
        Utils::WStringList      lEntries;
} STypesSection2;

typedef struct SComponentEntry {
        Utils::WString          sSection;
        Utils::CList<STypesSection> lEntries;
} SComponentEntry;

typedef struct SWeaponMask {
        int             iMask;
        int             iGame;
} SWeaponMask;

typedef struct SText
{
        int             iId;
        Utils::WString sName;
        Utils::WString sDesc;
} SText;

typedef struct SDummy
{
        Utils::WString  sSection;
        Utils::WString sData;
} SDummy;

typedef struct SComponent
{
        Utils::WString sSection;
        Utils::WString sSection2;
        Utils::WString sData;
} SComponent;

typedef struct SCockpit
{
        Utils::WString     sCockpit;
        CLinkList<SWeaponMask> lWeaponMask;
        int                             iIndex;
} SCockpit;

using namespace SPK;

class SPKEXPORT CXspFile : public CBaseFile
{
public:
        CXspFile ();
        ~CXspFile () { this->Delete(); }

        static bool ReadAnimations(const Utils::WStringList& lIn, Utils::WStringList& lOut, int startRecord);
        static bool ReadAnimations(const Utils::CStringList& lIn, Utils::CStringList& lOut, int startRecord);
        static int GetAnimationType(const Utils::String &sType);
        static Utils::WString TypesListToString(Utils::CList<STypesSection> &list, bool deleteAfter = false);

        bool writeHeader(CFileIO &file, int iHeader, int iLength) const override;

        bool IsLanguageText () { return m_bLanguageText; }
        bool IsExistingShip () { return m_bExistingShip; }

        int  GetOriginalDescription () { return m_iOrgDesc; }
        int  GetShipyards () { return m_iShipyard; }

        const Utils::WString &shipID () const { return m_sID; }
        const Utils::WString &shipData () const { return m_sData; }
        Utils::WString getX3ShipData() const;
        Utils::WString getTCShipData() const;
        Utils::WString shipFilename() const
        { 
                Utils::WString s = this->name() + L"-" + this->author();
                s = s.remove(L' ');
                s = s.remove(L'\\');
                s = s.remove(L'/');
                return s;
        }

        SText *FindShipText(int lang);
        Utils::WString textName(int lang);
        Utils::WString textDescription(int lang);

        void SetLanguageText            ( bool b )   { m_bLanguageText = b; _changed(); }
        void SetExistingShip            ( bool b )   { m_bExistingShip = b; _changed(); }
        void SetOriginalDescription     ( int i )        { m_iOrgDesc = i; _changed();; }
        void setShipID                          (const Utils::WString &sId ) { m_sID = sId; _changed();; }
        void setShipData                        (const Utils::WString &sData ) { m_sData = sData; _changed(); }

        void SetSceneFile ( C_File *f ) { m_pSceneFile = f; }
        void SetCockpitFile ( C_File *f ) { m_pCockpitFile = f; }

        void addAnimation(const Utils::CStringList &list);
        void addAnimation(const Utils::WString& data);
        void addBodies(const Utils::WString &data);
        void addBody(const Utils::WString &section, const Utils::WString &data);
        void addCutData(const Utils::WString& data);
        void addText(int id, const Utils::WString &name, const Utils::WString &desc);
        void addCockpit(const Utils::WString &cockpit, int game, int mask = -1, int index = -1 );
        void addCockpitWeapon(const Utils::WString &cockpit, int game, int mask);
        void NewCockpit(const Utils::String &id, const Utils::String &scene, int mask );
        void EditCockpit(const Utils::String &id, const Utils::String &cockpit);
        void EditCockpit(const Utils::String &id, const Utils::String &scene, int mask);
        Utils::String GetCockpitData(const Utils::String &id);
        SCockpit *FindCockpit(const Utils::String &id);
        void addDummy(const Utils::WString &section, const Utils::WString &data );
        void addComponent(const Utils::WString &section, const Utils::WString &section2, const Utils::WString &data);
        void AddWeaponMask(int game, int mask );
        void AddMissileMask(int game, int mask );
        void RemoveText(int id);
        void ClearText() { m_lText.MemoryClear(); _changed(); }

        void AddShipyard ( int s ) { m_iShipyard |= s; _changed(); }
        void RemoveShipyard ( int s ) { m_iShipyard &= ~(s); _changed(); }
        void SetShipyard(int s, bool b) { if ( b ) AddShipyard(s); else RemoveShipyard(s); }
        void ToggleShipyard(int s) { if ( this->IsShipyard(s) ) RemoveShipyard(s); else AddShipyard(s); }

        bool removeCutData(const Utils::WString &cut);
        bool removeCockpit(const Utils::WString &cockpitid);
        bool removeComponent(const Utils::WString &section1, const Utils::WString &section2, const Utils::WString &data);
        bool removeDummy(const Utils::WString &section, const Utils::WString &data);
        bool removeBodies(const Utils::WString &body);
        bool removeAnimation(const Utils::WString &ani);

        bool IsSigned() { return false; }
        bool IsValid ();
        bool IsShipyard(int s) { return (m_iShipyard & s) ? true : false; }
        bool AnyShipyards() { return (m_iShipyard > 0) ? true : false; }
        void AdjustCockpits();
        virtual Utils::WString createValuesLine() const override;
        virtual bool parseValueLine(const Utils::WString &line) override;

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

        Utils::WString shipName(int lang);
        bool ConvertOld(const Utils::String &file);

        const Utils::WStringList &getAnimations() const { return _lAnimations; }
        const Utils::WStringList &getCutData() const { return _lCutData; }
        const Utils::WStringList &getBodies() const { return _lBodies; }
        CLinkList<SWeaponMask> *GetLaserMasks() { return &m_lWeaponMasks; }
        CLinkList<SWeaponMask> *GetMissileMasks() { return &m_lMissileMasks; }
        CLinkList<SText> *GetTexts() { return &m_lText; }
        CLinkList<SDummy> *GetDummies() { return &m_lDummy; }
        CLinkList<SComponent> *GetComponents() { return &m_lComponent; }
        CLinkList<SCockpit> *GetCockpits() { return &m_lCockpit; }
        int GetLaserMask(int game, bool getOnly = false);
        int GetMissileMask(int game, bool getOnly = false);
        void SetLaserMask(int game, int mask);
        void SetMissileMask(int game, int mask);

        void setCreatedShipData(CShipData *data) { m_sData = data->createData(); }
        bool AnyTexts() { return !m_lText.empty(); }
        bool AnyDummies() { return !m_lDummy.empty(); }
        bool AnyComponents() { return !m_lComponent.empty(); }
        bool AnyCockpits() { return !m_lCockpit.empty(); }
        bool anyCutData() { return !_lCutData.empty(); }
        bool anyBodies() const { return !_lBodies.empty(); }
        bool anyAnimations() const { return !_lAnimations.empty(); }

        void clearCutData();
        void clearAnimations();
        void clearBodies();

        Utils::WString shipClass() const;
        virtual bool computeSigned(bool updateFiles) const override { return false; }

        // ship extraction
        bool startExtractShip(CVirtualFileSystem *pVfs, const Utils::String &sId, CProgressInfo *pProgress);
        bool extractShip(CVirtualFileSystem *pVfs, const Utils::String &sId, CProgressInfo *progress);
        bool extractSceneFiles(CVirtualFileSystem *pVfs);
        void extractComponants(CVirtualFileSystem *pVfs, const Utils::CStringList &sceneModels);
        void extractCutData(CVirtualFileSystem *pVfs, Utils::CStringList& sceneModels, bool add);
        void extractDummies(CVirtualFileSystem *pVfs, Utils::CStringList& sceneModels, bool add);
        void extractTextures(CVirtualFileSystem *pVfs);
        bool extractBodies(CVirtualFileSystem *pVfs, const Utils::CStringList& sceneModels);
        bool extractCockpits(CVirtualFileSystem *pVfs);

        void addComponentsToList(CLinkList<SComponentEntry> &componentList);
        void addDummiesToList(Utils::CList<STypesSection> &list);
        void addCutDataToList(Utils::CList<STypesSection> &list);
        void addBodiesToList(Utils::CList<STypesSection> &list);
        void addAnimationsToList(Utils::CList<STypesSection> &list);

        bool processSceneFileSection(int section, CVirtualFileSystem *pVfs, Utils::CStringList &lModels, CProgressInfo *progress);
        bool processSceneFiles(CVirtualFileSystem *pVfs, CProgressInfo *progress);

        void PackAllFiles();
        bool readSceneModels(Utils::CStringList& out);

        //TODO: convert this
        void ExtractTexts(CCatFile *catFile, CCatFile *secondCatFile, int textId);

        bool getTextureList(Utils::WStringList &list, const unsigned char *olddata, size_t size) const;
        bool addTextFromFile(const Utils::WString &file, int textId = -1);
        bool importBodies(const Utils::CStringList &sceneModels, const Utils::String &filename);
        bool ImportCockpits(const Utils::String &filename);
        Utils::WString formatShipData(const Utils::WStringList &cockpits, int *text, int game);

        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;
        virtual void addGeneratedFiles(HZIP &hz);

protected:
        virtual void Delete ();
        virtual void SetDefaults ();
        virtual bool _checkHeader(const Utils::WString &header) const override;
        SCockpit *_findCockpit(const Utils::WString &sID);
        void _addSection(Utils::CList<STypesSection> &list, const Utils::WString &section, const Utils::WString &data);
        void _addDataSection(Utils::WStringList& list, Utils::CList<STypesSection>& sectionList, bool bUseFirst);
        bool _addTextFromFile(CFileIO &F, int textId = -1);

protected:
        C_File *m_pSceneFile, *m_pCockpitFile;

        bool m_bLanguageText, m_bExistingShip;

        int m_iOrgDesc;

        Utils::WString m_sID;
        Utils::WString m_sData;

        Utils::WStringList              _lCutData;
        Utils::WStringList              _lBodies;
        Utils::WStringList              _lAnimations;
        CLinkList<SCockpit>             m_lCockpit;
        CLinkList<SText>                m_lText;
        CLinkList<SComponent>   m_lComponent;
        CLinkList<SDummy>               m_lDummy;
        CLinkList<SWeaponMask>  m_lWeaponMasks;
        CLinkList<SWeaponMask>  m_lMissileMasks;

        int m_iShipyard;
};

#endif //_XSPFILE_H__