Subversion Repositories spk

Rev

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

Rev Author Line No. Line
1 cycrow 1 
#include "GameExe.h"
2 
#include "File_IO.h"
3 
#include "DirIO.h"
4 
 
5 
/**
6 
 * Add Exe
7 
 *
8 
 * Adds an exe name available
9 
 */
56 cycrow 10 
int CGameExe::AddExe(const Utils::String &exe)
1 cycrow 11 
{
12 
	// search if it already exists
57 cycrow 13 
	int iCount = this->_findExe(exe);
14 
	if ( iCount != -1 ) return iCount;
1 cycrow 15 
 
16 
	// not found, we need to add
17 
	SGameExe *sExe = new SGameExe;
18 
	sExe->sExe = exe;
19 
	sExe->iName = 0;
20 
	sExe->iFlags = 0;
21 
	sExe->iMaxPatch = 1;
22 
	sExe->iAddonTo = 0;
57 cycrow 23 
	sExe->iTextNum = 0;
1 cycrow 24 
 
25 
	m_lExe.push_back(sExe);
26 
 
27 
	return m_lExe.size() - 1;
28 
}
29 
 
30 
/**
31 
 * Find Exe
32 
 *
33 
 * Find an exe and return its position in the file
34 
 *
35 
 * Argument:	exe,	String - name of the exe file to find
36 
 */
57 cycrow 37 
int CGameExe::_findExe(const Utils::String &exe) const
1 cycrow 38 
{
39 
	int count = 0;
40 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
41 
	{
42 
		if ( node->Data()->sExe.Compare(exe) )
43 
			return count;
44 
		++count;
45 
	}
46 
 
47 
	return -1;
48 
}
49 
 
57 cycrow 50 
SGameExe *CGameExe::gameExe(const Utils::String &exe)
1 cycrow 51 
{
57 cycrow 52 
	int e = this->_findExe(exe);
1 cycrow 53 
	if ( e < 0 ) return NULL;
54 
	return m_lExe[e];
55 
}
56 
 
57 cycrow 57 
int CGameExe::_findVersion(int exe, int size, Utils::String *fVersion)
1 cycrow 58 
{
57 cycrow 59 
	if ( fVersion ) *fVersion = -1.0;
60 
	if ( exe < 0 ) return -1;
1 cycrow 61 
 
62 
	SGameExe *gameExe = m_lExe[exe];
57 cycrow 63 
	if ( !gameExe ) return -1;
1 cycrow 64 
 
65 
	int count = 0;
57 cycrow 66 
	for ( CListNode<SGameExeVersion> *node = gameExe->lVersions.Front(); node; node = node->next() ) {
67 
		for ( CListNode<int> *iNode = node->Data()->lSize.Front(); iNode; iNode = iNode->next() ) {
1 cycrow 68 
			int checkSize = *iNode->Data();
57 cycrow 69 
			if ( checkSize == size ) {
1 cycrow 70 
				*fVersion = node->Data()->fVersion;
71 
				return count;
72 
			}
73 
		}
74 
 
75 
		++count;
76 
	}
77 
 
78 
	return -1;
79 
}
80 
 
56 cycrow 81 
int CGameExe::FindVersion(const Utils::String &exe, int size, Utils::String *fVersion)
1 cycrow 82 
{
57 cycrow 83 
	int iExe = this->_findExe(exe);
1 cycrow 84 
	if ( iExe < 0 )
85 
		return -1;
86 
 
57 cycrow 87 
	int iVersion = this->_findVersion(iExe, size, fVersion);
1 cycrow 88 
	if ( iVersion < 0 )
89 
		return -2 - iExe;
90 
 
91 
	return -1;
92 
}
93 
 
56 cycrow 94 
Utils::String CGameExe::GetModKey(int game)
1 cycrow 95 
{
56 cycrow 96 
	if ( game < 0 )	return "";
1 cycrow 97 
	SGameExe *sExe = m_lExe[game];
56 cycrow 98 
	if ( !sExe ) return "";
1 cycrow 99 
 
100 
	return sExe->sModKey;
101 
}
102 
 
