Subversion Repositories spk

Rev

Rev 1 | 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 
 */
10 
int CGameExe::AddExe(CyString exe)
11 
{
12 
	// search if it already exists
13 
	int count = 0;
14 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
15 
	{
16 
		if ( node->Data()->sExe.Compare(exe) )
17 
			return count;
18 
		--count;
19 
	}
20 
 
21 
	// not found, we need to add
22 
	SGameExe *sExe = new SGameExe;
23 
	sExe->sExe = exe;
24 
	sExe->iName = 0;
25 
	sExe->iFlags = 0;
26 
	sExe->iMaxPatch = 1;
27 
	sExe->iAddonTo = 0;
28 
 
29 
	m_lExe.push_back(sExe);
30 
 
31 
	return m_lExe.size() - 1;
32 
}
33 
 
34 
/**
35 
 * Find Exe
36 
 *
37 
 * Find an exe and return its position in the file
38 
 *
39 
 * Argument:	exe,	String - name of the exe file to find
40 
 */
41 
int CGameExe::FindExe(CyString exe)
42 
{
43 
	int count = 0;
44 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
45 
	{
46 
		if ( node->Data()->sExe.Compare(exe) )
47 
			return count;
48 
		++count;
49 
	}
50 
 
51 
	return -1;
52 
}
53 
 
54 
SGameExe *CGameExe::GetGameExe(CyString exe)
55 
{
56 
	int e = FindExe(exe);
57 
	if ( e < 0 ) return NULL;
58 
	return m_lExe[e];
59 
}
60 
 
61 
int CGameExe::FindVersion(int exe, int size, CyString *fVersion)
62 
{
63 
	if ( fVersion )
64 
		*fVersion = -1.0;
65 
 
66 
	if ( exe < 0 )
67 
		return -1;
68 
 
69 
	SGameExe *gameExe = m_lExe[exe];
70 
	if ( !gameExe )
71 
		return -1;
72 
 
73 
	int count = 0;
74 
	for ( CListNode<SGameExeVersion> *node = gameExe->lVersions.Front(); node; node = node->next() )
75 
	{
76 
		// check each size of a watch
77 
		for ( CListNode<int> *iNode = node->Data()->lSize.Front(); iNode; iNode = iNode->next() )
78 
		{
79 
			int checkSize = *iNode->Data();
80 
			if ( checkSize == size )
81 
			{
82 
				*fVersion = node->Data()->fVersion;
83 
				return count;
84 
			}
85 
		}
86 
 
87 
		++count;
88 
	}
89 
 
90 
	return -1;
91 
}
92 
 
93 
int CGameExe::FindVersion(CyString exe, int size, CyString *fVersion)
94 
{
95 
	int iExe = this->FindExe(exe);
96 
	if ( iExe < 0 )
97 
		return -1;
98 
 
99 
	int iVersion = this->FindVersion(iExe, size, fVersion);
100 
	if ( iVersion < 0 )
101 
		return -2 - iExe;
102 
 
103 
	return -1;
104 
}
105 
 
106 
CyString CGameExe::GetModKey(int game)
107 
{
108 
	if ( game < 0 )
109 
		return NullString;
110 
	SGameExe *sExe = m_lExe[game];
111 
	if ( !sExe )
112 
		return NullString;
113 
 
114 
	return sExe->sModKey;
115 
}
116 
 
