Subversion Repositories spk

#pragma once

#include "BaseFile.h"

tstruct SSettingType {

	CyString	sKey;

	int		iType;

} SSettingType;

typedef struct SWaresText {

	int		iLang;

	CyString  sName;

	CyString  sDesc;

} SWaresText;

typedef struct SWares {

	CyString  sID;

	char    cType;

	long	iPrice;

	int		iSize;

	int		iVolumn;

	int		iNotority;

	bool	bEnabled;

	int		iPosID;

	int		iDescID;

	int		iTextID;

	int		iTextPage;

	CLinkList<SWaresText> lText;

	int		iUsed;

} SWares;

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

		CyString 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(CyString sType);

	static CyString GetScriptTypeStringStatic(int type);

	static CyString GetWareText(SWares *w, int lang);

	static CyString GetWareDesc(SWares *w, int lang);

	// get functions

	CyString GetScriptTypeString(int lang);

	CyString GetCustomScriptType ()	{ return m_sScriptType; }

	CyString GetCustomScriptType (int lang);

	CyString GetOtherName ()		{ return m_sOtherName; }

	CyString GetOtherAuthor ()	{ return m_sOtherAuthor; }

	CLinkList<SWares> *GetWaresList() { return &m_lWares; }

	CLinkList<SSettingType> *GetSettingsList() { return &m_lSettings; }

	bool CheckValidReadmes ();

	bool   IsCustomStart () { return (m_iPackageType == PACKAGETYPE_CUSTOMSTART) ? true : false;  }

	bool   IsPackageUpdate () { return (m_iPackageType == PACKAGETYPE_UPDATE) ? true : false; }

	bool   IsPatch ()		{ return (m_iPackageType == PACKAGETYPE_PATCH) ? true: false; }

	bool   IsLibrary ()		{ return (m_iPackageType == PACKAGETYPE_LIBRARY) ? true: false; }

	bool   IsAnotherMod()   { if ( (m_sOtherName.Empty()) || (m_sOtherAuthor.Empty()) ) return false; return true; }

	bool   IsForceProfile() { return m_bForceProfile; }

	int		GetScriptType() { return m_iScriptType; }

	int		GetPackageType() { return m_iPackageType; }

	// Custom Start

	CyString GetCustomStartName();

	// set functions

	void SetScriptType		( CyString str ) { m_sScriptType = str; m_bChanged = true; }

	void SetAnotherMod ( CyString name, CyString author ) { m_sOtherName = name; m_sOtherAuthor = author; m_bChanged = true; }

	void SetForceProfile ( bool p ) { m_bForceProfile = p; m_bChanged = true; }

	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>");

		m_bChanged = true;

	}

	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; m_bChanged = true; }

	virtual bool LoadPackageData(CyString first, CyString rest);

	virtual bool GeneratePackagerScript(bool wildcard, CyStringList *list, bool datafile = false);

	CSpkFile();

	virtual ~CSpkFile();

	bool IsMatchingMod ( CyString mod );

	/// reading of files

	virtual bool ReadFileToMemory ( C_File *file );

	virtual bool ParseValueLine ( CyString line );

	// writing of files

	CyString CreateValuesLine ();

	bool WriteHeader ( FILE *id, int, int );

	SWares *FindWare ( CyString id );

	void AddWare ( CyString  );

	void AddWareText ( CyString );

	void AddWare ( SWares * );

	void AddWareText ( SWares *, int, CyString, CyString );

	void RemoveWare ( CyString );

	void RemoveWareText ( CyString, int );

	void ClearWareText ( SWares * );

	void ClearWareText ( CyString );

	void ClearWares ();

	bool AnyWares() { return !m_lWares.empty(); }

	int CheckValidCustomStart ();

	bool UpdateSigned (bool updateFiles);

	SSettingType *AddSetting ( CyString key, int type );

	void ClearSettings ();

	void ConvertSetting ( SSettingType *t, CyString set );

	CyString GetSetting ( SSettingType *t );

	bool AnySettings() { return !m_lSettings.empty(); }

	// installer usage

	CyString GetLastReadme () { return m_sLastReadme; }

	CyString GetCustomMap () { return m_sCustomMap; }

	void SetCustomMap ( CyString map ) { m_sCustomMap = map; }

	void SetLastReadme ( CyString 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(CyString header);

	// old conversion functions

	unsigned char *_convert_uncompressFile(const Utils::String &sOldFilename, int *pLen);

	void _convert_parse(const Utils::String &sCmd, const Utils::String &sRest, bool bVerbose);

	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, bool bVerbose );

	// varibles

	CyString m_sOtherAuthor;

	CyString m_sOtherName;

	CyString m_sScriptType;

	bool m_bForceProfile;

	int m_iPackageType;

	int m_iScriptType;

	CLinkList<SWares> m_lWares;

	CLinkList<SSettingType> m_lSettings;

	SWares *m_pLastWare;

	// installer varibles

	CyString m_sLastReadme;

	CyString m_sCustomMap;

};