56 cycrow 103 
void CGameExe::ParseExe(const Utils::String &line)
1 cycrow 104 
{
105 
	// get the exe file
56 cycrow 106 
	Utils::String exe = line.token(":", 1);
107 
	int iTextNum = -1;
58 cycrow 108 
	if ( exe.isin("|") ) {
109 
		iTextNum = exe.token("|", 2);
110 
		exe = exe.token("|", 1);
56 cycrow 111 
	}
112 
 
1 cycrow 113 
	int iExe = this->AddExe(exe);
114 
 
115 
	SGameExe *sExe = m_lExe[iExe];
56 cycrow 116 
	sExe->iMaxPatch = line.token(":", 2);
117 
	sExe->iFlags = this->ParseFlags(line.token(":", 3));
118 
	sExe->sModKey = line.token(":", 4);
119 
	sExe->iTextNum = iTextNum;
1 cycrow 120 
 
121 
	// get the name
56 cycrow 122 
	Utils::String gameName = line.token(":", 5);
1 cycrow 123 
	this->_SetExeName(&sExe->sName, &sExe->iName, gameName);
124 
 
125 
	// get mydocs
56 cycrow 126 
	sExe->sMyDoc = line.token(":", 6);
1 cycrow 127 
 
128 
	// now get the versions
129 
	int pos = EXE_VERSIONPOS;
130 
	int namestart = EXE_VERSION_NAMESTART;
131 
	int sizestart = EXE_VERSION_SIZESTART;
132 
 
133 
	if ( sExe->iFlags & EXEFLAG_ADDON ) {
134 
		++pos;
135 
		++namestart;
136 
		++sizestart;
56 cycrow 137 
		sExe->sAddon = line.token(":", EXE_VERSIONPOS);
138 
		if ( sExe->sAddon.isin("!") ) {
57 cycrow 139 
			sExe->iAddonTo = this->_findExe(sExe->sAddon.token("!", 2));
56 cycrow 140 
			sExe->sAddon = sExe->sAddon.token("!", 1);
1 cycrow 141 
		}
142 
	}
143 
 
56 cycrow 144 
	int iVersions = line.token(":", pos);
1 cycrow 145 
	int i;
146 
 
147 
	for ( i = 0; i < iVersions; i++ )
148 
	{
149 
		SGameExeVersion *sGameVersion = new SGameExeVersion;
150 
		sGameVersion->iName = 0;
56 cycrow 151 
		sGameVersion->fVersion = line.token(":", namestart + (i * 2)).token(" ", 1);
1 cycrow 152 
 
56 cycrow 153 
		Utils::String sSize = line.token(":", sizestart + (i * 2));
1 cycrow 154 
		// multiple versions available, we need to split them up
56 cycrow 155 
		if ( sSize.isin("!") ) {
1 cycrow 156 
			int max = 0;
56 cycrow 157 
			Utils::String *sizes = sSize.tokenise("!", &max);
158 
			if ( sizes && max ) {
159 
				for ( int j = 0; j < max; j++ ) {
1 cycrow 160 
					int *size = new int;
56 cycrow 161 
					(*size) = sizes[j];
162 
					if ( *size ) sGameVersion->lSize.push_back(size);
1 cycrow 163 
				}
164 
				CLEANSPLIT(sizes, max);
165 
			}
166 
		}
56 cycrow 167 
		else {
1 cycrow 168 
			int *size = new int;
56 cycrow 169 
			(*size) = sSize;
170 
			if ( *size ) sGameVersion->lSize.push_back(size);
1 cycrow 171 
		}
172 
 
56 cycrow 173 
		if ( !sGameVersion->lSize.empty() )	{
1 cycrow 174 
			// finally, add the version names
56 cycrow 175 
			this->_SetExeName(&sGameVersion->sName, &sGameVersion->iName, line.token(":", namestart + (i * 2)));
1 cycrow 176 
			sExe->lVersions.push_back(sGameVersion);
177 
		}
178 
	}
179 
}
180 
 