117 
void CGameExe::ParseExe(CyString line)
118 
{
119 
	// get the exe file
120 
	CyString exe = line.GetToken(":", 1, 1);
121 
	int iExe = this->AddExe(exe);
122 
 
123 
	SGameExe *sExe = m_lExe[iExe];
124 
	sExe->iMaxPatch = line.GetToken(":", 2, 2).ToInt();
125 
	sExe->iFlags = this->ParseFlags(line.GetToken(":", 3, 3));
126 
	sExe->sModKey = line.GetToken(":", 4, 4);
127 
 
128 
	// get the name
129 
	CyString gameName = line.GetToken(":", 5, 5);
130 
	this->_SetExeName(&sExe->sName, &sExe->iName, gameName);
131 
 
132 
	// get mydocs
133 
	sExe->sMyDoc = line.GetToken(":", 6, 6);
134 
 
135 
	// now get the versions
136 
	int pos = EXE_VERSIONPOS;
137 
	int namestart = EXE_VERSION_NAMESTART;
138 
	int sizestart = EXE_VERSION_SIZESTART;
139 
 
140 
	if ( sExe->iFlags & EXEFLAG_ADDON ) {
141 
		++pos;
142 
		++namestart;
143 
		++sizestart;
144 
		sExe->sAddon = line.GetToken(":", EXE_VERSIONPOS, EXE_VERSIONPOS);
145 
		if ( sExe->sAddon.IsIn("!") ) {
146 
			sExe->iAddonTo = this->FindExe(sExe->sAddon.GetToken("!", 2, 2));
147 
			sExe->sAddon = sExe->sAddon.GetToken("!", 1, 1);
148 
		}
149 
	}
150 
 
151 
	int iVersions = line.GetToken(":", pos, pos).ToInt();
152 
	int i;
153 
 
154 
	for ( i = 0; i < iVersions; i++ )
155 
	{
156 
		SGameExeVersion *sGameVersion = new SGameExeVersion;
157 
		sGameVersion->iName = 0;
158 
		sGameVersion->fVersion = line.GetToken(":", namestart + (i * 2), namestart + (i * 2)).GetToken(" ", 1, 1).ToFloat();
159 
 
160 
		CyString sSize = line.GetToken(":", sizestart + (i * 2), sizestart + (i * 2));
161 
		// multiple versions available, we need to split them up
162 
		if ( sSize.IsIn("!") )
163 
		{
164 
			int max = 0;
165 
			CyString *sizes = sSize.SplitToken('!', &max);
166 
			if ( sizes && max )
167 
			{
168 
				for ( int j = 0; j < max; j++ )
169 
				{
170 
					int *size = new int;
171 
					(*size) = sizes[j].ToInt();
172 
					if ( *size )
173 
						sGameVersion->lSize.push_back(size);
174 
				}
175 
 
176 
				CLEANSPLIT(sizes, max);
177 
			}
178 
		}
179 
		else
180 
		{
181 
			int *size = new int;
182 
			(*size) = sSize.ToInt();
183 
			if ( *size )
184 
				sGameVersion->lSize.push_back(size);
185 
		}
186 
 
187 
		if ( !sGameVersion->lSize.empty() )
188 
		{
189 
			// finally, add the version names
190 
			this->_SetExeName(&sGameVersion->sName, &sGameVersion->iName, line.GetToken(":", namestart + (i * 2), namestart + (i * 2)));
191 
 
192 
			sExe->lVersions.push_back(sGameVersion);
193 
		}
194 
	}
195 
}
196 
 
197 
int CGameExe::ParseFlags(CyString flags)
198 
{
199 
	int max;
200 
	CyString *sFlags = flags.SplitToken("|", &max);
201 
	if ( !sFlags || !max )
202 
		return EXEFLAG_NONE;
203 
 
204 
	int f = 0;
205 
	for ( int i = 0; i < max; i++ )
206 
	{
207 
		CyString str = sFlags[i];
208 
		if ( str.Compare("TC_TEXT") )
209 
			f |= EXEFLAG_TCTEXT;
210 
		else if ( str.Compare("NO_XOR") )
211 
			f |= EXEFLAG_NOXOR;
212 
		else if ( str.Compare("ADDON") )
213 
			f |= EXEFLAG_ADDON;
214 
		else if ( str.Compare("MYDOCLOG") )
215 
			f |= EXEFLAG_MYDOCLOG;
216 
		else if ( str.Compare("NOSAVESUBDIR") )
217 
			f |= EXEFLAG_NOSAVESUBDIR;
218 
		else
219 
		{
220 
			if ( str.IsNumber() )
221 
				f |= str.ToInt();
222 
		}
223 
	}
224 
 
225 
	CLEANSPLIT(sFlags, max);
226 
 
227 
	return f;
228 
}
229 
 
