Subversion Repositories spk

Rev

Rev 223 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 cycrow 1 
 
2 
#include "ModDiff.h"
3 
#include "File_IO.h"
4 
#include "CatFile.h"
5 
 
197 cycrow 6 
CModDiff::CModDiff(const Utils::WString &dir, const Utils::WString &sAddon, int maxPatch) : m_pCatFile(NULL), m_sAddon(sAddon), m_sTempDir(L"."), m_iMaxPatch(maxPatch)
1 cycrow 7 
{
58 cycrow 8 
	m_bLoaded = this->LoadDirectory(dir);
1 cycrow 9 
}
10 
 
11 
CModDiff::~CModDiff(void)
12 
{
58 cycrow 13 
	delete m_pCatFile;
1 cycrow 14 
}
15 
 
197 cycrow 16 
bool CModDiff::LoadDirectory(const Utils::WString &dir)
1 cycrow 17 
{
18 
	m_sCurrentDir = dir;
101 cycrow 19 
	m_fileSystem.setAddon(m_sAddon);
58 cycrow 20 
	return m_fileSystem.LoadFilesystem(dir, m_iMaxPatch);
1 cycrow 21 
}
22 
 
224 cycrow 23 
bool CModDiff::startDiff(const Utils::WString &sModFile)
1 cycrow 24 
{
25 
	ClearError();
58 cycrow 26 
	if ( !CFileIO::Exists(sModFile) ) { m_iError = MDERR_FILENOTFOUND; return false; }
1 cycrow 27 
 
58 cycrow 28 
	delete m_pCatFile;
29 
	m_pCatFile = new CCatFile;
30 
 
125 cycrow 31 
	if ( m_pCatFile->open(sModFile, m_sAddon, CATREAD_CATDECRYPT, false) != CATERR_NONE ) {
58 cycrow 32 
		delete m_pCatFile;
33 
		m_pCatFile = NULL;
34 
		m_iError = MDERR_CANTOPENMOD;
35 
		return false;
36 
	}
37 
 
38 
	return true;
39 
}
40 
 
197 cycrow 41 
Utils::WString CModDiff::_extractFile(const Utils::WString &sFile, const Utils::WString &sTo)
58 cycrow 42 
{
181 cycrow 43 
	SInCatFile *c = m_pCatFile->findData(sFile);
197 cycrow 44 
	if ( !c ) c = m_pCatFile->findData(m_sAddon + L"/" + sFile);
45 
	if ( !c ) return m_fileSystem.extractGameFile(sFile, sTo);
181 cycrow 46 
	if (m_pCatFile->extractFile(c, sTo)) return sTo;
197 cycrow 47 
	return L"";
58 cycrow 48 
}
49 
 
197 cycrow 50 
bool CModDiff::doDiff(const Utils::WString &sModFile)
58 cycrow 51 
{
52 
	// find the file in the loaded cat
181 cycrow 53 
	SInCatFile *c = m_pCatFile->findData(sModFile);
197 cycrow 54 
	if ( !c ) c = m_pCatFile->findData(m_sAddon + L"/" + sModFile);
58 cycrow 55 
	if ( !c ) return false;
56 
 
197 cycrow 57 
	Utils::WString temp = m_sTempDir;
196 cycrow 58 
 
58 cycrow 59 
	// extract the matching file
197 cycrow 60 
	Utils::WString sToFile = CFileIO(temp + L"/" + CFileIO(c->sFile).filename()).fullFilename();
181 cycrow 61 
	if ( !m_pCatFile->extractFile(sModFile, sToFile) ) return false;
58 cycrow 62 
 
63 
	// create a diff
197 cycrow 64 
	Utils::WString to = m_fileSystem.extractGameFile(c->sFile, sToFile + L".compare");
58 cycrow 65 
	if ( !to.empty() ) {
124 cycrow 66 
		SDiffFile *diff = diffFile(to, sToFile, c->sFile);
58 cycrow 67 
		if ( diff ) {
68 
			this->_adjustFile(sModFile, diff, false);
69 
		}
70 
		CFileIO::Remove(to);
71 
	}
72 
 
73 
	CFileIO::Remove(sToFile);
74 
 
75 
	return true;
76 
}
77 
 