56 cycrow 181 
int CGameExe::ParseFlags(const Utils::String &flags)
1 cycrow 182 
{
183 
	int max;
56 cycrow 184 
	Utils::String *sFlags = flags.tokenise("|", &max);
185 
	if ( !sFlags || !max ) return EXEFLAG_NONE;
1 cycrow 186 
 
187 
	int f = 0;
56 cycrow 188 
	for ( int i = 0; i < max; i++ ) {
189 
		Utils::String str = sFlags[i];
1 cycrow 190 
		if ( str.Compare("TC_TEXT") )
191 
			f |= EXEFLAG_TCTEXT;
192 
		else if ( str.Compare("NO_XOR") )
193 
			f |= EXEFLAG_NOXOR;
194 
		else if ( str.Compare("ADDON") )
195 
			f |= EXEFLAG_ADDON;
196 
		else if ( str.Compare("MYDOCLOG") )
197 
			f |= EXEFLAG_MYDOCLOG;
198 
		else if ( str.Compare("NOSAVESUBDIR") )
199 
			f |= EXEFLAG_NOSAVESUBDIR;
56 cycrow 200 
		else {
201 
			if ( str.isNumber() )
202 
				f |= (long)str;
1 cycrow 203 
		}
204 
	}
205 
 
206 
	CLEANSPLIT(sFlags, max);
207 
 
208 
	return f;
209 
}
210 
 
56 cycrow 211 
void CGameExe::_SetExeName(Utils::String *sName, int *iName, const Utils::String &n)
1 cycrow 212 
{
56 cycrow 213 
	Utils::String str = n;
214 
	if ( n.isin("!") )
1 cycrow 215 
	{
56 cycrow 216 
		Utils::String gameNum = str.token("!", 1);
217 
		str = str.token("!", 2);
1 cycrow 218 
 
56 cycrow 219 
		if ( gameNum.isNumber() )
220 
			*iName = gameNum;
1 cycrow 221 
		else
222 
			*sName = gameNum;
223 
	}
224 
 
56 cycrow 225 
	if ( str.isNumber() )
226 
		*iName = str;
1 cycrow 227 
	else
56 cycrow 228 
		*sName = str;
1 cycrow 229 
}
230 
 
231 
void CGameExe::Reset()
232 
{
233 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
234 
	{
235 
		for ( CListNode<SGameExeVersion> *vNode = node->Data()->lVersions.Front(); vNode; vNode = vNode->next() )
236 
			vNode->Data()->lSize.MemoryClear();
237 
		node->Data()->lVersions.MemoryClear();
238 
	}
239 
	m_lExe.MemoryClear();
240 
}
241 
 
56 cycrow 242 
bool CGameExe::ReadFile(const Utils::String &file)
1 cycrow 243 
{
56 cycrow 244 
	CFileIO File(file);
245 
	if ( !File.startRead() ) return false;
1 cycrow 246 
 
56 cycrow 247 
	while ( !File.atEnd() ) {
248 
		Utils::String line = File.readEndOfLine();
249 
		line.removeFirstSpace();
250 
		if ( line.empty() ) continue;
251 
		if ( line[0] == '/' ) continue;
1 cycrow 252 
		this->ParseExe(line);
253 
	}
56 cycrow 254 
	File.close();
1 cycrow 255 
	return true;
256 
}
257 
 
56 cycrow 258 
Utils::String CGameExe::GetGameRunExe(const Utils::String &dir)
1 cycrow 259 
{
260 
	CDirIO Dir(dir);
261 
	int count = 0;
262 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
263 
	{
264 
		SGameExe *exe = node->Data();
265 
		if ( Dir.Exists(exe->sExe) )
266 
			return dir + "/" + exe->sExe;
56 cycrow 267 
		if ( !exe->sAddon.empty() ) {
268 
			if ( Dir.TopDir().Compare(CyString(exe->sAddon)) )
1 cycrow 269 
				return this->GetGameDir(dir) + "/" + exe->sExe;
270 
		}
271 
		++count;
272 
	}
273 
 
56 cycrow 274 
	return "";
1 cycrow 275 
}
276 
 