230 
void CGameExe::_SetExeName(CyString *sName, int *iName, CyString n)
231 
{
232 
	if ( n.IsIn("!") )
233 
	{
234 
		CyString gameNum = n.GetToken("!", 1, 1);
235 
		n = n.GetToken("!", 2, 2);
236 
 
237 
		if ( gameNum.IsNumber() )
238 
			*iName = gameNum.ToInt();
239 
		else
240 
			*sName = gameNum;
241 
	}
242 
 
243 
	if ( n.IsNumber() )
244 
		*iName = n.ToInt();
245 
	else
246 
		*sName = n;
247 
}
248 
 
249 
void CGameExe::Reset()
250 
{
251 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
252 
	{
253 
		for ( CListNode<SGameExeVersion> *vNode = node->Data()->lVersions.Front(); vNode; vNode = vNode->next() )
254 
			vNode->Data()->lSize.MemoryClear();
255 
		node->Data()->lVersions.MemoryClear();
256 
	}
257 
	m_lExe.MemoryClear();
258 
}
259 
 
260 
bool CGameExe::ReadFile(CyString file)
261 
{
262 
	FILE *id = fopen(file.c_str(), "rb");
263 
	if ( !id )
264 
		return false;
265 
 
266 
	CyString line;
267 
	while ( !feof(id) )
268 
	{
269 
		line.GetEndOfLine(id, NULL, false);
270 
		if ( line.Empty() )
271 
			continue;
272 
		CyString lineNoSpace = line;
273 
		lineNoSpace.RemoveFirstSpace();
274 
		if ( lineNoSpace.Empty() )
275 
			continue;
276 
 
277 
		if ( lineNoSpace.Left(1) == "/" )
278 
			continue;
279 
 
280 
		this->ParseExe(line);
281 
	}
282 
	fclose(id);
283 
 
284 
	return true;
285 
}
286 
 
287 
CyString CGameExe::GetGameRunExe(CyString dir)
288 
{
289 
	CDirIO Dir(dir);
290 
	int count = 0;
291 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
292 
	{
293 
		SGameExe *exe = node->Data();
294 
		if ( Dir.Exists(exe->sExe) )
295 
			return dir + "/" + exe->sExe;
296 
		if ( !exe->sAddon.Empty() ) {
297 
			if ( Dir.TopDir().Compare(exe->sAddon) )
298 
				return this->GetGameDir(dir) + "/" + exe->sExe;
299 
		}
300 
		++count;
301 
	}
302 
 
303 
	return NullString;
304 
}
305 
 
306 
CyString CGameExe::GetGameName(CyString gameExe)
307 
{
308 
	int gameType = this->GetGameType(gameExe);
309 
	CyString gameName = ExtractGameName(gameExe);
310 
	if ( gameName.Empty() )
311 
		gameName = this->GetGameNameFromType(gameType);
312 
	if ( gameName.Empty() )
313 
		return NullString;
314 
 
315 
	// no version
316 
	CyString fVersion;
317 
 
318 
	CyString versionName;
319 
	if ( this->GetGameVersionName(gameExe, &versionName) )
320 
	{
321 
		if ( !versionName.Empty() )
322 
			return gameName + " V" + versionName;
323 
		else
324 
			return gameName;
325 
	}
326 
 
327 
	CyString sGameVersion = this->GetGameVersionFromType(gameType, this->GetGameVersion(gameExe, &fVersion), fVersion);
328 
	if ( sGameVersion.Empty() )
329 
	{
330 
		if ( !fVersion.Empty() )
331 
			return gameName + " V" + fVersion;
332 
		else
333 
			return gameName;
334 
	}
335 
 
336 
	// return the name and the version
337 
	return gameName + " " + sGameVersion;
338 
}
339 
 
340 
 
