Subversion Repositories spk

#include "ModDiff.h"

#include "File_IO.h"

#include "CatFile.h"

CModDiff::CModDiff(const Utils::String &dir, const Utils::String &sAddon, int maxPatch) : m_pCatFile(NULL), m_sAddon(sAddon), m_sTempDir("."), m_iMaxPatch(maxPatch)

{

	m_bLoaded = this->LoadDirectory(dir);

}

CModDiff::~CModDiff(void)

{

	delete m_pCatFile;

}

bool CModDiff::LoadDirectory(const Utils::String &dir)

{

	m_sCurrentDir = dir;

	m_fileSystem.setAddon(m_sAddon);

	return m_fileSystem.LoadFilesystem(dir, m_iMaxPatch);

}

bool CModDiff::startDiff(const Utils::String &sModFile)

{

	ClearError();

	if ( !CFileIO::Exists(sModFile) ) { m_iError = MDERR_FILENOTFOUND; return false; }

	delete m_pCatFile;

	m_pCatFile = new CCatFile;

	if ( m_pCatFile->open(sModFile, m_sAddon, CATREAD_CATDECRYPT, false) != CATERR_NONE ) { 

		delete m_pCatFile;

		m_pCatFile = NULL;

		m_iError = MDERR_CANTOPENMOD; 

		return false; 

	}

	return true;

}

Utils::String CModDiff::_extractFile(const Utils::String &sFile, const Utils::String &sTo)

{

	SInCatFile *c = m_pCatFile->FindData(sFile);

	if ( !c ) c = m_pCatFile->FindData(m_sAddon + "/" + sFile);

	if ( !c ) return m_fileSystem.ExtractGameFile(sFile, sTo);

	if ( m_pCatFile->ExtractFile(c, sTo) ) return sTo;

	return "";

}

bool CModDiff::doDiff(const Utils::String &sModFile)

{

	// find the file in the loaded cat

	SInCatFile *c = m_pCatFile->FindData(sModFile);

	if ( !c ) c = m_pCatFile->FindData(m_sAddon + "/" + sModFile);

	if ( !c ) return false;

	// extract the matching file

	Utils::String sToFile = CFileIO(m_sTempDir + "/" + CFileIO(c->sFile).filename()).fullFilename();

	if ( !m_pCatFile->ExtractFile(sModFile, sToFile) ) return false;

	// create a diff

	Utils::String to = m_fileSystem.ExtractGameFile(c->sFile, sToFile + ".compare");

	if ( !to.empty() ) {

		SDiffFile *diff = diffFile(to, sToFile, c->sFile);

		if ( diff ) { 

			this->_adjustFile(sModFile, diff, false);

		}

		CFileIO::Remove(to);

	}

	CFileIO::Remove(sToFile);

	return true;

}

bool CModDiff::_adjustTShips(SDiffFile *pDiff, bool bReverse)

{

	// need to read TCockpits

	Utils::String sTo = this->_extractFile("types/TCockpits.pck", "TCockpits.xml");

	if ( sTo.empty() ) return false;

	CFileIO TCockpits("TCockpits.xml");

	if ( !TCockpits.exists() ) return false;

	CyStringList *pFiles = TCockpits.ReadLinesStr();

	if ( !pFiles ) return false;

	// remove all the comments

	for ( SStringList *str = pFiles->Head(); str; str = str->next ) {

		if ( str->str[0] == '/' ) str->remove = true;

	}

	pFiles->RemoveMarked();

	pFiles->PopFront();

	std::map<Utils::String, int> fileSet;

	int iPos = 0;

	for ( SStringList *str = pFiles->Head(); str; str = str->next ) fileSet[Utils::String(str->str.ToString()).token(";", -2)] = iPos++;

	// now cycle through ships and adjust the cockpits

	int iCount = -1;

	for ( SDiffEntry *pEntry = pDiff->m_lEntries.First(); pEntry; pEntry = pDiff->m_lEntries.Next() ) {

		switch (pEntry->iType) {

			case DIFFTYPE_ADDITION:

				{

					SDiffEntryAddition *pAddition = static_cast<SDiffEntryAddition *>(pEntry);

					if ( pAddition ) {

						for ( int t = 0; t < 6; t++ ) {

							Utils::String sE = pAddition->sEntry.token(";", 32 + (t * 2));

							if ( !bReverse && sE.isNumber() ) {

								int iTurret = sE;

								if ( iTurret && iTurret < pFiles->Count() ) {

									Utils::String sCockpit = pFiles->GetAt(iTurret)->str.ToString();

									pAddition->sEntry = pAddition->sEntry.replaceToken(";", 32 + (t * 2), sCockpit.token(";", -2) + ":" + static_cast<long>(iTurret));

								}

							}

							else if ( bReverse && !sE.isNumber() ) {

								int iUnfound = 0;

								if ( sE.isin(":") ) {

									iUnfound = sE.token(":", 2);

									sE = sE.token(":", 1);

								}

								int iEntry = (fileSet.find(sE) == fileSet.end()) ? iUnfound : fileSet[sE];

								pAddition->sEntry = pAddition->sEntry.replaceToken(";", 32 + (t * 2), static_cast<long>(iEntry));

							}

						}

					}

				}

				break;

			case DIFFTYPE_CHANGE:

				{

					SDiffEntryChange *pChange = static_cast<SDiffEntryChange *>(pEntry);

					if ( pChange->iPos >= 32 && pChange->iPos <= 42 && (pChange->iPos % 2) && pChange->sEntry.isNumber() ) {

						Utils::String sCockpit = pFiles->GetAt(pChange->sEntry)->str.ToString();

						pChange->sEntry = sCockpit.token(";", -2) + ":" + pChange->sEntry;

					}

				}

				break;

		}

	}

	delete pFiles;

	return true;

}