56 cycrow 277 
Utils::String CGameExe::GetGameName(const Utils::String &gameExe)
1 cycrow 278 
{
279 
	int gameType = this->GetGameType(gameExe);
56 cycrow 280 
	Utils::String gameName = ExtractGameName(gameExe);
281 
	if ( gameName.empty() )	gameName = this->GetGameNameFromType(gameType);
282 
	if ( gameName.empty() )	return "";
1 cycrow 283 
 
284 
	// no version
56 cycrow 285 
	Utils::String fVersion;
286 
	Utils::String versionName;
1 cycrow 287 
 
56 cycrow 288 
	if ( this->GetGameVersionName(gameExe, &versionName) ) {
289 
		if ( !versionName.empty() )
1 cycrow 290 
			return gameName + " V" + versionName;
291 
		else
292 
			return gameName;
293 
	}
294 
 
56 cycrow 295 
	Utils::String sGameVersion = this->GetGameVersionFromType(gameType, this->GetGameVersion(gameExe, &fVersion), fVersion);
296 
	if ( sGameVersion.empty() )
1 cycrow 297 
	{
56 cycrow 298 
		if ( !fVersion.empty() )
1 cycrow 299 
			return gameName + " V" + fVersion;
300 
		else
301 
			return gameName;
302 
	}
303 
 
304 
	// return the name and the version
305 
	return gameName + " " + sGameVersion;
306 
}
307 
 
308 
 
56 cycrow 309 
int CGameExe::GetGameAddons(const Utils::String &dir, CyStringList &exes)
1 cycrow 310 
{
311 
	int count = 0;
312 
 
313 
	CDirIO Dir(dir);
314 
 
315 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
316 
	{
317 
		SGameExe *exe = node->Data();
318 
		if ( !(exe->iFlags & EXEFLAG_ADDON) )
319 
			continue;
320 
		if ( Dir.Exists(exe->sExe) ) {
321 
			if ( Dir.Exists(exe->sAddon) ) {
56 cycrow 322 
				exes.PushBack(CyString(exe->sExe), CyString(exe->sAddon));
1 cycrow 323 
				++count;
324 
			}
325 
		}
326 
	}
327 
 
328 
	return count;
329 
}
330 
 
56 cycrow 331 
Utils::String CGameExe::GetAddonDir(const Utils::String &dir)
1 cycrow 332 
{
333 
	int gameType = this->GetGameType(dir);
334 
	if ( gameType != -1 ) {
335 
		return m_lExe[gameType]->sAddon;
336 
	}
337 
 
338 
	return "";
339 
}
340 
 
56 cycrow 341 
Utils::String CGameExe::GetProperDir(const Utils::String &dir)
1 cycrow 342 
{
343 
	CDirIO Dir(dir);
344 
	int gameType = this->GetGameType(dir);
345 
	if ( gameType != -1 ) {
56 cycrow 346 
		if ( !m_lExe[gameType]->sAddon.empty() ) {
347 
			if ( CDirIO(dir).IsFile() ) return CFileIO(dir).GetDir().ToString() + "/" + m_lExe[gameType]->sAddon;
348 
			return Dir.Dir(m_lExe[gameType]->sAddon).ToString();
1 cycrow 349 
		}
350 
	}
351 
 
95 cycrow 352 
	return CDirIO(dir).IsFile() ? CFileIO(dir).GetDir().ToString() : dir;
1 cycrow 353 
}
354 
 
355 
int CGameExe::GetGameFlags(int game)
356 
{
357 
	if ( game == -1 )
358 
		return 0;
359 
 
360 
	SGameExe *exe = m_lExe[game];
361 
	if ( !exe )
362 
		return 0;
363 
 
364 
	return exe->iFlags;
365 
}
366 
 
367 
int CGameExe::GetMaxPatch(int game)
368 
{
369 
	if ( game == -1 )
370 
		return 0;
371 
 
372 
	SGameExe *exe = m_lExe[game];
373 
	if ( !exe )
374 
		return 0;
375 
 
376 
	return exe->iMaxPatch;
377 
}
378 
 