341 
int CGameExe::GetGameAddons(CyString dir, CyStringList &exes)
342 
{
343 
	int count = 0;
344 
 
345 
	CDirIO Dir(dir);
346 
 
347 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
348 
	{
349 
		SGameExe *exe = node->Data();
350 
		if ( !(exe->iFlags & EXEFLAG_ADDON) )
351 
			continue;
352 
		if ( Dir.Exists(exe->sExe) ) {
353 
			if ( Dir.Exists(exe->sAddon) ) {
354 
				exes.PushBack(exe->sExe, exe->sAddon);
355 
				++count;
356 
			}
357 
		}
358 
	}
359 
 
360 
	return count;
361 
}
362 
 
363 
CyString CGameExe::GetAddonDir(CyString dir)
364 
{
365 
	int gameType = this->GetGameType(dir);
366 
	if ( gameType != -1 ) {
367 
		return m_lExe[gameType]->sAddon;
368 
	}
369 
 
370 
	return "";
371 
}
372 
 
373 
CyString CGameExe::GetProperDir(CyString dir)
374 
{
375 
	CDirIO Dir(dir);
376 
	int gameType = this->GetGameType(dir);
377 
	if ( gameType != -1 ) {
378 
		if ( !m_lExe[gameType]->sAddon.Empty() ) {
379 
			if ( CDirIO(dir).IsFile() )
380 
				return CFileIO(dir).GetDir() + "/" + m_lExe[gameType]->sAddon;
381 
			return Dir.Dir(m_lExe[gameType]->sAddon);
382 
		}
383 
	}
384 
 
385 
	return dir;
386 
}
387 
 
388 
int CGameExe::GetGameFlags(int game)
389 
{
390 
	if ( game == -1 )
391 
		return 0;
392 
 
393 
	SGameExe *exe = m_lExe[game];
394 
	if ( !exe )
395 
		return 0;
396 
 
397 
	return exe->iFlags;
398 
}
399 
 
400 
int CGameExe::GetMaxPatch(int game)
401 
{
402 
	if ( game == -1 )
403 
		return 0;
404 
 
405 
	SGameExe *exe = m_lExe[game];
406 
	if ( !exe )
407 
		return 0;
408 
 
409 
	return exe->iMaxPatch;
410 
}
411 
 
412 
CyString CGameExe::GetGameNameFromType(int type)
413 
{
414 
	if ( type == -1 )
415 
		return NullString;
416 
 
417 
	SGameExe *exe = m_lExe[type];
418 
	if ( !exe )
419 
		return NullString;
420 
 
421 
	return exe->sName;
422 
}
423 
 
424 
CyString CGameExe::GetGameVersionFromType(int game, int gameVersion, CyString fGameVersion)
425 
{
426 
	SGameExe *exe = m_lExe[game];
427 
	if ( !exe )
428 
		return NullString;
429 
 
430 
	SGameExeVersion *version = exe->lVersions[gameVersion];
431 
	if ( !version )
432 
	{
433 
		if ( !fGameVersion.Empty() )
434 
			return fGameVersion;
435 
		return NullString;
436 
	}
437 
 
438 
	return version->sName;
439 
}
440 
 
441 
CyString CGameExe::GetGameDir(CyString dir)
442 
{
443 
	CDirIO Dir(dir);
444 
 
445 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
446 
	{
447 
		SGameExe *exe = node->Data();
448 
		if ( CDirIO(dir).IsFile() ) {
449 
			if ( CFileIO(dir).GetFilename().Compare(exe->sExe) )
450 
				return CFileIO(dir).GetDir();
451 
		}
452 
		else {
453 
			if ( Dir.Exists(exe->sExe) )
454 
				return dir;
455 
			// check for addon dir
456 
			if ( !exe->sAddon.Empty() ) {
457 
				CyString top = Dir.TopDir();
458 
				if ( exe->sAddon.Compare(Dir.TopDir()) )
459 
					return Dir.Back();
460 
			}
461 
		}
462 
	}
463 
 
464 
	return dir;
465 
}
466 
int CGameExe::GetGameType(CyString gameExe)
467 
{
468 
	CDirIO Dir(gameExe);
469 
	int count = 0;
470 
 
471 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
472 
	{
473 
		SGameExe *exe = node->Data();
474 
		if ( CDirIO(gameExe).IsFile() ) {
475 
			if ( CFileIO(gameExe).GetFilename().Compare(exe->sExe) )
476 
				return count;
477 
		}
478 
		else {
479 
			if ( Dir.Exists(exe->sExe) )
480 
				return count;
481 
			// check for addon dir
482 
			if ( !exe->sAddon.Empty() ) {
483 
				CyString top = Dir.TopDir();
484 
				if ( exe->sAddon.Compare(Dir.TopDir()) )
485 
					return count;
486 
			}
487 
		}
488 
		++count;
489 
	}
490 
 
491 
	return -1;
492 
}
493 
 