int CModDiff::_specialType(const Utils::String &sFile)

{

	if ( sFile.Compare("TShips") ) return MERGETYPE_TSHIPS;

	return MERGETYPE_NONE;

}

void CModDiff::_adjustFile(const Utils::String &sFile, SDiffFile *pDiff, bool bReverse)

{

	// check if we need to adjust the file

	CFileIO File(sFile);

	int iType = _specialType(File.baseName());

	if ( iType == MERGETYPE_NONE ) return;

	// read in the file data

	switch(iType) {

		case MERGETYPE_TSHIPS:

			this->_adjustTShips(pDiff, bReverse);

			break;

	}

}

bool CModDiff::CreateDiff(const Utils::String &modfile)

{

	ClearError();

	//check for valid parameters

	if ( !CFileIO(modfile).ExistsOld() ) { m_iError = MDERR_FILENOTFOUND; return false; }

	Utils::String addonDir = "";

	int addonSize = addonDir.length() + 1;

	// try and open the mod file

	CCatFile cat;

	if ( cat.open(modfile, addonDir, CATREAD_DAT, false) != CATERR_NONE ) { m_iError = MDERR_CANTOPENMOD; return false; }

	// we'll need to read in all the types/text files

	for (unsigned int i = 0; i < cat.GetNumFiles(); i++)

	{

		SInCatFile *f = cat.GetFile(i);

		Utils::String checkFile = f->sFile.findReplace("\\", "/");

		if ( (checkFile.left(6).Compare("types/") || checkFile.left(2).Compare("t/") || checkFile.left(6 + addonSize).Compare(addonDir + "/types/") || checkFile.left(2 + addonSize).Compare(addonDir + "/t/")) && _validFile(checkFile) )

		{

			// extract the file to the temp dir

			Utils::String toFile = CFileIO(m_sTempDir + "/" + CFileIO(f->sFile).filename()).fullFilename();

			if ( cat.ExtractFile(f, toFile ) )

			{

				// now extract the matching file from the game dir

				if ( m_fileSystem.ExtractGameFile(f->sFile, toFile + ".compare") )

				{

					diffFile(toFile + ".compare", toFile, f->sFile);

					CFileIO::Remove(toFile + ".compare");

				}

				// make sure we clear up afterwards

				CFileIO::Remove(toFile);

			}

		}

	}

	return true;

}

SDiffFile *CModDiff::diffFile(const Utils::String &baseFile, const Utils::String &modFile, const Utils::String &fileType)

{

	int type = 0;

	SDiffFile *diffFile = new SDiffFile;

	diffFile->sFile = fileType;

	// read both files and compare them

	CFileIO Base(baseFile);

	CyStringList *baseLines = Base.ReadLinesStr();

	if ( baseLines )

	{

		CFileIO Mod(modFile);

		CyStringList *lines = Mod.ReadLinesStr();

		if ( lines )

		{

			int id = -1;

			SStringList *node[2];

			node[0] = baseLines->Head();

			node[1] = lines->Head();

			Utils::String prev[2];

			while ( node[0] || node[1] )

			{

				Utils::String str[2];

				for ( int i = 0; i < 2; i++ )

				{

					while (node[i])

					{

						Utils::String l = node[i]->str.ToString();

						node[i] = node[i]->next;

						l.removeFirstSpace();

						l.removeChar('\r');

						if ( !l.empty() && l.left(1) != "/") {

							str[i] += l;

							if ( _isLineComplete(str[i], fileType, (id == -1) ? true : false) ) 

								break;

						}

					}

				}

				if ( id == -1 )

					id = 0;

				else

				{

					// first check for mismatch amount, one of the nodes will be empty

					if ( str[0].empty() && !str[1].empty() ) // mod file has more entries (these must be additions)

					{

						SDiffEntryAddition *entry = new SDiffEntryAddition;

						entry->iID = id;

						entry->sEntry = str[1];

						diffFile->m_lEntries.push_back(entry);

					}

					else if ( str[1].empty() && !str[0].empty() ) // mod file has less entries (must have removed some)

					{

						SDiffEntry *entry = new SDiffEntryRemoval;

						entry->iID = id;

						diffFile->m_lEntries.push_back(entry);

					}

					else // we have a line for both, we need to compare them

					{

						// we migth have multiple entries to add when changed

						if ( str[0].empty() || str[1].empty() ) continue;

						_compareLine(str[0], str[1], type, id, diffFile);						

					}

					++id;

				}

			}

			delete lines;

		}

		delete baseLines;

	}

	if ( diffFile->m_lEntries.empty() ) {

		delete diffFile;

		return NULL;

	}

	else {

		m_lFiles.push_back(diffFile);

		return diffFile;

	}

}

