Subversion Repositories spk

#ifndef __PACKAGES_H__
#define __PACKAGES_H__

#include "SpkFile.h"
#include "GameExe.h"
#include "XspFile.h"
#include "archive/unzip.h"

#include "MultiSpkFile.h"
#include "VirtualFileSystem.h"

enum {INSTALLERR_NONE, INSTALLERR_VERSION, INSTALLERR_INVALID, INSTALLERR_NOMULTI, INSTALLERR_NOSHIP, INSTALLERR_UNKNOWN, INSTALLERR_NOEXIST, INSTALLERR_OLD};
enum {INSTALLCHECK_OK, INSTALLCHECK_OLDVERSION, INSTALLCHECK_NOOTHERMOD, INSTALLCHECK_ALREADYQUEUED, INSTALLCHECK_WRONGGAME, INSTALLCHECK_WRONGVERSION, INSTALLCHECK_MODIFIED, INSTALLCHECK_NOSHIP};
enum {PROGRESS_ENABLEFILE, PROGRESS_SHUFFLEFAKE, PROGRESS_DISABLEFILE};
enum {PKERR_NONE, PKERR_NOPARENT, PKERR_MODIFIED, PKERR_MISSINGDEP, PKERR_NOOUTPUT, PKERR_DONTEXIST, PKERR_UNABLETOOPEN};
enum {WARETYPE_NONE, WARETYPE_DELETED, WARETYPE_ADDED, WARETYPE_DISABLED};
enum {WARES_BIO, WARES_ENERGY, WARES_FOOD, WARES_MINERAL, WARES_TECH, WARES_NATURAL, WAREBUFFERS};

#define IC_WRONGGAME            1
#define IC_WRONGVERSION         2
#define IC_OLDVERSION           4
#define IC_MODIFIED                     8
#define IC_ALL                          15

#define PMTEXTFILE 901

#define SHIPSTARTTEXT           500000
#define WARETEXTSTART           400000

class CFileIO;

tstruct SGameWare {
        char cType;
        int iType;
        int iText;
        CyString sWareName;
        int iPos;
        SWares *pWare;
} SGameWare;

tstruct SGameShip {
        int               iType;
        int               iText;
        int               iPos;
        CyString  sShipID;
        CyString  sShipClass;
        CXspFile *pPackage;
} SGameShip;

tstruct SBodies {
        CyString         sNumbers;
        CyString         sSection;
        CyStringList lEntries;
} SBodes;

tstruct SAvailablePackage {
        CLinkList<SGameCompat> lGames;
        int                     iType;
        int                     iPluginType;
        CyString        sName;
        CyString        sAuthor;
        CyString        sVersion;
        CyString        sDesc;
        CyString        sUpdated;
        int                     iEase;
        int                     iChanging;
        int                     iRec;
        CyString        sFilename;
        int                     iScriptType;
        bool            bSigned;
} SAvailablePackage;

class SPKEXPORT CPackages
{
public:
        static CyString ConvertLanguage(int lang);
        static SAvailablePackage *CreateAvailablePackageData(CBaseFile *package);
        static CyString FormatAvailablePackageData(CBaseFile *package);
        static CyString FormatAvailablePackageData(SAvailablePackage *package);
        static CyString CreateFromPackagerScript(CyString filename);
        static int GeneratePackageUpdateData(CyString dir, bool includeSingle = true);

        CPackages ();
        ~CPackages ();

        bool IsOldDir(CyString dir);
        bool Read ( CyString dir, CProgressInfo *progress = NULL );
        void Startup(CyString dir, CyString tempDir, CyString myDoc, CyString mod = NullString);

        CBaseFile *LoadPackagerScript(CyString filename, int compression, CyString (*askFunc)(CyString), CyStringList *malformedLines = NULL, CyStringList *unknownCommands = NULL, CyStringList *variables = NULL);
        CyStringList *GetGlobals() { return &m_lGlobals; }
        CyStringList *GetFakePatchOrder() { return &m_lFakePatchOrder; }
        CyString GetCurrentDirectory() { return m_sCurrentDir; }
        CyString GetTempDirectory() { return m_sTempDir; }
        CyString GetMyDocuments() { return m_sMyDoc; }
        CGameExe *GetGameExe() { return &m_gameExe; }
        CLinkList<CBaseFile> *GetInstallPackageList() { return &m_lInstallList; }