78 
 
79 
bool CModDiff::_adjustTShips(SDiffFile *pDiff, bool bReverse)
80 
{
81 
	// need to read TCockpits
197 cycrow 82 
	Utils::WString sTo = this->_extractFile(L"types/TCockpits.pck", L"TCockpits.xml");
58 cycrow 83 
	if ( sTo.empty() ) return false;
197 cycrow 84 
	CFileIO TCockpits(L"TCockpits.xml");
58 cycrow 85 
	if ( !TCockpits.exists() ) return false;
197 cycrow 86 
	std::vector<Utils::WString> lines;
173 cycrow 87 
	if (!TCockpits.readLines(lines))
88 
		return false;
58 cycrow 89 
 
90 
	// remove all the comments
173 cycrow 91 
	auto itr = lines.begin();
92 
	while(itr != lines.end())
93 
	{
197 cycrow 94 
		if ((*itr)[0] == L'/')
173 cycrow 95 
			itr = lines.erase(itr);
96 
		else
97 
			itr++;
58 cycrow 98 
	}
173 cycrow 99 
	lines.erase(lines.begin());
58 cycrow 100 
 
197 cycrow 101 
	std::map<Utils::WString, int> fileSet;
58 cycrow 102 
	int iPos = 0;
173 cycrow 103 
	for(itr = lines.begin(); itr != lines.end(); itr++)
197 cycrow 104 
		fileSet[itr->token(L";", -2)] = iPos++;
58 cycrow 105 
 
106 
	// now cycle through ships and adjust the cockpits
107 
	int iCount = -1;
108 
	for ( SDiffEntry *pEntry = pDiff->m_lEntries.First(); pEntry; pEntry = pDiff->m_lEntries.Next() ) {
109 
		switch (pEntry->iType) {
110 
			case DIFFTYPE_ADDITION:
111 
				{
112 
					SDiffEntryAddition *pAddition = static_cast<SDiffEntryAddition *>(pEntry);
113 
					if ( pAddition ) {
114 
						for ( int t = 0; t < 6; t++ ) {
197 cycrow 115 
							Utils::WString sE = pAddition->sEntry.token(L";", 32 + (t * 2));
173 cycrow 116 
							if ( !bReverse && sE.isNumber() )
117 
							{
58 cycrow 118 
								int iTurret = sE;
173 cycrow 119 
								if ( iTurret && static_cast<size_t>(iTurret) < lines.size())
120 
								{
197 cycrow 121 
									Utils::WString sCockpit = lines[iTurret];
122 
									pAddition->sEntry = pAddition->sEntry.replaceToken(L";", 32 + (t * 2), sCockpit.token(L";", -2) + ":" + static_cast<long>(iTurret));
58 cycrow 123 
								}
124 
							}
125 
							else if ( bReverse && !sE.isNumber() ) {
126 
								int iUnfound = 0;
197 cycrow 127 
								if ( sE.contains(L":") ) {
128 
									iUnfound = sE.token(L":", 2);
129 
									sE = sE.token(L":", 1);
58 cycrow 130 
								}
131 
								int iEntry = (fileSet.find(sE) == fileSet.end()) ? iUnfound : fileSet[sE];
197 cycrow 132 
								pAddition->sEntry = pAddition->sEntry.replaceToken(L";", 32 + (t * 2), static_cast<long>(iEntry));
58 cycrow 133 
							}
134 
						}
135 
					}
136 
				}
137 
				break;
138 
			case DIFFTYPE_CHANGE:
139 
				{
140 
					SDiffEntryChange *pChange = static_cast<SDiffEntryChange *>(pEntry);
141 
					if ( pChange->iPos >= 32 && pChange->iPos <= 42 && (pChange->iPos % 2) && pChange->sEntry.isNumber() ) {
197 cycrow 142 
						Utils::WString sCockpit = lines[pChange->sEntry.toInt()];
143 
						pChange->sEntry = sCockpit.token(L";", -2) + L":" + pChange->sEntry;
58 cycrow 144 
					}
145 
				}
146 
				break;
147 
		}
148 
	}
149 
 
150 
	return true;
151 
}
152 
 