int CModDiff::_amountPosition(const Utils::String &fileType)

{

	return 2;

}

bool CModDiff::_isLineComplete(const Utils::String &line, const Utils::String &fileType, bool first)

{

	if ( first )

	{

		if ( line.countToken(";") > _amountPosition(fileType) ) return true;

		return false;

	}

	return true;

}

void CModDiff::_compareLine(const Utils::String &line1, const Utils::String &line2, int type, int id, SDiffFile *diffFile)

{

	int max1, max2;

	Utils::String *str1 = line1.tokenise(";", &max1);

	Utils::String *str2 = line2.tokenise(";", &max2);

	if ( !str1 || !str2 ) return;

	int max = ((max1 > max2) ? max2 : max1);

	for ( int i = 0; i < max; i++ )

	{

		if ( str1[i] == str2[i] ) continue;

		if ( str1[i].Compare(str2[i]) ) continue;

		if ( str1[i].empty() && str2[i].empty() ) continue;

		if ( str1[i].length() && str1[i][0] == '\0' && str2[i].length() && str2[i][0] == '\0' ) continue;

		SDiffEntryChange *diff = new SDiffEntryChange;

		diff->iID = id;

		diff->iPos = i;

		diff->sEntry = str2[i];

		diff->sFrom = str1[i];

		diffFile->m_lEntries.push_back(diff);

	}

}

void CModDiff::Clean()

{

	for ( CListNode<SDiffFile> *node = m_lFiles.Front(); node; node = node->next() )

	{

		node->Data()->m_lEntries.clear();

		node->DeleteData();

	}

	m_lFiles.clear();

}

bool CModDiff::WriteDiff(const Utils::String &file)

{

	if ( m_lFiles.empty() ) return false;

	Utils::CStringList lines;

	for ( CListNode<SDiffFile> *node = m_lFiles.Front(); node; node = node->next() )

	{

		lines.pushBack("$$" + node->Data()->sFile);

		for ( CListNode<SDiffEntry> *node2 = node->Data()->m_lEntries.Front(); node2; node2 = node2->next() )

		{

			switch(node2->Data()->iType)

			{

				case DIFFTYPE_ADDITION:

					lines.pushBack("+++:" + Utils::String::Number((long)node2->Data()->iID) + ":" + ((SDiffEntryAddition *)node2->Data())->sEntry);

					break;

				case DIFFTYPE_REMOVAL:

					lines.pushBack("---:" + Utils::String::Number((long)node2->Data()->iID));

					break;

				case DIFFTYPE_CHANGE:

					lines.pushBack("///:" + Utils::String::Number((long)node2->Data()->iID) + ":" + Utils::String::Number((long)((SDiffEntryChange *)node2->Data())->iPos) + ":" + ((SDiffEntryChange *)node2->Data())->sEntry);

					break;

			}

		}

	}

	CFileIO File(file);

	return File.writeFile(&lines);

}

bool CModDiff::ReadDiff(const Utils::String &file)

