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__