        // installing/uninstalling
        bool            InstallPackage ( CBaseFile *package, CyStringList *errors, CProgressInfo *progress = NULL, bool disabled = false );
        CBaseFile               *OpenPackage ( CyString file, int *error, CProgressInfo *progress = NULL, int readtype = SPKREAD_ALL, int flags = READFLAG_NONE );
        CMultiSpkFile   *OpenMultiPackage(CyString file, int *error, CProgressInfo *progress = NULL);
        bool            OpenMultiPackage ( CyString file, CLinkList<CBaseFile> *packageList, int *error, CProgressInfo *progress = NULL );
        int                     CheckInstallPackage(CBaseFile *package, int check = IC_ALL);
        bool            RemoveFile(C_File *file, CyStringList *errors = NULL);
        void            PrepareUninstallPackage(CBaseFile *package);
        bool            UninstallPreparedPackages(CyStringList *errors, CProgressInfo *progress, CLinkList<CBaseFile> *uninstalledPackages = NULL, CLinkList<CBaseFile> *disabledPackages = NULL);
        void            ConvertOldPackage(CBaseFile *p);
        void            PurgeUninstallScripts(CBaseFile *package, CyStringList *errors);
        int             PrepareInstallPackage(CBaseFile *package, bool disabled = false, bool force = false, int check = IC_ALL);
        int                     InstallPreparedPackages(CyStringList *errors, CProgressInfo *progress, CLinkList<CBaseFile> *errored, CLinkList<CBaseFile> *installedList = NULL);
        void            RemovePreparedInstall(CBaseFile *package);
        int                     GetNumPackagesInQueue() { return m_lInstallList.size(); }
        int                     CheckOpenPackage(CyString file, int *error);
        int                     GetMissingDependacies(CBaseFile *p, CyStringList *list, bool onlyEnabled = false, bool includePrepared = false);
        bool            CheckInstalledDependacy(CyString name, CyString author, CyString version, bool onlyEnabled = false, bool includePerpered = false);
        bool            CheckEnabledDependacy(CBaseFile *p);
        int                     GetDependacyList(CBaseFile *package, CLinkList<CBaseFile> *list);
        int                     PrepareMultiPackage ( CyString file, CLinkList<CBaseFile> *errorPackageList, int *error, CProgressInfo *progress = 0);

        bool            IsOldPluginManager() { return m_bOldPlugin; }

        // enable/disable
        bool EnablePackage ( CBaseFile *package, CyStringList *errors, CProgressInfo *progress = NULL );
        bool DisablePackage ( CBaseFile *package, CyStringList *errors, CProgressInfo *progress = NULL );
        bool DisablePreparedPackages ( CyStringList *errors, CProgressInfo *progress, CLinkList<CBaseFile> *disabledPackages = NULL );
        bool PrepareEnablePackage(CBaseFile *package);
        bool PrepareDisablePackage(CBaseFile *package);
        bool EnablePreparedPackages ( CyStringList *errors, CProgressInfo *progress, CLinkList<CBaseFile> *enabledPackages = NULL );
        int  GetNumPackagesInEnabledQueue() { return m_lEnableList.size(); }
        int  GetNumPackagesInDisabledQueue() { return m_lDisableList.size(); }
        bool PrepareDisableForVanilla();
        bool PrepareEnableLibrarys();
        bool PrepareEnableFromVanilla();

        void WriteData();
        bool CloseDir ( CyStringList *errors = 0, CProgressInfo *progress = NULL, bool removedir = false );
        bool RestoreFakePatch();
        bool ReadyFakePatch();
        bool CheckValidPluginManagerFile(CyString filename);
        bool CheckIfPluginManagerFile(CyString filename);