196 cycrow 153 
int CModDiff::_specialType(const Utils::WString &sFile) const
58 cycrow 154 
{
196 cycrow 155 
	if ( sFile.Compare(L"TShips") ) return MERGETYPE_TSHIPS;
58 cycrow 156 
	return MERGETYPE_NONE;
157 
}
158 
 
197 cycrow 159 
void CModDiff::_adjustFile(const Utils::WString &sFile, SDiffFile *pDiff, bool bReverse)
58 cycrow 160 
{
161 
	// check if we need to adjust the file
162 
	CFileIO File(sFile);
163 
	int iType = _specialType(File.baseName());
164 
	if ( iType == MERGETYPE_NONE ) return;
165 
 
166 
	// read in the file data
167 
	switch(iType) {
168 
		case MERGETYPE_TSHIPS:
169 
			this->_adjustTShips(pDiff, bReverse);
170 
			break;
171 
	}
172 
}
173 
 
197 cycrow 174 
bool CModDiff::CreateDiff(const Utils::WString &modfile)
58 cycrow 175 
{
176 
	ClearError();
177 
 
1 cycrow 178 
	//check for valid parameters
197 cycrow 179 
	if ( !CFileIO::Exists(modfile) ) { m_iError = MDERR_FILENOTFOUND; return false; }
1 cycrow 180 
 
197 cycrow 181 
	Utils::WString addonDir = L"";
58 cycrow 182 
	int addonSize = addonDir.length() + 1;
1 cycrow 183 
 
184 
	// try and open the mod file
185 
	CCatFile cat;
125 cycrow 186 
	if ( cat.open(modfile, addonDir, CATREAD_DAT, false) != CATERR_NONE ) { m_iError = MDERR_CANTOPENMOD; return false; }
1 cycrow 187 
 
197 cycrow 188 
	Utils::WString temp = m_sTempDir;
196 cycrow 189 
 
1 cycrow 190 
	// we'll need to read in all the types/text files
125 cycrow 191 
	for (unsigned int i = 0; i < cat.GetNumFiles(); i++)
1 cycrow 192 
	{
193 
		SInCatFile *f = cat.GetFile(i);
197 cycrow 194 
		Utils::WString checkFile = f->sFile.findReplace(L"\\", L"/");
195 
		if ( (checkFile.left(6).Compare(L"types/") || checkFile.left(2).Compare(L"t/") || checkFile.left(6 + addonSize).Compare(addonDir + L"/types/") || checkFile.left(2 + addonSize).Compare(addonDir + L"/t/")) && _validFile(checkFile) )
1 cycrow 196 
		{
197 
			// extract the file to the temp dir
197 cycrow 198 
			Utils::WString toFile = CFileIO(temp + L"/" + CFileIO(f->sFile).filename()).fullFilename();
181 cycrow 199 
			if (cat.extractFile(f, toFile ))
1 cycrow 200 
			{
201 
				// now extract the matching file from the game dir
197 cycrow 202 
				if (!m_fileSystem.extractGameFile(f->sFile, toFile + L".compare").empty() )
1 cycrow 203 
				{
197 cycrow 204 
					diffFile(toFile + L".compare", toFile, f->sFile);
205 
					CFileIO::Remove(toFile + L".compare");
1 cycrow 206 
				}
207 
				// make sure we clear up afterwards
58 cycrow 208 
				CFileIO::Remove(toFile);
1 cycrow 209 
			}
210 
		}
211 
	}
212 
 
213 
	return true;
214 
}
215 
 