56 cycrow 379 
Utils::String CGameExe::GetGameNameFromType(int type)
1 cycrow 380 
{
56 cycrow 381 
	if ( type == -1 ) return "";
1 cycrow 382 
 
383 
	SGameExe *exe = m_lExe[type];
56 cycrow 384 
	if ( !exe ) return "";
1 cycrow 385 
 
386 
	return exe->sName;
387 
}
388 
 
56 cycrow 389 
Utils::String CGameExe::GetGameVersionFromType(int game, int gameVersion, const Utils::String &fGameVersion)
1 cycrow 390 
{
391 
	SGameExe *exe = m_lExe[game];
56 cycrow 392 
	if ( !exe ) return "";
1 cycrow 393 
 
394 
	SGameExeVersion *version = exe->lVersions[gameVersion];
395 
	if ( !version )
396 
	{
56 cycrow 397 
		if ( !fGameVersion.empty() ) return fGameVersion;
398 
		return "";
1 cycrow 399 
	}
400 
 
401 
	return version->sName;
402 
}
403 
 
56 cycrow 404 
Utils::String CGameExe::GetGameDir(const Utils::String &dir)
1 cycrow 405 
{
406 
	CDirIO Dir(dir);
407 
 
408 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
409 
	{
410 
		SGameExe *exe = node->Data();
411 
		if ( CDirIO(dir).IsFile() ) {
56 cycrow 412 
			if ( CFileIO(dir).filename().Compare(exe->sExe) )
413 
				return CFileIO(dir).GetDir().ToString();
1 cycrow 414 
		}
415 
		else {
56 cycrow 416 
			if ( Dir.Exists(exe->sExe) ) return dir;
1 cycrow 417 
			// check for addon dir
56 cycrow 418 
			if ( !exe->sAddon.empty() ) {
419 
				if ( exe->sAddon.Compare(Dir.TopDir().ToString()) )
420 
					return Dir.Back().ToString();
1 cycrow 421 
			}
422 
		}
423 
	}
424 
 
425 
	return dir;
426 
}
56 cycrow 427 
int CGameExe::GetGameType(const Utils::String &gameExe)
1 cycrow 428 
{
95 cycrow 429 
	CDirIO Dir (gameExe);
1 cycrow 430 
	int count = 0;
431 
 
432 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
433 
	{
434 
		SGameExe *exe = node->Data();
435 
		if ( CDirIO(gameExe).IsFile() ) {
56 cycrow 436 
			if ( CFileIO(gameExe).filename().Compare(exe->sExe) )
1 cycrow 437 
				return count;
438 
		}
439 
		else {
440 
			if ( Dir.Exists(exe->sExe) )
441 
				return count;
442 
			// check for addon dir
56 cycrow 443 
			if ( !exe->sAddon.empty() ) {
444 
				if ( exe->sAddon.Compare(Dir.TopDir().ToString()) )
1 cycrow 445 
					return count;
446 
			}
447 
		}
448 
		++count;
449 
	}
450 
 
451 
	return -1;
452 
}
453 
 
56 cycrow 454 
Utils::String CGameExe::ExtractGameName(const Utils::String &gameDir)
1 cycrow 455 
{
456 
	CDirIO Dir(gameDir);
457 
 
56 cycrow 458 
	Utils::String sText = this->_extractTextData(this->_readTextFile(gameDir), 1910, 1216);
459 
	if ( sText.empty() ) return "";
460 
	int end = sText.findPos("\\n");
461 
	if ( end >= 0 ) return sText.left(end);
1 cycrow 462 
 
56 cycrow 463 
	return "";
464 
}
465 
 
466 
Utils::String CGameExe::_textFileName(const Utils::String &sGameDir)
467 
{
468 
	CDirIO Dir(sGameDir);
469 
	if ( Dir.Exists("t") && Dir.Exists("t/0002.pck") ) return "t/0002.pck";
470 
	else if ( Dir.Exists("t") && Dir.Exists("t/440002.pck") ) return "t/440002.pck";
471 
	else if ( Dir.Exists("t") && Dir.Exists("t/0002-L044.pck") ) return "t/0002-L044.pck";
472 
	return "";
473 
}
474 
 