494 
CyString CGameExe::ExtractGameName(CyString gameDir)
495 
{
496 
	CDirIO Dir(gameDir);
497 
 
498 
	CyString textFileName;
499 
	if ( Dir.Exists("t") && Dir.Exists("t/0002.pck") )
500 
		textFileName = "t/0002.pck";
501 
	else if ( Dir.Exists("t") && Dir.Exists("t/440002.pck") )
502 
		textFileName = "t/440002.pck";
503 
	else if ( Dir.Exists("t") && Dir.Exists("t/0002-L044.pck") )
504 
		textFileName = "t/0002-L044.pck";
505 
 
506 
	CyString sName;
507 
	if ( !textFileName.Empty() )
508 
	{
509 
		CFileIO File(Dir.File(textFileName));
510 
 
511 
		size_t fileSize;
512 
		char *fileData = File.ReadToData(&fileSize);
513 
 
514 
		if ( fileData && fileSize)
515 
		{
516 
			size_t newFileSize;
517 
			unsigned char *pckData = UnPCKData((unsigned char *)fileData, fileSize, &newFileSize);
518 
 
519 
			if ( pckData )
520 
			{
521 
				if ( newFileSize )
522 
				{
523 
					pckData[newFileSize -1] = '\0';
524 
					CyString data((char *)pckData);
525 
 
526 
					int startpage = data.FindPos("<page id=\"1910\"");
527 
					if ( startpage >= 0 )
528 
					{
529 
						int start = data.FindPos("<t id=\"1216\">", startpage);
530 
						if ( start >= 0 )
531 
						{
532 
							start += 14;
533 
							int end = data.FindPos("</t>", start);
534 
							end++;
535 
							CyString text = data.Mid(start, end - start);
536 
							end = text.FindPos("\\n");
537 
							if ( end >= 0 )
538 
								sName = text.Left(end);
539 
						}
540 
					}
541 
				}
542 
				delete pckData;
543 
			}
544 
		}
545 
	}
546 
	return sName;
547 
}
548 
 