197 cycrow 216 
SDiffFile *CModDiff::diffFile(const Utils::WString &baseFile, const Utils::WString &modFile, const Utils::WString &fileType)
1 cycrow 217 
{
218 
	int type = 0;
219 
 
220 
	SDiffFile *diffFile = new SDiffFile;
221 
	diffFile->sFile = fileType;
222 
 
223 
	// read both files and compare them
224 
	CFileIO Base(baseFile);
223 cycrow 225 
	std::vector<Utils::WString> baseLines;
173 cycrow 226 
	if(Base.readLines(baseLines))
1 cycrow 227 
	{
228 
		CFileIO Mod(modFile);
223 cycrow 229 
		std::vector<Utils::WString> lines;
173 cycrow 230 
		if(Mod.readLines(lines))
1 cycrow 231 
		{
232 
			int id = -1;
223 cycrow 233 
			std::vector<Utils::WString>::iterator node[2];
173 cycrow 234 
			node[0] = baseLines.begin();
235 
			node[1] = lines.begin();
223 cycrow 236 
			std::vector<Utils::WString>::iterator endNode[2];
173 cycrow 237 
			endNode[0] = baseLines.end();
238 
			endNode[1] = lines.end();
1 cycrow 239 
 
223 cycrow 240 
			Utils::WString prev[2];
1 cycrow 241 
 
173 cycrow 242 
			while (node[0] != endNode[0] || node[1] != endNode[1])
1 cycrow 243 
			{
223 cycrow 244 
				Utils::WString str[2];
1 cycrow 245 
 
246 
				for ( int i = 0; i < 2; i++ )
247 
				{
173 cycrow 248 
					while (node[i] != endNode[i])
1 cycrow 249 
					{
223 cycrow 250 
						Utils::WString l = *node[i];
173 cycrow 251 
						node[i]++;
1 cycrow 252 
 
58 cycrow 253 
						l.removeFirstSpace();
254 
						l.removeChar('\r');
223 cycrow 255 
						if ( !l.empty() && l.left(1) != L"/") {
1 cycrow 256 
							str[i] += l;
58 cycrow 257 
							if ( _isLineComplete(str[i], fileType, (id == -1) ? true : false) )
1 cycrow 258 
								break;
259 
						}
260 
					}
261 
				}
262 
 
263 
				if ( id == -1 )
264 
					id = 0;
265 
				else
266 
				{
267 
					// first check for mismatch amount, one of the nodes will be empty
58 cycrow 268 
					if ( str[0].empty() && !str[1].empty() ) // mod file has more entries (these must be additions)
1 cycrow 269 
					{
270 
						SDiffEntryAddition *entry = new SDiffEntryAddition;
271 
						entry->iID = id;
223 cycrow 272 
						entry->sEntry = str[1];
1 cycrow 273 
						diffFile->m_lEntries.push_back(entry);
274 
					}
58 cycrow 275 
					else if ( str[1].empty() && !str[0].empty() ) // mod file has less entries (must have removed some)
1 cycrow 276 
					{
277 
						SDiffEntry *entry = new SDiffEntryRemoval;
278 
						entry->iID = id;
279 
						diffFile->m_lEntries.push_back(entry);
280 
					}
281 
					else // we have a line for both, we need to compare them
282 
					{
283 
						// we migth have multiple entries to add when changed
58 cycrow 284 
						if ( str[0].empty() || str[1].empty() ) continue;
285 
						_compareLine(str[0], str[1], type, id, diffFile);
1 cycrow 286 
					}
287 
 
288 
					++id;
289 
				}
290 
			}
291 
		}
292 
	}
293 
 
58 cycrow 294 
	if ( diffFile->m_lEntries.empty() ) {
1 cycrow 295 
		delete diffFile;
58 cycrow 296 
		return NULL;
297 
	}
298 
	else {
1 cycrow 299 
		m_lFiles.push_back(diffFile);
58 cycrow 300 
		return diffFile;
301 
	}
1 cycrow 302 
}
303 
 
197 cycrow 304 
int CModDiff::_amountPosition(const Utils::WString &fileType)
1 cycrow 305 
{
306 
	return 2;
307 
}
308 
 
197 cycrow 309 
bool CModDiff::_isLineComplete(const Utils::WString &line, const Utils::WString &fileType, bool first)
1 cycrow 310 
{
311 
	if ( first )
312 
	{
197 cycrow 313 
		if ( line.countToken(L";") > _amountPosition(fileType) ) return true;
1 cycrow 314 
		return false;
315 
	}
316 
 
317 
	return true;
318 
}
319 
 
