Subversion Repositories spk

#pragma once

#include "BaseFile.h"

tstruct SSettingType {

	Utils::String	sKey;

	int		iType;

} SSettingType;

typedef struct SWaresText {

	int		iLang;

	Utils::String  sName;

	Utils::String  sDesc;

} SWaresText;

typedef struct SWares {

	Utils::String  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; }

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

	Utils::String GetCustomScriptType (){ return m_sScriptType; }

	Utils::String GetCustomScriptType (int lang);

	Utils::String GetOtherName ()	{ return m_sOtherName; }

	Utils::String 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

	Utils::String GetCustomStartName();

	// set functions

	void SetScriptType	 ( const Utils::String &str ) { m_sScriptType = str; m_bChanged = true; }

	void SetAnotherMod   ( const Utils::String &name, const Utils::String &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(const Utils::String &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(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 ();

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

	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;

};