475 
Utils::String CGameExe::_readTextFile(const Utils::String &sGameDir)
476 
{
477 
	Utils::String textFileName = _textFileName(sGameDir);;
478 
	if ( !textFileName.empty() ) {
479 
		Utils::String sVersion;
480 
 
481 
		CDirIO Dir(sGameDir);
1 cycrow 482 
		CFileIO File(Dir.File(textFileName));
483 
		size_t fileSize;
56 cycrow 484 
		unsigned char *fileData = File.readAll(&fileSize);
485 
		if ( fileData && fileSize) {
1 cycrow 486 
			size_t newFileSize;
487 
			unsigned char *pckData = UnPCKData((unsigned char *)fileData, fileSize, &newFileSize);
56 cycrow 488 
			delete fileData;
489 
			pckData[newFileSize -1] = '\0';
490 
			Utils::String Data((char *)pckData);
491 
			delete pckData;
492 
			return Data;
493 
		}
494 
	}
1 cycrow 495 
 
56 cycrow 496 
	return "";
497 
}
1 cycrow 498 
 
56 cycrow 499 
Utils::String CGameExe::_extractTextData(const Utils::String &sData, long iPage, long iID)
500 
{
501 
	Utils::String sPage = Utils::String("<page id=\"") + iPage + "\"";
502 
	Utils::String sID = Utils::String("<t id=\"") + iID + "\">";
503 
 
504 
	int startpage = sData.findPos(sPage);
505 
	if ( startpage >= 0 ) {
506 
		int start = sData.findPos(sID, startpage);
507 
		if ( start >= 0 ) {
508 
			start += sID.length();
509 
			int end = sData.findPos("</t>", start);
510 
			return sData.mid(start, end);
1 cycrow 511 
		}
512 
	}
56 cycrow 513 
 
514 
	return "";
1 cycrow 515 
}
516 
 
56 cycrow 517 
bool CGameExe::GetGameVersionName(const Utils::String &sGameExe, Utils::String *versionName)
1 cycrow 518 
{
56 cycrow 519 
	int gameType = this->GetGameType(sGameExe);
1 cycrow 520 
 
521 
	if ( gameType == -1 )
522 
		return false;
523 
 
56 cycrow 524 
	Utils::String gameDir = sGameExe;
525 
	Utils::String gameExe = this->GetGameDir(sGameExe) + "/" + m_lExe[gameType]->sExe;
1 cycrow 526 
	int size = (int)CFileIO(gameExe).GetFilesize();
527 
 
56 cycrow 528 
	Utils::String fVersion;
57 cycrow 529 
	int version = this->_findVersion(gameType, size, &fVersion);
1 cycrow 530 
	// not matched version
531 
	// lets read the text file
532 
 
56 cycrow 533 
	if ( version != -1 ) {
1 cycrow 534 
		(*versionName) = this->GetGameVersionFromType(gameType, version, fVersion);
535 
		return true;
536 
	}
537 
 
56 cycrow 538 
	Utils::String sText = this->_extractTextData(this->_readTextFile(gameDir), 1910, 1216);
539 
	Utils::String sVersion = sText.between("Version ", ", ");
540 
	if ( sVersion.empty() ) sVersion = sText.between("ver=", "&amp");
1 cycrow 541 
 
56 cycrow 542 
	if ( !sVersion.empty() ) {
543 
		// lets match the version
544 
		(*versionName) = sVersion;
545 
		float fVersion = sVersion;
546 
		SGameExe *gameExe = m_lExe[gameType];
547 
		if ( gameExe )
1 cycrow 548 
		{
56 cycrow 549 
			int count = 0;
550 
			int lower = -1;
551 
			for ( CListNode<SGameExeVersion> *node = gameExe->lVersions.Front(); node; node = node->next() )
1 cycrow 552 
			{
56 cycrow 553 
				if ( (float)node->Data()->fVersion == fVersion )
1 cycrow 554 
				{
56 cycrow 555 
					(*versionName) = node->Data()->sName;
556 
					return true;
1 cycrow 557 
				}
56 cycrow 558 
				++count;
1 cycrow 559 
			}
560 
 
56 cycrow 561 
			version = lower;
562 
		}
1 cycrow 563 
	}
564 
 
565 
	return true;
566 
}
567 
 