        // package control
        void UpdateUsedFiles(CLinkList<CBaseFile> *ignoreList = NULL, bool = true);
        void UpdateSigned();
        bool UpdatePackages(int doStatus = -1, bool individual = false);
        CBaseFile *FindXspPackage(CyString id);
        CBaseFile *FindSpkPackage(CyString name, CyString author);
        CArchiveFile *FindArchivePackage(CyString name);
        CBaseFile *FindPackage(CyString name, CyString author);
        CBaseFile *FindFirstPackageWithFile(C_File *f);
        CBaseFile *FindNextPackageWithFile(CBaseFile *p, C_File *f);
        CBaseFile *FindPackage(CBaseFile *package);
        C_File *FindFile(int filetype, CyString filename, CyString dir = NullString);
        CBaseFile *FirstPackage() { return m_lPackages.First(); }
        CBaseFile *NextPackage() { return m_lPackages.Next(); }
        CBaseFile *GetFirstPackage() { if ( m_lPackages.Front() ) return m_lPackages.Front()->Data(); return NULL; }
        CBaseFile *GetNextPackage(CBaseFile *from) 
        { 
                bool found = false;
                for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
                {
                        if ( !node->Data() ) continue;
                        if ( node->Data() == from )
                                found = true;
                        else if ( found )
                                return node->Data();
                }
                return NULL; 
        }
        void Reset();
        CBaseFile *GetPackageAt(int i) { return m_lPackages[i]; }
        CyString GetSelectedModName();
        CyString GetModKey();
        void SetupWares();
        void SetupShips();
        void PurgeGameObjects();
        void PurgeWares();
        void PurgeShips();
        void StartPackage() { m_pPackageNode = m_lPackages.Front(); }
        void UpdatePackage(CBaseFile *p);
        CBaseFile *GetCurrentPackage() { return (m_pPackageNode) ? m_pPackageNode->Data() : NULL; }
        bool RemoveCurrentDirectory();
        void RemoveCreatedFiles();
        bool AnyUnusedShared();

        // util functions
        void RemoveUnusedDirectories(CyStringList &dirs, CyStringList *errors = NULL);
        int  RemoveUninstallScripts(CyStringList *errors = 0, CProgressInfo *progress = NULL);
        bool RemoveUninstallFile(C_File *file, CyStringList *errors = 0);
        int  RemoveUnusedSharedFiles(CyStringList *errors = 0, CProgressInfo *progress = NULL);
        bool RemoveSharedFile(C_File *file, CyStringList *errors = NULL);
        void ShufflePatchTo(C_File *file, int to, CyStringList *errors);
        void ShuffleFakePatches(CyStringList *errors);
        void ShuffleTextFiles(CyStringList *errors);
        int  FindNextFakePatch(int start = 0, CyString dir = NullString);
        int  FindNextTextFile(int start = 2, CyString dir = NullString);
        int  FindLastFakePatch(int start = 99, CyString dir = NullString);
        int  FindLastTextFile(int start = 9999, CyString dir = NullString);
        int  FindLowestFakePatchInstalled();
        void ReadGameLanguage(bool force = true);
        int      RemoveAllPackages(CyStringList *errors = NULL, CProgressInfo *progress = NULL);
        void AssignPackageNumbers();
        int  GetChildPackages(CBaseFile *package, CLinkList<CBaseFile> *children, bool recursive = false);
        int  GetAllPackageFiles(CBaseFile *package, CLinkList<C_File> *fileList, bool includeChild);
        int      GetAllPackageFiles(CLinkList<CBaseFile> *list, CLinkList<C_File> *fileList, bool includeChild);
        void AddLogEntry(int type, CyString args, CyStringList *errors);
        CyString FindDataDir(CyString dir, CyString file);
        int  CountPackages(int type, bool onlyEnabled);
        int  CountBuiltInPackages(bool onlyEnabled);
        bool IsCurrentDir(CyString dir);
        bool CheckOtherPackage(CBaseFile *package);
        int CheckPreparedInstallRequired(CLinkList<CBaseFile> *list);
        static int ConvertWareType(char w);
        static char ConvertWareTypeBack(int w);
        CyString GetLogDirectory();
        CyString GetLogDirectory(CyString gameExe);
        CyString GetSaveDirectory();
        void BackupSaves() { BackupSaves(m_bVanilla); }
        void BackupSaves(bool vanilla);
        void RestoreSaves() { RestoreSaves(m_bVanilla); }
        void RestoreSaves(bool vanilla);
        bool UnPackFile(CyString filename, bool checkxml = true);
        bool PackFile(CyString filename);
        bool PackFile(CFileIO *File, CyString filename);
        CyString ConvertTextString(CyString text);
        void LoadVirtualFileSystem();
        bool CheckAccessRights(CyString dir);
        bool LoadShipData(CyString file, CyStringList *list);
        bool LoadShipData(CVirtualFileSystem *pVfs, CyStringList *list);
        bool ReadTextPage(CyString file, CyStringList *list, bool search, int page);
        CyStringList *LoadShipData(CyString file);
        CyStringList *ReadTextPage(CyString file, bool search, int page);
        int AdjustFileType(CyString name, int filetype);
        CXspFile *extractShip(const Utils::String &sCatFile, const Utils::String &sId, CProgressInfo *progress = NULL);
        CyString ReadShipData(CyString file, CyString entry);
        bool IsSamePackage(CBaseFile *p1, CBaseFile *p2);
        void ApplyFakePatchOrder(CyStringList *list);
        CBaseFile *CreateFromArchive(CyString filename, bool toInstall = false );
        void ReadArchiveData(const char *buf, size_t len, CBaseFile *archive);
        void ReadArchiveData(CyString filename, CBaseFile *archive);
        int VerifyInstalledFiles(CyStringList *missingFiles = NULL, bool getPackages = true);