197 cycrow 320 
void CModDiff::_compareLine(const Utils::WString &line1, const Utils::WString &line2, int type, int id, SDiffFile *diffFile)
1 cycrow 321 
{
197 cycrow 322 
	std::vector<Utils::WString> str1;
323 
	std::vector<Utils::WString> str2;
324 
	if (!line1.tokenise(L";", str1))
325 
		return;
326 
	if (!line2.tokenise(L";", str2))
327 
		return;
1 cycrow 328 
 
197 cycrow 329 
	size_t max = ((str1.size() > str2.size()) ? str2.size() : str1.size());
330 
	for (size_t i = 0; i < max; i++ )
1 cycrow 331 
	{
332 
		if ( str1[i] == str2[i] ) continue;
333 
		if ( str1[i].Compare(str2[i]) ) continue;
58 cycrow 334 
		if ( str1[i].empty() && str2[i].empty() ) continue;
335 
		if ( str1[i].length() && str1[i][0] == '\0' && str2[i].length() && str2[i][0] == '\0' ) continue;
1 cycrow 336 
		SDiffEntryChange *diff = new SDiffEntryChange;
337 
		diff->iID = id;
338 
		diff->iPos = i;
339 
		diff->sEntry = str2[i];
340 
		diff->sFrom = str1[i];
341 
		diffFile->m_lEntries.push_back(diff);
342 
	}
343 
}
344 
 
345 
void CModDiff::Clean()
346 
{
347 
	for ( CListNode<SDiffFile> *node = m_lFiles.Front(); node; node = node->next() )
348 
	{
349 
		node->Data()->m_lEntries.clear();
350 
		node->DeleteData();
351 
	}
352 
	m_lFiles.clear();
353 
}
354 
 
224 cycrow 355 
bool CModDiff::WriteDiff(const Utils::WString &file)
1 cycrow 356 
{
357 
	if ( m_lFiles.empty() ) return false;
358 
 
197 cycrow 359 
	Utils::WStringList lines;
1 cycrow 360 
 
361 
	for ( CListNode<SDiffFile> *node = m_lFiles.Front(); node; node = node->next() )
362 
	{
197 cycrow 363 
		lines.pushBack(L"$$" + node->Data()->sFile);
1 cycrow 364 
		for ( CListNode<SDiffEntry> *node2 = node->Data()->m_lEntries.Front(); node2; node2 = node2->next() )
365 
		{
366 
			switch(node2->Data()->iType)
367 
			{
368 
				case DIFFTYPE_ADDITION:
197 cycrow 369 
					lines.pushBack(L"+++:" + Utils::WString::Number((long)node2->Data()->iID) + L":" + ((SDiffEntryAddition *)node2->Data())->sEntry);
1 cycrow 370 
					break;
371 
				case DIFFTYPE_REMOVAL:
197 cycrow 372 
					lines.pushBack(L"---:" + Utils::WString::Number((long)node2->Data()->iID));
1 cycrow 373 
					break;
374 
				case DIFFTYPE_CHANGE:
197 cycrow 375 
					lines.pushBack(L"///:" + Utils::WString::Number((long)node2->Data()->iID) + L":" + Utils::WString::Number((long)((SDiffEntryChange *)node2->Data())->iPos) + L":" + ((SDiffEntryChange *)node2->Data())->sEntry);
1 cycrow 376 
					break;
377 
			}
378 
		}
379 
	}
380 
 
381 
 
382 
	CFileIO File(file);
160 cycrow 383 
	return File.writeFile(&lines);
1 cycrow 384 
}
385 
 