549 
bool CGameExe::GetGameVersionName(CyString gameExe, CyString *versionName)
550 
{
551 
	int gameType = this->GetGameType(gameExe);
552 
 
553 
	if ( gameType == -1 )
554 
		return false;
555 
 
556 
	CyString gameDir = gameExe;
557 
	gameExe = this->GetGameDir(gameExe) + "/" + m_lExe[gameType]->sExe;
558 
	int size = (int)CFileIO(gameExe).GetFilesize();
559 
 
560 
	CyString fVersion;
561 
	int version = this->FindVersion(gameType, size, &fVersion);
562 
	// not matched version
563 
	// lets read the text file
564 
 
565 
	if ( version != -1 )
566 
	{
567 
		(*versionName) = this->GetGameVersionFromType(gameType, version, fVersion);
568 
		return true;
569 
	}
570 
 
571 
 
572 
	CDirIO Dir(gameDir);
573 
	CyString textFileName;
574 
	if ( Dir.Exists("t") && Dir.Exists("t/0002.pck") )
575 
		textFileName = "t/0002.pck";
576 
	else if ( Dir.Exists("t") && Dir.Exists("t/440002.pck") )
577 
		textFileName = "t/440002.pck";
578 
	else if ( Dir.Exists("t") && Dir.Exists("t/0002-L044.pck") )
579 
		textFileName = "t/0002-L044.pck";
580 
 
581 
	if ( !textFileName.Empty() )
582 
	{
583 
		CyString sVersion;
584 
		CFileIO File(Dir.File(textFileName));
585 
 
586 
		size_t fileSize;
587 
		char *fileData = File.ReadToData(&fileSize);
588 
 
589 
		if ( fileData && fileSize)
590 
		{
591 
			size_t newFileSize;
592 
			unsigned char *pckData = UnPCKData((unsigned char *)fileData, fileSize, &newFileSize);
593 
 
594 
			if ( pckData )
595 
			{
596 
				if ( newFileSize )
597 
				{
598 
					pckData[newFileSize -1] = '\0';
599 
					CyString data((char *)pckData);
600 
 
601 
					int startpage = data.FindPos("<page id=\"1910\"");
602 
					if ( startpage >= 0 )
603 
					{
604 
						int start = data.FindPos("<t id=\"1216\">", startpage);
605 
						if ( start >= 0 )
606 
						{
607 
							start += 15;
608 
							int end = data.FindPos("</t>", start);
609 
							end++;
610 
							CyString text = data.Mid(start, end - start);
611 
							int pos = text.FindPos("Version ");
612 
							if ( pos >= 0 )
613 
							{
614 
								pos += 9;
615 
								end = text.FindPos(", ", pos);
616 
								if ( end >= 0 )
617 
									sVersion = text.Mid(pos, (end + 1) - pos);
618 
							}
619 
						}
620 
						if ( sVersion.Empty() )
621 
						{
622 
							int start = data.FindPos("<t id=\"1216\">", startpage);
623 
							if ( start >= 0 )
624 
							{
625 
								start += 15;
626 
								int end = data.FindPos("</t>", start);
627 
								end++;
628 
								CyString text = data.Mid(start, end - start);
629 
								int pos = text.FindPos("ver=");
630 
								if ( pos >= 0 )
631 
								{
632 
									pos += 5;
633 
									end = text.FindPos("&amp", pos);
634 
									if ( end >= 0 )
635 
										sVersion = text.Mid(pos, (end + 1) - pos);
636 
								}
637 
							}
638 
						}
639 
					}
640 
				}
641 
				delete pckData;
642 
			}
643 
		}
644 
		if ( !sVersion.Empty() )
645 
		{
646 
			// lets match the version
647 
			(*versionName) = sVersion;
648 
			float fVersion = sVersion.ToFloat();
649 
			SGameExe *gameExe = m_lExe[gameType];
650 
			if ( gameExe )
651 
			{
652 
				int count = 0;
653 
				int lower = -1;
654 
				for ( CListNode<SGameExeVersion> *node = gameExe->lVersions.Front(); node; node = node->next() )
655 
				{
656 
					if ( node->Data()->fVersion == fVersion )
657 
					{
658 
						(*versionName) = node->Data()->sName;
659 
						return true;
660 
					}
661 
					++count;
662 
				}
663 
 
664 
				version = lower;
665 
			}
666 
		}
667 
	}
668 
 
669 
	return true;
670 
}
671 
 