        int GetCurrentGameFlags() { return m_iGameFlags; }

        void SetCurrentDir(CyString dir) { m_sCurrentDir = dir; }

        // merge mods
        CyStringList *GetMergedFiles(CCatFile *cat1, CCatFile *cat2);
        bool CanWeMerge(CyString file);
        bool MergeMods(CCatFile *mod1, CCatFile *mod2, CyString outFile, CyStringList *cantMerge);
        bool NeedToMerge(CyString file);
        CyStringList MergeTextFiles(CyStringList *files, CCatFile *mod1, CCatFile *mod2);
        bool GetModCompatabilityList(C_File *file, CyStringList *list = NULL);
        bool CheckCompatabilityBetweenModFiles(C_File *from, C_File *to, CyStringList *list = NULL);
        bool CheckCompatabilityBetweenMods(CBaseFile *from, CBaseFile *to, CyStringList *list = NULL);
        int CheckCompatabilityAgainstPackages(CBaseFile *newFile, CyStringList *list = NULL, CLinkList<CBaseFile> *packages = NULL);

        CyString GetLanguageName();

        int     GetGameLanguage(CyString dir = NullString);
        int      GetGameAddons(CyStringList &exes, CyString dir = NullString);
        CyString GetGameName(CyString dir = NullString);
        CyString GetGameVersionFromType(int game, int version, CyString sVersion);
        CyString GetGameNameFromType(int game);
        CyString GetGameTypesString(CBaseFile *package, bool includeVersion);
        CyString GetGameVersionString(CBaseFile *package);
        CyString GetGameRunExe(CyString dir = NullString);
        CyString GetProperDir(CyString dir = NullString);
        CyString GetAddonDir(CyString dir = NullString);

        // text files
        void CreateLanguageTextFiles(CyStringList *errors = 0);
        bool RenameTextFile(CyString textid, int languageid, CyStringList *errors);
        void AddTextFileToScripts(C_File *file, CyString textid);
        void CreatePluginManagerText();

        // game control
        void CreateEMPFile(CyString progDir = CyString::NullString);
        void CreateWareFiles();
        int ExtractGameFile(CyString aFilename, CyString aTo, CyString dir = NullString, CyString addon = NullString);
        void CreateDummies();
        void CreateComponants();
        void CreateCutData();
        void CreateBodies();
        void CreateGlobals();
        void CreateAnimations();
        void CreateTShips();
        CyStringList *CreateCockpits();
        void CreateCustomStarts();
        void AddCreatedFile(CyString file);
        bool ReadGlobals(CyStringList &globals);

        // install text
        CyString GetInstallBeforeText(CBaseFile *package);
        CyString GetInstallAfterText(CBaseFile *package);
        CyString GetUninstallBeforeText(CBaseFile *package);
        CyString GetUninstallAfterText(CBaseFile *package);

        // original files
        void StoreOriginalFiles(int filetype, CyString searchPath);
        void AddOriginalFile(int filetype, CyString filename, CyString searchPath);
        C_File *GetOriginalFile(C_File *file);
        bool IsOriginalFile(C_File *file);
        bool BackupOriginalFile(C_File *f, CyStringList *errors);

        //setting functions
        void SetRenameText(bool b) { m_bRenameText = b; }
        void SetLanguage(int i) { m_iLanguage = i; }
        void SetAutoEnable(bool b) { m_bAutoEnableChild = b; }
        void SetForceModInstall(bool b) { m_bForceModInstall = b; }
        void SetTempDirectory(CyString s) { m_sTempDir = s; }
        void SetMyDocuments(CyString s) { m_sMyDoc = s; }
        void SetForceEMP(bool b) { m_bForceEMP = b; }
        void SetSurpressProtectedWarning(bool b) { m_bSurpressProtectedWarning = b; }
        void SurpressProtectedWarning() { m_bSurpressProtectedWarning = true; }
        bool IsSupressProtectedWarning() { return m_bSurpressProtectedWarning; }