224 cycrow 386 
bool CModDiff::ReadDiff(const Utils::WString &file)
1 cycrow 387 
{
388 
	Clean();
389 
 
390 
	CFileIO File(file);
52 cycrow 391 
	if ( !File.exists() ) return false;
1 cycrow 392 
 
223 cycrow 393 
	std::vector<Utils::WString> lines;
173 cycrow 394 
	if(File.readLines(lines))
1 cycrow 395 
	{
396 
		SDiffFile *diffFile = NULL;
173 cycrow 397 
		for(auto itr = lines.begin(); itr != lines.end(); itr++)
1 cycrow 398 
		{
223 cycrow 399 
			if (itr->left(2).Compare(L"$$") )
1 cycrow 400 
			{
401 
				diffFile = new SDiffFile;
402 
				m_lFiles.push_back(diffFile);
223 cycrow 403 
				diffFile->sFile = itr->right(-2);
1 cycrow 404 
			}
405 
			else if ( diffFile )
406 
			{
223 cycrow 407 
				if ( itr->left(4).Compare(L"+++:") )
1 cycrow 408 
				{
409 
					SDiffEntryAddition *addition = new SDiffEntryAddition;
223 cycrow 410 
					addition->iID = itr->token(L":", 2).toInt();
411 
					addition->sEntry = itr->tokens(L":", 3);
1 cycrow 412 
					diffFile->m_lEntries.push_back(addition);
413 
				}
223 cycrow 414 
				else if ( itr->left(4).Compare(L"---:") )
1 cycrow 415 
				{
416 
					SDiffEntryRemoval *entry = new SDiffEntryRemoval;
223 cycrow 417 
					entry->iID = itr->token(L":", 2).toInt();
1 cycrow 418 
					diffFile->m_lEntries.push_back(entry);
419 
				}
223 cycrow 420 
				else if (itr->left(4).Compare(L"///:") )
1 cycrow 421 
				{
422 
					SDiffEntryChange *entry = new SDiffEntryChange;
223 cycrow 423 
					entry->iID = itr->token(L":", 2).toInt();
424 
					entry->iPos = itr->token(L":", 3).toInt();
425 
					entry->sEntry = itr->tokens(L":", 4);
1 cycrow 426 
					diffFile->m_lEntries.push_back(entry);
427 
				}
428 
			}
429 
		}
430 
 
431 
		return true;
432 
	}
433 
 
434 
	return false;
435 
}
436 
 
224 cycrow 437 
bool CModDiff::ApplyMod(const Utils::WString &mod)
1 cycrow 438 
{
58 cycrow 439 
	return m_fileSystem.addMod(mod);
1 cycrow 440 
}
441 
 
224 cycrow 442 
bool CModDiff::ApplyDiff(const Utils::WString &mod)
1 cycrow 443 
{
444 
	if ( m_lFiles.empty() ) return false;
445 
 
58 cycrow 446 
	this->ApplyMod(mod);
447 
 
1 cycrow 448 
	bool ret = false;
449 
 
197 cycrow 450 
	Utils::WString temp = m_sTempDir;
451 
	Utils::WString addonDir = L"";
1 cycrow 452 
 
453 
	CCatFile cat;
125 cycrow 454 
	if ( !CCatFile::Opened(cat.open(mod, addonDir, CATREAD_CATDECRYPT, true)) )
1 cycrow 455 
		return false;
456 
 
457 
	for ( CListNode<SDiffFile> *node = m_lFiles.Front(); node; node = node->next() )
458 
	{
459 
		// extract the file from the game
460 
		SDiffFile *f = node->Data();
461 
 
197 cycrow 462 
		Utils::WStringList writeLines;
1 cycrow 463 
		int id;
197 cycrow 464 
		if ( _readGameFile(f->sFile, writeLines, &id))
1 cycrow 465 
		{
466 
			// now apply the diff
58 cycrow 467 
			this->_adjustFile(f->sFile, f, true);
1 cycrow 468 
			for ( CListNode<SDiffEntry> *eNode = f->m_lEntries.Front(); eNode; eNode = eNode->next() )
469 
			{
470 
				switch ( eNode->Data()->iType )
471 
				{
472 
					case DIFFTYPE_ADDITION:
223 cycrow 473 
						writeLines.pushBack(((SDiffEntryAddition *)eNode->Data())->sEntry);
1 cycrow 474 
						break;
475 
					case DIFFTYPE_REMOVAL:
160 cycrow 476 
						writeLines.removeAt(eNode->Data()->iID);
1 cycrow 477 
						break;
478 
					case DIFFTYPE_CHANGE:
479 
						{
160 cycrow 480 
							auto strAt = writeLines.get(eNode->Data()->iID);
1 cycrow 481 
							if ( strAt )
197 cycrow 482 
								strAt->str = strAt->str.replaceToken(L";", ((SDiffEntryChange *)eNode->Data())->iPos, ((SDiffEntryChange *)eNode->Data())->sEntry);
1 cycrow 483 
						}
484 
						break;
485 
				}
486 
			}
487 
 
488 
			// add our comments and info
197 cycrow 489 
			writeLines.pushFront(Utils::WString((long)id) + L";" + (long)writeLines.size() + L";");
490 
			writeLines.pushFront(L"// Generated by ModDiff (SPK Version: " + Utils::WString::FromFloat(GetLibraryVersion(), 2) + L")");
1 cycrow 491 
 
492 
			// now write the file
196 cycrow 493 
			CFileIO WriteFile(temp + L"/" + CFileIO(f->sFile).filename());
160 cycrow 494 
			if ( WriteFile.writeFile(&writeLines) )
1 cycrow 495 
			{
197 cycrow 496 
				if ( cat.appendFile(m_sTempDir + L"/" + CFileIO(f->sFile).filename(), f->sFile) )
1 cycrow 497 
					ret = true;
58 cycrow 498 
				WriteFile.remove();
1 cycrow 499 
			}
500 
		}
501 
	}
502 
 
503 
	if ( ret )
504 
		cat.WriteCatFile();
505 
 
506 
	return ret;
507 
}
508 
 