672 
int CGameExe::GetGameVersion(CyString gameExe, CyString *a_fVersion)
673 
{
674 
	int gameType = this->GetGameType(gameExe);
675 
 
676 
	if ( gameType == -1 )
677 
		return -1;
678 
 
679 
	CyString gameDir = gameExe;
680 
	if ( !m_lExe[gameType]->sAddon.Empty() )
681 
		gameExe = CDirIO(gameExe).Back() + "/" + m_lExe[gameType]->sExe;
682 
	else
683 
		gameExe = gameExe + "/" + m_lExe[gameType]->sExe;
684 
	int size = (int)CFileIO(gameExe).GetFilesize();
685 
 
686 
	int version = this->FindVersion(gameType, size, a_fVersion);
687 
	// not matched version
688 
	// lets read the text file
689 
	if ( version == -1 )
690 
	{
691 
		CDirIO Dir(gameDir);
692 
		CyString textFileName;
693 
		if ( Dir.Exists("t") && Dir.Exists("t/0002.pck") )
694 
			textFileName = "t/0002.pck";
695 
		else if ( Dir.Exists("t") && Dir.Exists("t/440002.pck") )
696 
			textFileName = "t/440002.pck";
697 
		else if ( Dir.Exists("t") && Dir.Exists("t/0002-L044.pck") )
698 
			textFileName = "t/0002-L044.pck";
699 
 
700 
		if ( !textFileName.Empty() )
701 
		{
702 
			CyString sVersion;
703 
			CFileIO File(Dir.File(textFileName));
704 
 
705 
			size_t fileSize;
706 
			char *fileData = File.ReadToData(&fileSize);
707 
 
708 
			if ( fileData && fileSize)
709 
			{
710 
				size_t newFileSize;
711 
				unsigned char *pckData = UnPCKData((unsigned char *)fileData, fileSize, &newFileSize);
712 
 
713 
				if ( pckData )
714 
				{
715 
					if ( newFileSize )
716 
					{
717 
						pckData[newFileSize -1] = '\0';
718 
						CyString data((char *)pckData);
719 
						int start = data.FindPos("<t id=\"10000\">");
720 
						if ( start >= 0 )
721 
						{
722 
							start += 15;
723 
							int end = data.FindPos("</t>", start);
724 
							end++;
725 
							CyString text = data.Mid(start, end - start);
726 
							int pos = text.FindPos("ver=");
727 
							if ( pos >= 0 )
728 
							{
729 
								pos += 5;
730 
								end = text.FindPos("&amp", pos);
731 
								if ( end >= 0 )
732 
									sVersion = text.Mid(pos, (end + 1) - pos);
733 
							}
734 
						}
735 
					}
736 
					delete pckData;
737 
				}
738 
			}
739 
			if ( !sVersion.Empty() )
740 
			{
741 
				// lets match the version
742 
				CyString fVersion = sVersion;
743 
				if ( a_fVersion )
744 
					*a_fVersion = fVersion;
745 
				SGameExe *gameExe = m_lExe[gameType];
746 
				if ( gameExe )
747 
				{
748 
					int count = 0;
749 
					int lower = -1;
750 
					for ( CListNode<SGameExeVersion> *node = gameExe->lVersions.Front(); node; node = node->next() )
751 
					{
752 
						if ( fVersion.CompareVersion(node->Data()->fVersion) == COMPARE_OLDER )
753 
							lower = count;
754 
						if (  fVersion.CompareVersion(node->Data()->fVersion) == COMPARE_SAME )
755 
							return count;
756 
						++count;
757 
					}
758 
 
759 
					version = lower;
760 
				}
761 
			}
762 
		}
763 
	}
764 
	return version;
765 
}
766 
 
767 
int CGameExe::ConvertGameType(int gametype, int *version)
768 
{
769 
	int count = 0, game = 0;
770 
 
771 
	switch ( gametype )
772 
	{
773 
		case 1:
774 
			*version = 0;
775 
			return 1;
776 
		case 2:
777 
			*version = 0;
778 
			return 2;
779 
		case 3:
780 
			*version = 1;
781 
			return 2;
782 
		case 4:
783 
			*version = 0;
784 
			return 3;
785 
		case 5:
786 
			*version = 1;
787 
			return 3;
788 
		case 6:
789 
			*version = 2;
790 
			return 3;
791 
	}
792 
 
793 
	for ( CListNode<SGameExe> *node = m_lExe.Front(); node; node = node->next() )
794 
	{
795 
		++count;
796 
		++game;
797 
		SGameExe *exe = node->Data();
798 
 
799 
		// found the game type, the version is 0, which is any version
800 
		if ( count == gametype )
801 
		{
802 
			*version = 0;
803 
			return game;
804 
		}
805 
 
806 
		int v = 0;
807 
		for ( CListNode<SGameExeVersion> *vNode = exe->lVersions.Front(); vNode; vNode = vNode->next() )
808 
		{
809 
			++count;
810 
			++v;
811 
			if ( count == gametype )
812 
			{
813 
				*version = v;
814 
				return game;
815 
			}
816 
		}
817 
	}
818 
 
819 
	// not found ?? just set to all versions
820 
	*version = 0;
821 
	return 0;
822 
}