        int GetLanguage() { return m_iLanguage; }
        int GetGame() { return m_iGame; }
        bool IsLoaded() { return m_bLoaded; }
        bool IsVanilla() { return m_bVanilla; }
        void SetVanilla(bool b);

        CyString GetSetMod() { return m_sSetMod; }
        void SetMod(CyString mod) { 
                if ( mod != "PluginManager" )
                        m_sSetMod = mod; 
        }

        CBaseFile *GetEnabledMod() { return m_pEnabledMod; }

        //errors
        void ClearError() { m_iError = PKERR_NONE; }
        int  GetError() { return m_iError; }

        CLinkList<CBaseFile> *PackageList() { return &m_lPackages; }
        CLinkList<SAvailablePackage> *GetAvailablePackageList() { return &m_lAvailablePackages; }
        bool AnyAvailablePackages(int type = -1);
        bool AddAvailablePackage(SAvailablePackage *package);
        void ParseAvailablePackage(CyString str, CyString webaddress = NullString);
        SAvailablePackage *FindAvailablePackage(CyString &filename);
        int FindAllServers(CyStringList *list);

        CBaseFile *FindScriptByAuthor(CyString author, CBaseFile *prev = NULL);
        void RemoveFailedFiles();

private:
        CyString        m_sCurrentDir;
        CyString        m_sTempDir;
        CyString        m_sMyDoc;
        CyString        m_sSetMod;
        CyString        m_sActiveDir;

        // global files list
        CLinkList<C_File>               m_lFiles;
        CLinkList<CBaseFile>    m_lPackages;
        CLinkList<C_File>               m_lUninstallFiles;
        CLinkList<C_File>               m_lOriginalFiles;
        CLinkList<SGameWare>    m_lGameWares[WAREBUFFERS];
        CLinkList<SGameShip>    m_lGameShips;

        // prepared lists
        CLinkList<CBaseFile>    m_lInstallList; // install/uninstalling packages
        CLinkList<CBaseFile>    m_lEnableList;  // enable packages
        CLinkList<CBaseFile>    m_lDisableList; // disable packages

        CyStringList                    m_lCreatedFiles; // list of files we've created
        CyStringList                    m_lNonRemovedFiles; // list of fiels that couldn't be removed for some reason
        CyStringList                    m_lGlobals; // global settigns that we want changed
        CyStringList                    m_lFakePatchOrder; // ordered fake patches
        CLinkList<SAvailablePackage> m_lAvailablePackages; // list of available packages online

        CVirtualFileSystem              m_pGameVFS; // Games Virtual File System

        CGameExe                                m_gameExe;
        CBaseFile                          *m_pEnabledMod;

        // settings
        bool            m_bRenameText;  // rename text files
        bool            m_bAutoEnableChild;     // auto enable all children
        bool            m_bForceModInstall; // allowsm ultiple mods to be installed
        bool            m_bOldPlugin;           // if its loading data from the old plugin manager
        bool            m_bLoadVFS;                     // if we should load the virtual filesystem
        int                     m_iLanguage;    // Language id to use
        int                     m_iSaveGameManager; // Save game manager
        bool            m_bSurpressProtectedWarning; // prevent checking for protected directory

        int                     m_iGame;                // the game the directory is
        int                     m_iGameVersion; // the version of the game (version position)
        CyString        m_sGameVersion; // the version of the game (full version)
        int                     m_iGameFlags;   // the flags for the game from SGameExe
        int                     m_iMaxPatch;    // the maximum patch for the game

        int                     m_iSaveGame;
        int                     m_iError;
        int                     m_iLastUpdated;
        int                     m_iFakePatch;           // The current fake patch

        bool            m_bVanilla;             // currently in vanilla mode, dont allow unsigned packages to be installed

        bool            m_bLoaded;
        bool            m_bRedo;
        bool            m_bUsedWare;    // if we have used the ware files in the directory, not in a patch
        bool            m_bRemoveDir;   // shall we remove direcotires;

        int                     m_iWareBuffer[WAREBUFFERS];     //Ware Buffers
        int                     m_iShipBuffer; //Ship Buffers

        bool            m_bDisableVanilla;
        bool            m_bForceEMP;

        CListNode<CBaseFile>    *m_pPackageNode;
};

#endif // __PACKAGES_H__