{

	Clean();

	CFileIO File(file);

	if ( !File.exists() ) return false;

	CyStringList *lines = File.ReadLinesStr();

	if ( lines )

	{

		SDiffFile *diffFile = NULL;

		for ( SStringList *str = lines->Head(); str; str = str->next )

		{

			if ( str->str.Left(2).Compare("$$") )

			{

				diffFile = new SDiffFile;

				m_lFiles.push_back(diffFile);

				diffFile->sFile = str->str.Right(-2).ToString();

			}

			else if ( diffFile )

			{

				if ( str->str.Left(4).Compare("+++:") )

				{

					SDiffEntryAddition *addition = new SDiffEntryAddition;

					addition->iID = str->str.GetToken(":", 2, 2).ToInt();

					addition->sEntry = str->str.GetToken(":", 3).ToString();

					diffFile->m_lEntries.push_back(addition);

				}

				else if ( str->str.Left(4).Compare("---:") )

				{

					SDiffEntryRemoval *entry = new SDiffEntryRemoval;

					entry->iID = str->str.GetToken(":", 2, 2).ToInt();

					diffFile->m_lEntries.push_back(entry);

				}

				else if ( str->str.Left(4).Compare("///:") )

				{

					SDiffEntryChange *entry = new SDiffEntryChange;

					entry->iID = str->str.GetToken(":", 2, 2).ToInt();

					entry->iPos = str->str.GetToken(":", 3, 3).ToInt();

					entry->sEntry = str->str.GetToken(":", 4).ToString();

					diffFile->m_lEntries.push_back(entry);

				}

			}

		}

		delete lines;

		return true;

	}

	return false;

}

bool CModDiff::ApplyMod(const Utils::String &mod)

{

	return m_fileSystem.addMod(mod);

}

bool CModDiff::ApplyDiff(const Utils::String &mod)

{

	if ( m_lFiles.empty() ) return false;

	this->ApplyMod(mod);

	bool ret = false;

	Utils::String addonDir = "";

	CCatFile cat;

	if ( !CCatFile::Opened(cat.open(mod, addonDir, CATREAD_CATDECRYPT, true)) )

		return false;

	for ( CListNode<SDiffFile> *node = m_lFiles.Front(); node; node = node->next() )

	{

		// extract the file from the game

		SDiffFile *f = node->Data();

		Utils::CStringList writeLines;

		int id;

		if ( _readGameFile(f->sFile, writeLines, &id) )

		{

			// now apply the diff

			this->_adjustFile(f->sFile, f, true);

			for ( CListNode<SDiffEntry> *eNode = f->m_lEntries.Front(); eNode; eNode = eNode->next() )

			{

				switch ( eNode->Data()->iType )

				{

					case DIFFTYPE_ADDITION:

						writeLines.pushBack(((SDiffEntryAddition *)eNode->Data())->sEntry);

						break;

					case DIFFTYPE_REMOVAL:

						writeLines.removeAt(eNode->Data()->iID);

						break;

					case DIFFTYPE_CHANGE:

						{

							auto strAt = writeLines.get(eNode->Data()->iID);

							if ( strAt )

								strAt->str = strAt->str.replaceToken(";", ((SDiffEntryChange *)eNode->Data())->iPos, ((SDiffEntryChange *)eNode->Data())->sEntry);

						}

						break;

				}

			}

			// add our comments and info

			writeLines.pushFront(Utils::String((long)id) + ";" + (long)writeLines.size() + ";");

			writeLines.pushFront("// Generated by ModDiff (SPK Version: " + Utils::String::FromFloat(GetLibraryVersion(), 2) + ")");

			// now write the file

			CFileIO WriteFile(m_sTempDir + "/" + CFileIO(f->sFile).filename());

			if ( WriteFile.writeFile(&writeLines) )

			{

				if ( cat.AppendFile(m_sTempDir + "/" + CFileIO(f->sFile).filename(), f->sFile) )

				{

					ret = true;

				}

				WriteFile.remove();

			}

		}

	}

	if ( ret )

		cat.WriteCatFile();

	return ret;

}

bool CModDiff::_readGameFile(const Utils::String &file, Utils::CStringList &writeLines, int *id)

{

	bool ret = false;

	Utils::String sTo = m_fileSystem.ExtractGameFile(file, m_sTempDir + "/" + CFileIO(file).filename());

	if ( !sTo.empty() ) {

		CFileIO File(sTo);

		Utils::CStringList *lines = File.readLinesStr();

		if ( lines )

		{

			int entries = -1;

			for(auto itr = lines->begin(); itr != lines->end(); itr++)

			{

				Utils::String l = (*itr)->str;

				l.removeFirstSpace();

				if ( l.empty() ) continue;

				if ( l.left(1) == "/" ) continue;

				if ( entries == -1 )

				{

					entries = l.token(":", 2).toInt();

					if ( id )

						(*id) = l.token(":", 1).toInt();

				}

				else

					writeLines.pushBack(l);

			}

			delete lines;

			ret = true;

		}

		File.close();

		File.remove();

	}

	return ret;

}

bool CModDiff::_validFile(const Utils::String &file)

{

	return CModDiff::CanBeDiffed(file);

}

bool CModDiff::CanBeDiffed(const Utils::String &file)

{

	Utils::String checkFile = file;

	checkFile = CFileIO(file).dir() + "/" + CFileIO(file).baseName();

	// all t files are the same format

	if ( checkFile.left(7).Compare("types/T") )

		return true;

	return false;

}