56 cycrow 568 
int CGameExe::GetGameVersion(const Utils::String &sGameExe, Utils::String *a_fVersion)
1 cycrow 569 
{
56 cycrow 570 
	Utils::String gameExe = sGameExe;
571 
 
1 cycrow 572 
	int gameType = this->GetGameType(gameExe);
573 
 
574 
	if ( gameType == -1 )
575 
		return -1;
576 
 
56 cycrow 577 
	Utils::String gameDir = gameExe;
578 
	if ( !m_lExe[gameType]->sAddon.empty() )
579 
		gameExe = CDirIO(gameExe).Back().ToString() + "/" + m_lExe[gameType]->sExe;
1 cycrow 580 
	else
581 
		gameExe = gameExe + "/" + m_lExe[gameType]->sExe;
582 
	int size = (int)CFileIO(gameExe).GetFilesize();
583 
 
57 cycrow 584 
	int version = this->_findVersion(gameType, size, a_fVersion);
1 cycrow 585 
 
56 cycrow 586 
	Utils::String sText = this->_extractTextData(this->_readTextFile(gameDir), 1910, 10000);
587 
	Utils::String sVersion = sText.between("ver=", "&amp");
1 cycrow 588 
 
56 cycrow 589 
	if ( !sVersion.empty() )
590 
	{
591 
		// lets match the version
592 
		Utils::String fVersion = sVersion;
593 
		if ( a_fVersion ) *a_fVersion = fVersion;
594 
		SGameExe *gameExe = m_lExe[gameType];
595 
		if ( gameExe ) {
596 
			int count = 0;
597 
			int lower = -1;
598 
			for ( CListNode<SGameExeVersion> *node = gameExe->lVersions.Front(); node; node = node->next() )
1 cycrow 599 
			{
56 cycrow 600 
				if ( fVersion.compareVersion(node->Data()->fVersion) == COMPARE_OLDER )
601 
					lower = count;
602 
				if (  fVersion.compareVersion(node->Data()->fVersion) == COMPARE_SAME )
603 
					return count;
604 
				++count;
1 cycrow 605 
			}
606 
 
56 cycrow 607 
			version = lower;
608 
		}
1 cycrow 609 
	}
56 cycrow 610 
 
1 cycrow 611 
	return version;
612 
}
613 
 
614 
int CGameExe::ConvertGameType(int gametype, int *version)
615 
{
616 
	int count = 0, game = 0;
617 
 
618 
	switch ( gametype )
619 
	{
620 
		case 1:
621 
			*version = 0;
622 
			return 1;
623 
		case 2:
624 
			*version = 0;
625 
			return 2;
626 
		case 3:
627 
			*version = 1;
628 
			return 2;
629 
		case 4:
630 
			*version = 0;
631 
			return 3;
632 
		case 5:
633 
			*version = 1;
634 
			return 3;
635 
		case 6:
636 
			*version = 2;
637 
			return 3;
638 
	}
639 
 
640 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
641 
	{
642 
		++count;
643 
		++game;
644 
		SGameExe *exe = node->Data();
645 
 
646 
		// found the game type, the version is 0, which is any version
647 
		if ( count == gametype )
648 
		{
649 
			*version = 0;
650 
			return game;
651 
		}
652 
 
653 
		int v = 0;
654 
		for ( CListNode<SGameExeVersion> *vNode = exe->lVersions.Front(); vNode; vNode = vNode->next() )
655 
		{
656 
			++count;
657 
			++v;
658 
			if ( count == gametype )
659 
			{
660 
				*version = v;
661 
				return game;
662 
			}
663 
		}
664 
	}
665 
 
666 
	// not found ?? just set to all versions
667 
	*version = 0;
668 
	return 0;
669 
}