197 cycrow 509 
bool CModDiff::_readGameFile(const Utils::WString &file, Utils::WStringList &writeLines, int *id)
1 cycrow 510 
{
511 
	bool ret = false;
512 
 
197 cycrow 513 
	Utils::WString sTo = m_fileSystem.extractGameFile(file, m_sTempDir + L"/" + CFileIO(file).filename());
58 cycrow 514 
	if ( !sTo.empty() ) {
515 
		CFileIO File(sTo);
1 cycrow 516 
 
197 cycrow 517 
		std::vector<Utils::WString> lines;
518 
		if(File.readLines(lines))
1 cycrow 519 
		{
520 
			int entries = -1;
197 cycrow 521 
			for(auto itr = lines.begin(); itr != lines.end(); itr++)
1 cycrow 522 
			{
197 cycrow 523 
				Utils::WString l = *itr;
160 cycrow 524 
				l.removeFirstSpace();
525 
				if ( l.empty() ) continue;
197 cycrow 526 
				if ( l.left(1) == L"/" ) continue;
1 cycrow 527 
 
528 
				if ( entries == -1 )
529 
				{
197 cycrow 530 
					entries = l.token(L":", 2).toInt();
1 cycrow 531 
					if ( id )
197 cycrow 532 
						(*id) = l.token(L":", 1).toInt();
1 cycrow 533 
				}
534 
				else
160 cycrow 535 
					writeLines.pushBack(l);
1 cycrow 536 
			}
537 
			ret = true;
538 
		}
58 cycrow 539 
		File.close();
52 cycrow 540 
		File.remove();
1 cycrow 541 
	}
542 
 
543 
	return ret;
544 
}
545 
 
546 
 
197 cycrow 547 
bool CModDiff::_validFile(const Utils::WString &file)
1 cycrow 548 
{
549 
	return CModDiff::CanBeDiffed(file);
550 
}
551 
 
197 cycrow 552 
bool CModDiff::CanBeDiffed(const Utils::WString &file)
1 cycrow 553 
{
197 cycrow 554 
	Utils::WString checkFile = file;
196 cycrow 555 
	checkFile = CFileIO(file).dir() + L"/" + CFileIO(file).baseName();
1 cycrow 556 
 
557 
	// all t files are the same format
196 cycrow 558 
	if ( checkFile.left(7).Compare(L"types/T") )
1 cycrow 559 
		return true;
560 
 
561 
	return false;
35 cycrow 562 
}