Subversion Repositories spk

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 cycrow 1 
#include "XspFile.h"
2 
#include "File_IO.h"
3 
#include "Packages.h"
4 
#include "CatFile.h"
5 
 
6 
CXspFile::CXspFile () : CBaseFile()
7 
{
8 
	SetDefaults ();
9 
 
10 
	m_iType = TYPE_XSP;
11 
}
12 
 
13 
void CXspFile::Delete ()
14 
{
15 
	CBaseFile::Delete();
16 
	m_pSceneFile = m_pCockpitFile = NULL;
17 
 
18 
	// delete lists
19 
	m_lMissileMasks.MemoryClear();
20 
	m_lWeaponMasks.MemoryClear();
21 
 
22 
	m_lMissileMasks.destroy();
23 
	m_lWeaponMasks.destroy();
24 
 
25 
	for ( CListNode<SCockpit> *n = m_lCockpit.Front(); n; n = n->next() )
26 
		n->Data()->lWeaponMask.MemoryClear();
27 
	m_lCockpit.MemoryClear();
28 
	m_lCockpit.destroy();
29 
	m_lCutData.Clear();
30 
	m_lBodies.Clear();
31 
}
32 
 
33 
void CXspFile::SetDefaults ()
34 
{
35 
	CBaseFile::SetDefaults ();
36 
 
37 
	m_pSceneFile = m_pCockpitFile = NULL;
38 
	m_bLanguageText = m_bExistingShip = false;
39 
	m_iOrgDesc = 0;
40 
 
41 
	m_iShipyard = SHIPYARD_NONE;
42 
}
43 
 
44 
void CXspFile::AddText ( int id, CyString name, CyString desc )
45 
{
46 
	// first check if theres an existing id
47 
	SText *newtext = NULL;
48 
	for ( SText *t = m_lText.First(); t; t = m_lText.Next() )
49 
	{
50 
		if ( t->iId == id )
51 
		{
52 
			newtext = t;
53 
			break;
54 
		}
55 
	}
56 
 
57 
	if ( !newtext )
58 
	{
59 
		newtext = new SText;
60 
		newtext->iId = id;
61 
		m_lText.push_back ( newtext );
62 
	}
63 
 
64 
	newtext->sName = name;
65 
	newtext->sDesc = desc;
66 
 
67 
	m_bChanged = true;
68 
}
69 
 
70 
void CXspFile::RemoveText(int id)
71 
{
72 
	for ( SText *t = m_lText.First(); t; t = m_lText.Next() )
73 
	{
74 
		if ( t->iId == id )
75 
		{
76 
			m_bChanged = true;
77 
			m_lText.RemoveCurrent();
78 
			return;
79 
		}
80 
	}
81 
}
82 
 
83 
void CXspFile::AddDummy ( CyString section, CyString data )
84 
{
85 
	SDummy *d = new SDummy;
86 
	d->sData = data;
87 
	d->sSection = section;
88 
 
89 
	if ( d->sData.Right (1) != ";" )
90 
		d->sData += ";";
91 
 
92 
	m_lDummy.push_back ( d );
93 
 
94 
	m_bChanged = true;
95 
}
96 
 
97 
void CXspFile::AddComponent ( CyString section, CyString section2, CyString data )
98 
{
99 
	SComponent *c = new SComponent;
100 
	c->sData = data;
101 
	c->sSection = section;
102 
	c->sSection2 = section2;
103 
 
104 
	if ( c->sData.Right (1) != ";" )
105 
		c->sData += ";";
106 
 
107 
	m_lComponent.push_back ( c );
108 
 
109 
	m_bChanged = true;
110 
}
111 
 
112 
void CXspFile::AddWeaponMask ( int game, int mask )
113 
{
114 
	// first check if we have one for the game
115 
	SWeaponMask *m = NULL;
116 
	for ( CListNode<SWeaponMask> *node = m_lWeaponMasks.Front(); node; node = node->next() )
117 
	{
118 
		if ( node->Data()->iGame == game )
119 
		{
120 
			m = node->Data();
121 
			break;
122 
		}
123 
	}
124 
 
125 
	// not found, create one
126 
	if ( !m )
127 
	{
128 
		m = new SWeaponMask;
129 
		m_lWeaponMasks.push_back(m);
130 
		m->iGame = game;
131 
	}
132 
 
133 
	m->iMask = mask;
134 
	m_bChanged = true;
135 
}
136 
void CXspFile::AddMissileMask ( int game, int mask )
137 
{
138 
	// first check if we have one for the game
139 
	SWeaponMask *m = NULL;
140 
	for ( CListNode<SWeaponMask> *node = m_lMissileMasks.Front(); node; node = node->next() )
141 
	{
142 
		if ( node->Data()->iGame == game )
143 
		{
144 
			m = node->Data();
145 
			break;
146 
		}
147 
	}
148 
 
149 
	// not found, create one
150 
	if ( !m )
151 
	{
152 
		m = new SWeaponMask;
153 
		m_lMissileMasks.push_back(m);
154 
		m->iGame = game;
155 
	}
156 
 
157 
	m->iMask = mask;
158 
	m_bChanged = true;
159 
}
160 
 
161 
bool CXspFile::IsValid ()
162 
{
163 
	if ( m_sName.Empty() )
164 
		return false;
165 
	if ( m_sAuthor.Empty() )
166 
		return false;
167 
 
168 
	return true;
169 
}
170 
 
14 cycrow 171 
Utils::String CXspFile::CreateValuesLine() const
1 cycrow 172 
{
14 cycrow 173 
	Utils::String values = CBaseFile::CreateValuesLine ();
1 cycrow 174 
 
14 cycrow 175 
	values += "Data: " + m_sData + "\n";
176 
	values += "ID: " + m_sID + "\n";
1 cycrow 177 
 
178 
	if ( m_bLanguageText )
179 
		values += "LanguageText\n";
180 
	if ( m_bExistingShip )
181 
		values += "ExistingShip\n";
14 cycrow 182 
	values += Utils::String("OrgDesc: ") + (long)m_iOrgDesc + "\n";
183 
	values += Utils::String("Shipyard: ") + (long)m_iShipyard + "\n";
1 cycrow 184 
 
14 cycrow 185 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() ) {
186 
		SCockpit *cockpit = node->Data();
187 
		values += Utils::String("CockpitNew: ") + (long)cockpit->lWeaponMask.size();
188 
		for ( CListNode<SWeaponMask> *wNode = cockpit->lWeaponMask.Front(); wNode; wNode = wNode->next() ) {
1 cycrow 189 
			values += ":";
14 cycrow 190 
			values += (long)wNode->Data()->iGame;
1 cycrow 191 
			values += ":";
14 cycrow 192 
			values += (long)wNode->Data()->iMask;
1 cycrow 193 
		}
194 
		values += " ";
14 cycrow 195 
		values += cockpit->sCockpit.ToString() + "\n";
1 cycrow 196 
	}
197 
 
14 cycrow 198 
	for ( CListNode<SText> *tNode = m_lText.Front(); tNode; tNode = tNode->next() )
199 
		values += Utils::String("Text: ") + (long)tNode->Data()->iId + "|" + tNode->Data()->sName.FindReplace("|", "<::PiPe::>").ToString() + "|" + tNode->Data()->sDesc.ToString() + "\n";
1 cycrow 200 
 
14 cycrow 201 
	for ( CListNode<SComponent> *cNode = m_lComponent.Front(); cNode; cNode = cNode->next() )
202 
		values += Utils::String("Component: ") + cNode->Data()->sData.FindReplace("|", "<::PiPe::>").ToString() + "|" + cNode->Data()->sSection.FindReplace("|", "<::PiPe::>").ToString() + "|" + cNode->Data()->sSection2.ToString() + "\n";
1 cycrow 203 
 
14 cycrow 204 
	for ( CListNode<SDummy> *dNode = m_lDummy.Front(); dNode; dNode = dNode->next() )
205 
		values += Utils::String("Dummy: ") + dNode->Data()->sData.FindReplace("|", "<::PiPe::>").ToString() + "|" + dNode->Data()->sSection.ToString() + "\n";
1 cycrow 206 
 
14 cycrow 207 
	for ( CListNode<SWeaponMask> *wNode = m_lWeaponMasks.Front(); wNode; wNode = wNode->next() )
208 
		values += Utils::String("WeaponMask: ") + (long)wNode->Data()->iGame + " " + (long)wNode->Data()->iMask + "\n";
209 
	for ( CListNode<SWeaponMask> *mNode = m_lMissileMasks.Front(); mNode; mNode = mNode->next() )
210 
		values += Utils::String("MissileMask: ") + (long)mNode->Data()->iGame + " " + (long)mNode->Data()->iMask + "\n";
1 cycrow 211 
	for ( SStringList *cut = m_lCutData.Head(); cut; cut = cut->next )
14 cycrow 212 
		values += Utils::String("CutData: ") + cut->str.ToString() + "\n";
1 cycrow 213 
	for ( SStringList *body = m_lBodies.Head(); body; body = body->next )
14 cycrow 214 
		values += Utils::String("Bodies: ") + body->str.ToString() + "\n";
1 cycrow 215 
	for ( SStringList *ani = m_lAnimations.Head(); ani; ani = ani->next )
14 cycrow 216 
		values += Utils::String("Animations: ") + ani->str.ToString() + "\n";
1 cycrow 217 
 
218 
	return values;
219 
}
220 
 
14 cycrow 221 
bool CXspFile::ParseValueLine(const Utils::String &sLine)
1 cycrow 222 
{
14 cycrow 223 
	Utils::String first = sLine.token(":", 1);
224 
	Utils::String rest  = sLine.tokens(":", 2).removeFirstSpace();
1 cycrow 225 
 
14 cycrow 226 
	if ( first.Compare("Data") )
1 cycrow 227 
		m_sData = rest;
14 cycrow 228 
	else if ( first.Compare("ID") )
1 cycrow 229 
		m_sID = rest;
14 cycrow 230 
	else if ( sLine.Compare("LanguageText") )
1 cycrow 231 
		m_bLanguageText = true;
14 cycrow 232 
	else if ( sLine.Compare("ExistingShip") )
1 cycrow 233 
		m_bExistingShip = true;
14 cycrow 234 
	else if ( first.Compare("OrgDesc") || first.Compare("OriginalDesc") )
235 
		m_iOrgDesc = rest;
236 
	else if ( first.Compare("Shipyard") )
237 
		m_iShipyard = rest;
238 
	else if ( first.Compare("CutData") )
1 cycrow 239 
		this->AddCutData(rest);
14 cycrow 240 
	else if ( first.Compare("Bodies") )
1 cycrow 241 
		this->AddBodies(rest);
14 cycrow 242 
	else if ( first.Compare("Animations") )
1 cycrow 243 
		this->AddAnimation(rest);
14 cycrow 244 
	else if ( first.Compare("Cockpit") )
1 cycrow 245 
		this->AddCockpit(rest, 0);
14 cycrow 246 
	else if ( first.Compare("CockpitNew") )
1 cycrow 247 
	{
14 cycrow 248 
		Utils::String cockpit = rest.tokens(" ", 2);
249 
		Utils::String sMasks = rest.token(" ", 1);
1 cycrow 250 
		this->AddCockpit(cockpit, 0, -1);
14 cycrow 251 
		int num = sMasks.token(":", 1);
1 cycrow 252 
		for ( int i = 0; i < num; i++ )
253 
		{
14 cycrow 254 
			int mask = sMasks.token(":", ((i + 1) * 2) + 1);
255 
			int game = sMasks.token(":", ((i + 1) * 2));
1 cycrow 256 
			this->AddCockpit(cockpit, game, mask);
257 
		}
258 
	}
259 
	else if ( first == "Web" )
260 
		m_sWebSite = rest;
261 
	else if ( first.Compare("WeaponMask") )
14 cycrow 262 
		this->AddWeaponMask(rest.token(" ", 1), rest.token(" ", 2));
1 cycrow 263 
	else if ( first.Compare("MissileMask") )
14 cycrow 264 
		this->AddMissileMask(rest.token(" ", 1), rest.token(" ", 2));
1 cycrow 265 
	else if ( first == "Text" )
266 
	{
267 
		SText *text = new SText;
14 cycrow 268 
		text->iId = rest.token("|", 1);
269 
		text->sName = rest.token("|", 2);
270 
		text->sName = text->sName.FindReplace("<::PiPe::>", "|");
271 
		text->sDesc = rest.tokens( "|", 3);
1 cycrow 272 
		m_lText.push_back ( text );
273 
	}
274 
	else if ( first == "Component" )
275 
	{
276 
		SComponent *c = new SComponent;
14 cycrow 277 
		c->sData = rest.token("|", 1);
1 cycrow 278 
		c->sData = c->sData.FindReplace ("<::PiPe::>", "|");
14 cycrow 279 
		c->sSection = rest.token("|", 2);
1 cycrow 280 
		c->sSection = c->sSection.FindReplace ("<::PiPe::>", "|");
14 cycrow 281 
		c->sSection2 = rest.tokens("|", 3);
1 cycrow 282 
		m_lComponent.push_back ( c );
283 
	}
284 
	else if ( first == "Dummy" )
285 
	{
286 
		SDummy *d = new SDummy;
14 cycrow 287 
		d->sData = rest.token("|", 1);
1 cycrow 288 
		d->sData = d->sData.FindReplace ("<::PiPe::>", "|");
14 cycrow 289 
		d->sSection = rest.tokens( "|", 2);
1 cycrow 290 
		m_lDummy.push_back ( d );
291 
	}
292 
	else if ( first == "Comment" )
14 cycrow 293 
		m_sDescription = rest.findReplace("<newline>", "<br>");
1 cycrow 294 
	else
14 cycrow 295 
		return CBaseFile::ParseValueLine(sLine);
1 cycrow 296 
 
297 
	return true;
298 
}
299 
 
300 
CyString CXspFile::GetShipName(int lang)
301 
{
302 
	CyString name;
303 
	if ( (m_bLanguageText) && (lang) )
304 
	{
305 
		for ( SText *text = m_lText.First(); text; text = m_lText.Next() )
306 
		{
307 
			if ( text->iId == lang )
308 
			{
309 
				name = text->sName;
310 
				break;
311 
			}
312 
		}
313 
	}
314 
 
315 
	if ( name.Empty() )
316 
		name = GetLanguageName(lang);
317 
 
318 
	return name;
319 
}
320 
 
321 
bool CXspFile::ConvertOld(CyString file)
322 
{
323 
	// open the file
324 
	FILE *id = fopen(file.c_str(), "rb");
325 
	if ( !id )
326 
		return false;
327 
 
328 
	// read to memory
329 
	fseek(id, 0, SEEK_END);
330 
	size_t size = ftell(id);
331 
	fseek(id, 0, SEEK_SET);
332 
	unsigned char *data = new unsigned char[size + 1];
333 
	fread(data, sizeof(unsigned char), size, id);
334 
	data[size] = '\0';
335 
	fclose(id);
336 
 
337 
	// uncompress the file
338 
	size_t len;
339 
	unsigned char *compr = LZMADecode_C ( data, size, &len, NULL );
340 
 
341 
	delete data;
342 
 
343 
	if ( !compr )
344 
		return false;
345 
 
346 
	this->Delete();
347 
	this->SetDefaults();
348 
 
349 
	// now read the data line by line
350 
	size_t pos = 0;
351 
	size_t start = 0;
352 
	int packageVersion = 0;
353 
	while ( pos < len )
354 
	{
355 
		while ( compr[pos++] != '\n' && pos < len );
356 
 
357 
		compr[pos - 1] = '\0';
358 
		CyString line = (char *)(compr + start);
359 
		start = pos;
360 
		if ( line.Empty() )
361 
			continue;
362 
		CyString first = line.GetToken(":", 1, 1);
363 
		CyString rest = line.GetToken(":", 2);
364 
		rest = rest.RemoveFirstSpace();
365 
 
366 
		// now check each line
367 
		if ( first.Compare("Packager") )
368 
			packageVersion = rest.ToInt();
369 
		else if ( first.Compare("Shipyard") )
370 
		{
371 
			int max;
372 
			CyString *strs = rest.SplitToken(";", &max);
373 
			if ( strs && max )
374 
			{
375 
				int cur = 1;
376 
				for ( int i = 0; i < max; i++, cur *= 2 )
377 
				{
378 
					if ( strs[i] == "1" )
379 
						this->AddShipyard(cur);
380 
				}
381 
			}
382 
			CLEANSPLIT(strs, max)
383 
		}
384 
		else if ( first.Compare("ScreenShot") )
385 
		{
386 
			int size = rest.GetToken(" ", 1, 1).ToInt();
387 
			CyString ext = rest.GetToken(" ", 2, 2);
388 
 
14 cycrow 389 
			C_File *newFile = this->AddFile(CyString(m_sID) + "_" + CyString::Number(this->CountFiles(FILETYPE_SCREEN) + 1) + "." + ext, "", FILETYPE_SCREEN);
1 cycrow 390 
			newFile->ReadFromData((char *)(compr + pos), size);
391 
 
392 
			start += (size + 1);
393 
		}
394 
		else if ( first.Compare("SceneFile") )
395 
		{
396 
			CyString file = rest.GetToken(" ", 3);
397 
			m_pSceneFile = this->AddFile(CFileIO(file).GetFilename(), CFileIO(file).GetDir(), FILETYPE_SHIPSCENE);
398 
			m_pSceneFile->SetCreationTime(rest.GetToken(" ", 1, 1).ToLong());
399 
			m_pSceneFile->ReadFromData((char *)(compr + pos), rest.GetToken(" ", 2, 2).ToInt());
400 
 
401 
			start += m_pSceneFile->GetDataSize();
402 
		}
403 
		else if ( first.Compare("CockpitFile") )
404 
		{
405 
			CyString file = rest.GetToken(" ", 3);
406 
			m_pCockpitFile = this->AddFile(CFileIO(file).GetFilename(), CFileIO(file).GetDir(), FILETYPE_COCKPITSCENE);
407 
			m_pCockpitFile->SetCreationTime(rest.GetToken(" ", 1, 1).ToLong());
408 
			m_pCockpitFile->ReadFromData((char *)(compr + pos), rest.GetToken(" ", 2, 2).ToInt());
409 
 
410 
			start += m_pCockpitFile->GetDataSize();
411 
		}
412 
		else if ( first.Compare("Model") )
413 
		{
414 
			CyString file = rest.GetToken(" ", 3);
415 
			C_File *newFile= this->AddFile(CFileIO(file).GetFilename(), CFileIO(file).GetDir(), FILETYPE_SHIPMODEL);
416 
			newFile->SetCreationTime(rest.GetToken(" ", 1, 1).ToLong());
417 
			newFile->ReadFromData((char *)(compr + pos), rest.GetToken(" ", 2, 2).ToInt());
418 
 
419 
			start += (newFile->GetDataSize() + 1);
420 
		}
421 
		else if ( first.Compare("Files") )
422 
		{
423 
			CyString file = rest.GetToken(" ", 3);
424 
 
425 
			C_File *newFile = NULL;
426 
			int special = 0;
427 
			if ( file.Compare("types/CutData.txt") || file.Compare("types/CutData.pck") )
428 
			{
429 
				newFile = new C_File(file);
430 
				special = 1;
431 
			}
432 
			else if ( file.Compare("types/Bodies.txt") || file.Compare("types/Bodies.pck") )
433 
			{
434 
				newFile = new C_File(file);
435 
				special = 2;
436 
			}
437 
			else if ( file.Compare("types/Animations.txt") || file.Compare("types/Animations.pck") )
438 
			{
439 
				newFile = new C_File(file);
440 
				special = 3;
441 
			}
442 
			else
443 
			{
444 
				newFile = this->AddFile(CFileIO(file).GetFilename(), CFileIO(file).GetDir(), FILETYPE_SHIPOTHER);
445 
				newFile->SetCreationTime(rest.GetToken(" ", 1, 1).ToLong());
446 
			}
447 
			newFile->ReadFromData((char *)(compr + pos), rest.GetToken(" ", 2, 2).ToInt());
448 
			start += (newFile->GetDataSize() + 1);
449 
 
450 
			if ( special )
451 
			{
452 
				if ( newFile->CheckFileExt("pck") )
453 
					newFile->UnPCKFile();
454 
 
455 
				// read data into lines
456 
				CyString data((const char *)newFile->GetData());
457 
				data.RemoveChar('\r');
458 
				int iLines;
459 
				CyString *sLines = data.SplitToken("\n", &iLines);
460 
 
461 
				if ( sLines && iLines )
462 
				{
463 
					// cut data
464 
					int entries = -1;
465 
					if ( special == 1 )
466 
					{
467 
						CyStringList newLines;
468 
						for ( int i = 0; i < iLines; i++ )
469 
						{
470 
							CyString line = sLines[i];
471 
							line.RemoveChar(' ');
472 
							line.RemoveChar(9);
473 
							if ( line.Empty() || line[0] == '/' )
474 
								continue;
475 
							if ( entries == -1 )
476 
							{
477 
								entries	= line.GetToken(";", 1, 1).ToInt() - 36;
478 
								if ( entries <= 0 )
479 
									break;
480 
							}
481 
							else
482 
							{
483 
								int id = line.GetToken(";", 1, 1).ToInt();
484 
								if ( id >= 9000 && id <= 9017 )
485 
									continue;
486 
 
487 
								switch (id)
488 
								{
489 
									case 948:
490 
									case 4111:
491 
									case 4112:
492 
									case 4064:
493 
									case 4169:
494 
									case 4178:
495 
									case 4177:
496 
									case 4163:
497 
									case 4194:
498 
									case 4162:
499 
									case 4191:
500 
									case 4200:
501 
									case 4161:
502 
									case 4097:
503 
									case 4205:
504 
									case 4206:
505 
									case 4207:
506 
									case 4107:
507 
										break;
508 
 
509 
									default:
510 
										newLines.PushBack(line);
511 
								}
512 
								if ( newLines.Count() == entries )
513 
									break;
514 
							}
515 
						}
516 
 
517 
						for ( SStringList *strNode = newLines.Head(); strNode; strNode = strNode->next )
518 
							this->AddCutData(strNode->str);
519 
					}
520 
					// bodies
521 
					else if ( special == 2 )
522 
					{
523 
						entries = 0;
524 
						CyString section;
525 
						for ( int i = 0; i < iLines; i++ )
526 
						{
527 
							CyString line = sLines[i];
528 
							line.RemoveChar(' ');
529 
							line.RemoveChar(9);
530 
							if ( line.Empty() || line[0] == '/' )
531 
								continue;
532 
							if ( entries <= 0)
533 
							{
534 
								section = line.GetToken(";", 1, 1);
535 
								entries	= line.GetToken(";", 2, 2).ToInt();
536 
							}
537 
							else
538 
							{
539 
								if ( !line.IsIn(";") )
540 
									continue;
541 
								if ( line.NumToken(";") <= 2 )
542 
								{
543 
									this->AddBodies(section + ";" + line.GetToken(";", 1, 1) + ";");
544 
									--entries;
545 
								}
546 
								else
547 
								{
548 
									bool done = false;
549 
									while (!done)
550 
									{
551 
										int num;
552 
										CyString *strs = line.SplitToken(";", &num);
553 
										done = true;
554 
										for ( int j = 0; j < num; j++ )
555 
										{
556 
											if ( !entries )
557 
											{
558 
												line = line.GetToken(";", j + 1);
559 
												if ( !line.Empty() )
560 
													done = false;
561 
												break;
562 
											}
563 
 
564 
											if ( strs[j].Empty() )
565 
												continue;
566 
 
567 
											this->AddBodies(section + ";" + strs[j] + ";");
568 
											--entries;
569 
										}
570 
										//we must be at another section
571 
										if ( !done )
572 
										{
573 
											section = line.GetToken(";", 1, 1);
574 
											entries	= line.GetToken(";", 2, 2).ToInt();
575 
											line = line.RemToken(";", 1);
576 
											line = line.RemToken(";", 1);
577 
 
578 
											if (line.Empty())
579 
												done = true;
580 
										}
581 
 
582 
										CLEANSPLIT(strs, num)
583 
									}
584 
								}
585 
							}
586 
						}
587 
					}
588 
					// animations
589 
					else if ( special == 3 )
590 
					{
591 
						CyStringList in;
592 
						for ( int i = 0; i < iLines; i++ )
593 
						{
594 
							CyString line = sLines[i];
595 
							in.PushBack(line);
596 
						}
597 
 
598 
						CyStringList out;
599 
						if ( CXspFile::ReadAnimations(&in, &out, 87) )
600 
							this->AddAnimation(&out);
601 
					}
602 
				}
603 
				CLEANSPLIT(sLines, iLines)
604 
				delete newFile;
605 
			}
606 
		}
607 
		else if ( first.Compare("Script") )
608 
		{
609 
			CyString file = rest.GetToken(" ", 3);
610 
			C_File *newFile= this->AddFile(file, NullString, FILETYPE_SCRIPT);
611 
			newFile->SetCreationTime(rest.GetToken(" ", 1, 1).ToLong());
612 
			newFile->ReadFromData((char *)(compr + pos), rest.GetToken(" ", 2, 2).ToInt());
613 
 
614 
			start += (newFile->GetDataSize() + 1);
615 
		}
616 
		else if ( first.Compare("Text") )
617 
			this->AddText(rest.GetToken ( ":", 1, 1 ).ToInt(), rest.GetToken ( ":", 2, 2 ), rest.GetToken ( ":", 3 ));
618 
		else if ( first.Compare("Component") )
619 
			this->AddComponent(rest.GetToken ( ";", 1, 1 ), rest.GetToken ( ";", 2, 2 ), rest.GetToken ( ";", 3 ));
620 
		else if ( first.Compare("Dummy") )
621 
		{
622 
			SDummy *d = new SDummy;
623 
			d->sData = rest.GetToken ( ";", 2 );
624 
			d->sSection = rest.GetToken ( ";", 1, 1 );
625 
			m_lDummy.push_back ( d );
626 
		}
14 cycrow 627 
		else if ( !this->ParseValueLine(line.ToString()) )
1 cycrow 628 
		{
629 
		//	printf ( "Command: %s, Rest: %s\n", first.c_str(), rest.c_str());
630 
		}
631 
 
632 
		pos = start;
633 
	}
634 
 
635 
	// assume all old ones are for X3
14 cycrow 636 
	if ( !m_sData.empty() )
1 cycrow 637 
	{
14 cycrow 638 
		this->AddWeaponMask(GAME_X3 - 1, m_sData.token(";", 19));
639 
		this->AddMissileMask(GAME_X3 - 1, m_sData.token(";", 25));
1 cycrow 640 
	}
641 
 
642 
	return true;
643 
}
644 
 
645 
 
646 
int GetMaxShipyards() { return (int)SHIPYARD_MAX; }
647 
 
648 
CyString GetShipyardName (int s)
649 
{
650 
	switch (s)
651 
	{
652 
		case SHIPYARD_ARGON:
653 
			return "Argon";
654 
		case SHIPYARD_BORON:
655 
			return "Boron";
656 
		case SHIPYARD_PARANID:
657 
			return "Paranid";
658 
		case SHIPYARD_SPLIT:
659 
			return "Split";
660 
		case SHIPYARD_TELADI:
661 
			return "Teladi";
662 
		case SHIPYARD_PIRATES:
663 
			return "Pirates";
664 
		case SHIPYARD_FRIEND:
665 
			return "Friendly";
666 
		case SHIPYARD_XENON:
667 
			return "Xenon";
668 
		case SHIPYARD_TERRAN:
669 
			return "Terran";
670 
	}
671 
 
672 
	return "Unknown";
673 
}
674 
 
675 
bool CXspFile::WriteHeader(FILE *id, int valueheader, int valueComprLen)
676 
{
677 
	fprintf ( id, "XSPCycrow;%.2f;%d;%d\n", FILEVERSION, valueheader, valueComprLen );
678 
	if ( ferror(id) )
679 
		return false;
680 
	return true;
681 
}
682 
 
14 cycrow 683 
bool CXspFile::CheckHeader(const Utils::String header) const
1 cycrow 684 
{
685 
	if ( header.Compare("XSPCycrow") )
686 
		return true;
687 
	return false;
688 
}
689 
 
690 
void CXspFile::SetLaserMask(int game, int mask)
691 
{
692 
	for ( CListNode<SWeaponMask> *node = m_lWeaponMasks.Front(); node; node = node->next() )
693 
	{
694 
		SWeaponMask *m = node->Data();
695 
		if ( m->iGame == game )
696 
		{
697 
			m->iMask = mask;
698 
			return;
699 
		}
700 
	}
701 
 
702 
	// no found, need to add it
703 
	this->AddWeaponMask(game, mask);
704 
}
705 
 
706 
void CXspFile::SetMissileMask(int game, int mask)
707 
{
708 
	for ( CListNode<SWeaponMask> *node = m_lMissileMasks.Front(); node; node = node->next() )
709 
	{
710 
		SWeaponMask *m = node->Data();
711 
		if ( m->iGame == game )
712 
		{
713 
			m->iMask = mask;
714 
			return;
715 
		}
716 
	}
717 
 
718 
	// no found, need to add it
719 
	this->AddMissileMask(game, mask);
720 
}
721 
int CXspFile::GetLaserMask(int game, bool getOnly)
722 
{
723 
	int mask = -1;
724 
	for ( CListNode<SWeaponMask> *node = m_lWeaponMasks.Front(); node; node = node->next() )
725 
	{
726 
		SWeaponMask *m = node->Data();
727 
		if ( m->iGame == game )
728 
			return m->iMask;
729 
 
730 
		if ( !mask && !getOnly )
731 
			mask = m->iMask;
732 
	}
733 
 
734 
	return mask;
735 
}
736 
 
737 
int CXspFile::GetMissileMask(int game, bool getOnly)
738 
{
739 
	int mask = -1;
740 
	for ( CListNode<SWeaponMask> *node = m_lMissileMasks.Front(); node; node = node->next() )
741 
	{
742 
		SWeaponMask *m = node->Data();
743 
		if ( m->iGame == game )
744 
			return m->iMask;
745 
 
746 
		if ( !mask && !getOnly )
747 
			mask = m->iMask;
748 
	}
749 
 
750 
	return mask;
751 
}
752 
 
753 
CyString CXspFile::GetShipClass()
754 
{
14 cycrow 755 
	if ( !m_sData.empty() )
756 
		return m_sData.token(";", TSHIPPOS_CLASS);
1 cycrow 757 
	return "OBJ_SHIP_M5";
758 
}
759 
 
760 
bool CXspFile::GeneratePackagerScript(bool wildcard, CyStringList *list, bool datafile)
761 
{
762 
	if ( !CBaseFile::GeneratePackagerScript(wildcard, list, datafile) )
763 
		return false;
764 
 
765 
	if ( m_iShipyard )
766 
	{
767 
		list->PushBack("# Shipyards, Set which shipyards to add ships for sale to");
768 
		for ( int i = SHIPYARD_ARGON; i <= SHIPYARD_MAX; i *= 2 )
769 
		{
770 
			if ( this->IsShipyard(i) )
771 
				list->PushBack(CyString("Shipyard: ") + GetShipyardName(i));
772 
		}
773 
		list->PushBack("");
774 
	}
775 
 
776 
	if ( m_iOrgDesc > 0 )
777 
	{
778 
		list->PushBack("# Use Original Description, overrides text entrys to use one of the built in text");
779 
		list->PushBack(CyString("OriginalDescription: ") + (long)m_iOrgDesc);
780 
		list->PushBack("");
781 
	}
782 
 
14 cycrow 783 
	if ( !m_sID.empty() )
1 cycrow 784 
	{
785 
		list->PushBack("# Ship ID, the ship id to identify the ship as");
786 
		list->PushBack(CyString("ShipID: ") + m_sID);
787 
	}
788 
 
14 cycrow 789 
	if ( !m_sData.empty() )
1 cycrow 790 
	{
791 
		list->PushBack("# Ship Data, the TShip data entry to add to the game (parts of this are adjusted and auto generated by the installer)");
792 
		list->PushBack(CyString("ShipData: ") + m_sData);
793 
		list->PushBack("");
794 
	}
795 
 
796 
	if ( m_bExistingShip )
797 
	{
798 
		list->PushBack("# Existing Ship, replaces an existing ship in the game with ship package instead of creating a new entry");
799 
		list->PushBack("ExistingShip");
800 
		list->PushBack("");
801 
	}
802 
 
803 
	if ( !datafile )
804 
	{
805 
		if ( !CBaseFile::GeneratePackagerScriptFile(wildcard, list) )
806 
			return false;
807 
	}
808 
 
809 
	return true;
810 
}
811 
 
14 cycrow 812 
bool CXspFile::LoadPackageData(const Utils::String &sFirst, const Utils::String &sRest)
1 cycrow 813 
{
14 cycrow 814 
	if ( sFirst.Compare("Shipyard") )
1 cycrow 815 
	{
816 
		for ( int i = SHIPYARD_ARGON; i <= SHIPYARD_MAX; i *= 2 )
817 
		{
14 cycrow 818 
			if ( sRest.Compare(GetShipyardName(i).ToString()) )
1 cycrow 819 
			{
820 
				this->AddShipyard(i);
821 
				break;
822 
			}
823 
		}
824 
	}
14 cycrow 825 
	else if ( sFirst.Compare("OriginalDescription") )
826 
		m_iOrgDesc = sRest;
827 
	else if ( sFirst.Compare("ShipData") )
828 
		m_sData = sRest;
829 
	else if ( sFirst.Compare("ReadData") ) // read data from a tships file
1 cycrow 830 
	{
831 
		CPackages p;
14 cycrow 832 
		m_sData = p.ReadShipData(sRest.tokens(" ", 2), sRest.token(" ", 1)).ToString();
1 cycrow 833 
	}
14 cycrow 834 
	else if ( sFirst.Compare("ExistingShip") )
1 cycrow 835 
		m_bExistingShip = true;
14 cycrow 836 
	else if ( sFirst.Compare("ShipID") )
837 
		m_sID = sRest;
838 
	else if ( !CBaseFile::LoadPackageData(sFirst, sRest) )
1 cycrow 839 
	{
840 
		return false;
841 
	}
842 
 
843 
	return true;
844 
}
845 
 
846 
 
847 
CyString CXspFile::GetX3ShipData()
848 
{
849 
	CyString data = m_sData;
850 
 
851 
	// change the ship subtype, Reunion uses number, TC uses a define
852 
	CyString sSubType = data.GetToken(";", 6, 6);
853 
	if ( !sSubType.ToInt() && sSubType != "0" )
854 
		data = data.RepToken(";", 6, CyString::Number(CShipData::ConvertShipSubType(sSubType)));
855 
 
856 
	CyString sClass = data.GetToken(";", TSHIPPOS_CLASS, TSHIPPOS_CLASS);
857 
	if ( !sClass.ToInt() && sClass != "0" )
858 
	{
859 
		int num = 0;
860 
		for ( int i = 0; i < OBJ_SHIP_MAX; i++ )
861 
		{
862 
			if ( sClass.Compare(CShipData::ConvertShipClass(CShipData::GetShipClassFromNum(i))) )
863 
			{
864 
				num = i;
865 
				break;
866 
			}
867 
		}
868 
 
869 
		data = data.RepToken(";", TSHIPPOS_CLASS, CyString::Number(num));
870 
	}
871 
 
872 
	return data;
873 
}
874 
 
875 
CyString CXspFile::GetTCShipData()
876 
{
877 
	CyString data = m_sData;
878 
 
879 
	CyString sSubType = data.GetToken(";", 6, 6);
880 
	if ( sSubType.ToInt() || sSubType == "0" )
881 
		data = data.RepToken(";", 6, CShipData::ConvertShipSubType(sSubType.ToInt()));
882 
 
883 
	CyString sClass = data.GetToken(";", TSHIPPOS_CLASS, TSHIPPOS_CLASS);
884 
	if ( sClass.ToInt() || sClass == "0" )
885 
		data = data.RepToken(";", TSHIPPOS_CLASS, CShipData::ConvertShipClass(sClass.ToInt()));
886 
 
887 
	return data;
888 
}
889 
 
890 
bool CXspFile::RemoveCockpit(CyString cockpitid)
891 
{
892 
	// if its a whole line, just get the end
893 
	if ( cockpitid.IsIn(";") )
894 
	{
895 
		cockpitid = cockpitid.GetToken(";", -2);
896 
		while ( cockpitid.Right(1) == ";" )
897 
			cockpitid.Truncate((int)cockpitid.Length() - 1);
898 
	}
899 
 
900 
	bool ret = false;
901 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
902 
	{
903 
		CyString id = node->Data()->sCockpit.GetToken(";", 19, 19);
904 
		if ( id.Compare(cockpitid) )
905 
		{
906 
			node->DeleteData();
907 
			ret = true;
908 
			break;
909 
		}
910 
	}
911 
 
912 
	m_lCockpit.RemoveEmpty();
913 
 
914 
	return ret;
915 
}
916 
 
917 
bool CXspFile::RemoveComponent(CyString section1, CyString section2, CyString data)
918 
{
919 
	bool ret = false;
920 
	for ( CListNode<SComponent> *node = m_lComponent.Front(); node; node = node->next() )
921 
	{
922 
		if ( node->Data()->sSection.Compare(section1) && node->Data()->sSection2.Compare(section2) && node->Data()->sData.Compare(data) )
923 
		{
924 
			ret = true;
925 
			node->DeleteData();
926 
			break;
927 
		}
928 
	}
929 
	m_lComponent.RemoveEmpty();
930 
	return ret;
931 
}
932 
 
933 
bool CXspFile::RemoveDummy(CyString section, CyString data)
934 
{
935 
	bool ret = false;
936 
	for ( CListNode<SDummy> *node = m_lDummy.Front(); node; node = node->next() )
937 
	{
938 
		if ( node->Data()->sSection.Compare(section) && node->Data()->sData.Compare(data) )
939 
		{
940 
			ret = true;
941 
			node->DeleteData();
942 
			break;
943 
		}
944 
	}
945 
	m_lDummy.RemoveEmpty();
946 
 
947 
	return ret;
948 
}
949 
 
950 
CyString CXspFile::GetCockpitData(CyString cid)
951 
{
952 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
953 
	{
954 
		CyString id = node->Data()->sCockpit.GetToken(";", 19, 19);
955 
		if ( id.Compare(cid) )
956 
			return node->Data()->sCockpit;
957 
	}
958 
 
959 
	return NullString;
960 
}
961 
 
962 
SCockpit *CXspFile::FindCockpit(CyString cid)
963 
{
964 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
965 
	{
966 
		CyString id = node->Data()->sCockpit.GetToken(";", 19, 19);
967 
		if ( id.Compare(cid) )
968 
			return node->Data();
969 
	}
970 
 
971 
	return NULL;
972 
}
973 
 
974 
void CXspFile::EditCockpit(CyString cid, CyString cockpit)
975 
{
976 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
977 
	{
978 
		CyString id = node->Data()->sCockpit.GetToken(";", 19, 19);
979 
		if ( id.Compare(cid) )
980 
		{
981 
			node->Data()->sCockpit = cockpit;
982 
			break;
983 
		}
984 
	}
985 
}
986 
 
987 
void CXspFile::EditCockpit(CyString cid, CyString scene, int mask)
988 
{
989 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
990 
	{
991 
		CyString id = node->Data()->sCockpit.GetToken(";", 19, 19);
992 
		if ( id.Compare(cid) )
993 
		{
994 
			CyString cockpit = node->Data()->sCockpit;
995 
			cockpit = cockpit.RepToken(";", 8, scene);
996 
			cockpit = cockpit.RepToken(";", 9, CyString::Number(mask));
997 
			node->Data()->sCockpit = cockpit;
998 
			break;
999 
		}
1000 
	}
1001 
}
1002 
void CXspFile::NewCockpit(CyString id, CyString scene, int mask)
1003 
{
1004 
	CyString cockpit = "0;0;0;0;0;0;0;";
1005 
	cockpit += scene + ";";
1006 
	cockpit += CyString::Number(mask);
1007 
	cockpit += ";0;0;0;0;0;0;-100000;0;0;";
1008 
	cockpit += id + ";";
1009 
	this->AddCockpit(cockpit, -1);
1010 
}
1011 
 
1012 
bool CXspFile::RemoveCutData(CyString cut)
1013 
{
1014 
	bool ret = false;
1015 
	for ( SStringList *str = m_lCutData.Head(); str; str = str->next )
1016 
	{
1017 
		if ( str->str.GetToken(";", 1, 1).Compare(cut.GetToken(";", 1, 1)) )
1018 
		{
1019 
			ret = true;
1020 
			str->remove = true;
1021 
			break;
1022 
		}
1023 
	}
1024 
 
1025 
	m_lCutData.RemoveMarked();
1026 
 
1027 
	return ret;
1028 
}
1029 
 
1030 
bool CXspFile::RemoveBodies(CyString cut)
1031 
{
1032 
	bool ret = false;
1033 
	for ( SStringList *str = m_lBodies.Head(); str; str = str->next )
1034 
	{
1035 
		if ( str->str.Remove(' ').Compare(cut.Remove(' ')) )
1036 
		{
1037 
			ret = true;
1038 
			str->remove = true;
1039 
			break;
1040 
		}
1041 
	}
1042 
 
1043 
	m_lBodies.RemoveMarked();
1044 
 
1045 
	return ret;
1046 
}
1047 
 
1048 
bool CXspFile::RemoveAnimation(CyString cut)
1049 
{
1050 
	bool ret = false;
1051 
	for ( SStringList *str = m_lAnimations.Head(); str; str = str->next )
1052 
	{
1053 
		if ( str->str.Remove(' ').Remove('\n').Compare(cut.Remove(' ').Remove('\n')) )
1054 
		{
1055 
			ret = true;
1056 
			str->remove = true;
1057 
			break;
1058 
		}
1059 
	}
1060 
 
1061 
	m_lAnimations.RemoveMarked();
1062 
 
1063 
	return ret;
1064 
}
1065 
 
1066 
void CXspFile::AddCockpit(CyString cockpit, int game, int mask, int index)
1067 
{
1068 
	SCockpit *pCockpit = NULL;
1069 
 
1070 
	// first search for the cockpit entry
1071 
	CyString cid = cockpit.GetToken(";", 19, 19);
1072 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
1073 
	{
1074 
		CyString id = node->Data()->sCockpit.GetToken(";", 19, 19);
1075 
		if ( id.Compare(cid) )
1076 
		{
1077 
			pCockpit = node->Data();
1078 
			break;
1079 
		}
1080 
	}
1081 
 
1082 
	if ( !pCockpit )
1083 
	{
1084 
		pCockpit = new SCockpit;
1085 
		pCockpit->sCockpit = cockpit;
1086 
		pCockpit->iIndex = index;
1087 
		m_lCockpit.push_back(pCockpit);
1088 
	}
1089 
	if ( index != -1 )
1090 
		pCockpit->iIndex = index;
1091 
 
1092 
	// now add the game mask
1093 
	if ( game > 0 )
1094 
	{
1095 
		// search if the game mask already exists
1096 
		SWeaponMask *wm = NULL;
1097 
		for ( CListNode<SWeaponMask> *node = pCockpit->lWeaponMask.Front(); node; node = node->next() )
1098 
		{
1099 
			if ( node->Data()->iGame == game )
1100 
			{
1101 
				wm = node->Data();
1102 
				break;
1103 
			}
1104 
		}
1105 
 
1106 
		if ( !wm )
1107 
		{
1108 
			wm = new SWeaponMask;
1109 
			pCockpit->lWeaponMask.push_back(wm);
1110 
		}
1111 
 
1112 
		wm->iGame = game;
1113 
		if ( mask == -1 )
1114 
			wm->iMask = cockpit.GetToken(";", 9, 9).ToInt();
1115 
		else
1116 
			wm->iMask = mask;
1117 
	}
1118 
	m_bChanged = true;
1119 
}
1120 
 
1121 
void CXspFile::AddBody(CyString section, CyString data)
1122 
{
1123 
	this->AddBodies(section + ";" + data);
1124 
	m_bChanged = true;
1125 
}
1126 
void CXspFile::AddBodies(CyString data)
1127 
{
1128 
	if ( !data.IsNumber() )
1129 
	{
1130 
		if ( data[(int)(data.Length() - 5)] == '.' )
1131 
			data = data.Left(-5);
1132 
		else if ( data[(int)(data.Length() - 4)] == '.' )
1133 
			data = data.Left(-4);
1134 
		if ( data.Right(1) != ";" )
1135 
			data += ";";
1136 
	}
1137 
	m_lBodies.PushBack(data, true);
1138 
	m_bChanged = true;
1139 
}
1140 
 
1141 
int CXspFile::GetAnimationType(CyString type)
1142 
{
1143 
	if ( type.Compare("TAT_TAGSINGLESTEP") )
1144 
		return TAT_SINGLE;
1145 
	else if ( type.Compare("TAT_TAGONESHOT")
1146 
				|| type.Compare("TAT_TAGONESHOT_REINIT")
1147 
				|| type.Compare("TAT_PINGPONG")
1148 
				|| type.Compare("TAT_TAGLOOP") )
1149 
		return TAT_3;
1150 
 
1151 
	return TAT_NONE;
1152 
}
1153 
 
1154 
bool CXspFile::ReadAnimations(CyStringList *lIn, CyStringList *lOut, int startRecord)
1155 
{
1156 
	CyString lastComment;
1157 
	CyString addEntry;
1158 
	int remaining = 0;
1159 
	CyString lastType;
1160 
	int newEntries = 0;
1161 
	int entries = -1;
1162 
	for ( SStringList *strNode = lIn->Head(); strNode; strNode = strNode->next )
1163 
	{
1164 
		CyString line = strNode->str;
1165 
		line.RemoveChar('\r');
1166 
		line.RemoveChar(9);
1167 
		if ( line.Empty() || line[0] == '/' )
1168 
			continue;
1169 
		if ( entries == -1)
1170 
		{
1171 
			entries	= line.GetToken(";", 1, 1).ToInt();
1172 
			newEntries = entries - startRecord;
1173 
		}
1174 
		else
1175 
		{
1176 
			// remove comments, endspaces and last ;
1177 
			CyString sStriped = line;
1178 
			if ( sStriped.IsIn("//") )
1179 
			{
1180 
				if ( entries <= newEntries )
1181 
					lastComment = CyString("//") + sStriped.GetToken("//", 2);
1182 
				sStriped = sStriped.GetToken("//", 1, 1);
1183 
			}
1184 
			sStriped.RemoveEndSpace();
1185 
			if ( sStriped.Right(1) == ";" )
1186 
				sStriped.Truncate(-1);
1187 
 
1188 
			CyString sRemainingLeft;
1189 
			if ( remaining > 0 )
1190 
				sRemainingLeft = sStriped;
1191 
			else
1192 
			{
1193 
				// each line should be a new entry, with some exceptions
1194 
				// potection for new lines
1195 
				lastType = sStriped.GetToken(";", 1, 1);
1196 
 
1197 
				switch (CXspFile::GetAnimationType(lastType))
1198 
				{
1199 
					case TAT_SINGLE:
1200 
						remaining = sStriped.GetToken(";", 5, 5).ToInt() + 1;
1201 
						sRemainingLeft = sStriped.GetToken(";", 6);
1202 
						if ( entries <= newEntries )
1203 
							addEntry = sStriped.GetToken(";", 1, 5) + ";";
1204 
						break;
1205 
					case TAT_3:
1206 
						remaining = sStriped.GetToken(";", 5, 5).ToInt() + 1;
1207 
						sRemainingLeft = sStriped.GetToken(";", 6);
1208 
						if ( entries <= newEntries )
1209 
							addEntry = sStriped.GetToken(";", 1, 5) + ";";
1210 
						break;
1211 
 
1212 
					default:
1213 
						remaining = 0;
1214 
						if ( entries <= newEntries )
1215 
							addEntry = sStriped;
1216 
 
1217 
				}
1218 
			}
1219 
 
1220 
			if ( !sRemainingLeft.Empty() )
1221 
			{
1222 
				int tatType = CXspFile::GetAnimationType(lastType);
1223 
				if ( tatType == TAT_SINGLE )
1224 
				{
1225 
					if ( sRemainingLeft.IsIn(";") )
1226 
						remaining -= sRemainingLeft.NumToken(";");
1227 
					else if ( !sRemainingLeft.Empty() )
1228 
						--remaining;
1229 
 
1230 
					if ( entries <= newEntries )
1231 
						addEntry += sRemainingLeft + ";";
1232 
				}
1233 
				else if ( tatType == TAT_3 )
1234 
				{
1235 
					// last entry
1236 
					if ( remaining == 1 )
1237 
						--remaining;
1238 
					else if ( sRemainingLeft.IsIn(";") )
1239 
					{
1240 
						if ( !sRemainingLeft.IsIn("TATF_COORDS") )
1241 
						{
1242 
							int amt = sRemainingLeft.NumToken(";") / 3;
1243 
							remaining -= amt;
1244 
							if ( remaining == 1 && (sRemainingLeft.NumToken(";") - (amt * 3)) == 1 )
1245 
								--remaining;
1246 
						}
1247 
						else
1248 
						{
1249 
							int iRem = sRemainingLeft.NumToken(";");
1250 
							int iPos = 1;
1251 
							while ( iPos < iRem )
1252 
							{
1253 
								CyString first = sRemainingLeft.GetToken(";", iPos, iPos);
1254 
								if ( first.IsIn("TATF_COORDS") )
1255 
									iPos += 5;
1256 
								else
1257 
									iPos += 3;
1258 
								--remaining;
1259 
							}
1260 
 
1261 
							if ( remaining == 1 && iPos == iRem )
1262 
								--remaining;
1263 
						}
1264 
					}
1265 
 
1266 
					if ( entries <= newEntries )
1267 
						addEntry += sRemainingLeft + ";";
1268 
				}
1269 
			}
1270 
 
1271 
			if ( remaining <= 0 )
1272 
			{
1273 
				if ( entries <= newEntries && !addEntry.Empty())
1274 
				{
1275 
					if ( addEntry[(int)addEntry.Length() - 1] != ';' )
1276 
						addEntry += ";";
1277 
					lOut->PushBack(addEntry + lastComment);
1278 
				}
1279 
				--entries;
1280 
			}
1281 
		}
1282 
	}
1283 
 
1284 
	return !lOut->Empty();
1285 
}
1286 
 
1287 
void CXspFile::AddAnimation(CyStringList *list)
1288 
{
1289 
	for ( SStringList *strNode = list->Head(); strNode; strNode = strNode->next )
1290 
		this->AddAnimation(strNode->str);
1291 
	m_bChanged = true;
1292 
}
1293 
 
1294 
SText *CXspFile::FindShipText(int lang)
1295 
{
1296 
	if ( m_lText.empty() )
1297 
		return NULL;
1298 
 
1299 
	SText *english = NULL;
1300 
	SText *german = NULL;
1301 
	SText *found = NULL;
1302 
	for ( CListNode<SText> *node = m_lText.Front(); node; node = node->next() )
1303 
	{
1304 
		SText *text = node->Data();
1305 
		// matched language
1306 
		if ( text->iId == lang )
1307 
			return text;
1308 
		else if ( text->iId == 44 )
1309 
			english = text;
1310 
		else if ( text->iId == 49 )
1311 
			german = text;
1312 
		else if ( !found )
1313 
			found = text;
1314 
	}
1315 
 
1316 
	// if we've found an english version, use that
1317 
	if ( english )
1318 
		return english;
1319 
	// otherwise try a german
1320 
	if ( german )
1321 
		return german;
1322 
	// otherwise use any we've found (usually first one)
1323 
	return found;
1324 
}
1325 
 
1326 
CyString CXspFile::GetTextName(int lang)
1327 
{
1328 
	SText *t = FindShipText(lang);
1329 
	if ( t )
1330 
	{
1331 
		// return the correct language text
1332 
		if ( !t->sName.Empty() )
1333 
			return t->sName;
1334 
		// we have found a text, but there is no ship name ??
1335 
		else if ( lang != 44 )
1336 
		{
1337 
			// reget the english one
1338 
			t = FindShipText(44);
1339 
			if ( t && !t->sName.Empty() )
1340 
				return t->sName;
1341 
		}
1342 
	}
1343 
 
1344 
	// still not found one, return the ships name
1345 
	return this->GetShipName(lang);
1346 
}
1347 
 
1348 
CyString CXspFile::GetTextDescription(int lang)
1349 
{
1350 
	SText *t = FindShipText(lang);
1351 
	if ( t )
1352 
	{
1353 
		// return the correct language text
1354 
		if ( !t->sDesc.Empty() )
1355 
			return t->sDesc;
1356 
		// we have found a text, but there is no ship name ??
1357 
		else if ( lang != 44 )
1358 
		{
1359 
			// reget the english one
1360 
			t = FindShipText(44);
1361 
			if ( t && !t->sDesc.Empty() )
1362 
				return t->sDesc;
1363 
		}
1364 
	}
1365 
 
1366 
	// still not found one, return the ships name
1367 
	if ( !m_sDescription.Empty() )
1368 
		return m_sDescription;
1369 
	return this->GetShipName(lang);
1370 
}
1371 
 
1372 
bool CXspFile::StartExtractShip(CCatFile *catFile, CyString id, CProgressInfo *progress)
1373 
{
1374 
	id.RemoveChar('\r');
1375 
	while ( id.Right(1) == ";" )
1376 
		id.Truncate((int)id.Length() - 1);
14 cycrow 1377 
	m_sID = id.ToString();
1378 
	m_sData = catFile->GetTShipsEntry(id).ToString();
1 cycrow 1379 
 
1380 
	// get scene files
1381 
	if ( progress ) progress->UpdateStatus(IMPORTSHIP_SCENE);
1382 
	if ( !this->ExtractSceneFiles(catFile) )
1383 
		return false;
1384 
 
1385 
	return true;
1386 
}
1387 
 
1388 
bool CXspFile::StartExtractShip(CyString catFile, CyString id, CProgressInfo *progress)
1389 
{
1390 
	CCatFile cat;
1391 
	if ( cat.Open(catFile, "", CATREAD_CATDECRYPT, false) != CATERR_NONE )
1392 
		return this->StartExtractShip(&cat, id, progress);
1393 
 
1394 
	return false;
1395 
}
1396 
 
1397 
bool CXspFile::ExtractShip(CCatFile *catFile, CyString id, CProgressInfo *progress)
1398 
{
1399 
	if ( !this->StartExtractShip(catFile, id, progress) )
1400 
		return false;
1401 
 
1402 
	// read the scene file and get the files list
1403 
	if ( !this->ProcessSceneFiles(catFile, progress) )
1404 
		return false;
1405 
 
1406 
	// pack all the ship files
1407 
	this->PackAllFiles();
1408 
 
1409 
	return true;
1410 
}
1411 
 
1412 
bool CXspFile::ExtractShip(CyString catFile, CyString id, CProgressInfo *progress)
1413 
{
1414 
	CCatFile cat;
1415 
	if ( cat.Open(catFile, "", CATREAD_CATDECRYPT, false) == CATERR_NONE )
1416 
		return ExtractShip(&cat, id, progress);
1417 
 
1418 
	return false;
1419 
}
1420 
 
1421 
C_File *CXspFile::ExtractFileToPackage(CCatFile *catFile, CyString file, int type, CyString addAs)
1422 
{
1423 
	if ( catFile->ExtractFile(file, "tmp") )
1424 
	{
1425 
		CFileIO File("tmp");
1426 
 
1427 
		C_File *f = this->AddFile(CFileIO(addAs.Empty() ? file : addAs).GetFilename(), CFileIO(addAs.Empty() ? file : addAs).GetDir(), type);
1428 
		if ( f )
1429 
		{
1430 
			if ( f->ReadFromFile("tmp") )
1431 
			{
1432 
				File.Remove();
1433 
				return f;
1434 
			}
1435 
		}
1436 
 
1437 
		File.Remove();
1438 
	}
1439 
	return NULL;
1440 
}
1441 
 
1442 
bool CXspFile::ExtractSceneFiles(CCatFile *catFile)
1443 
{
14 cycrow 1444 
	m_pSceneFile = this->ExtractFileToPackage(catFile, CyString("objects\\") + m_sData.token(";", 17) + ".pbd", FILETYPE_SHIPSCENE, CyString("objects\\") + m_sData.token(";", 17) + ".bod");
1 cycrow 1445 
	if ( !m_pSceneFile )
1446 
	{
14 cycrow 1447 
		m_pSceneFile = this->ExtractFileToPackage(catFile, CyString("objects\\") + m_sData.token(";", 17) + ".bod", FILETYPE_SHIPSCENE);
1 cycrow 1448 
		if ( !m_pSceneFile )
1449 
			return false;
1450 
	}
1451 
 
14 cycrow 1452 
	m_pCockpitFile = this->ExtractFileToPackage(catFile, CyString("objects\\") + m_sData.token(";", 18) + ".pbd", FILETYPE_COCKPITSCENE, CyString("objects\\") + m_sData.token(";", 18) + ".bod");
1 cycrow 1453 
	if ( !m_pCockpitFile )
14 cycrow 1454 
		m_pCockpitFile = this->ExtractFileToPackage(catFile, CyString("objects\\") + m_sData.token(";", 18) + ".bod", FILETYPE_COCKPITSCENE);
1 cycrow 1455 
	return true;
1456 
}
1457 
 
1458 
bool CXspFile::ExtractSceneFiles(CyString catFile)
1459 
{
1460 
	CCatFile cat;
1461 
	if ( cat.Open(catFile, "", CATREAD_CATDECRYPT, false) == CATERR_NONE )
1462 
		return ExtractSceneFiles(&cat);
1463 
 
1464 
	return false;
1465 
}
1466 
 
1467 
CyStringList *CXspFile::ReadSceneModels()
1468 
{
1469 
	// read the scene file
1470 
	if ( !m_pSceneFile )
1471 
		m_pSceneFile = this->GetFirstFile(FILETYPE_SHIPSCENE);
1472 
 
1473 
	if ( !m_pSceneFile )
1474 
		return NULL;
1475 
 
1476 
	// check if its packed
1477 
	size_t datasize;
1478 
	unsigned char *data = m_pSceneFile->UncompressData((long *)&datasize, 0);
1479 
 
1480 
	// if data wasn't compressed, then copy it itself as we are editing it
1481 
	bool deleteData = false;
1482 
	if ( data == m_pSceneFile->GetData() )
1483 
	{
1484 
		data = new unsigned char[m_pSceneFile->GetDataSize()];
1485 
		memcpy(data, m_pSceneFile->GetData(), m_pSceneFile->GetDataSize());
1486 
		deleteData = true;
1487 
	}
1488 
 
1489 
	if ( data && datasize )
1490 
	{
1491 
		if ( m_pSceneFile->CheckPackedExtension() )
1492 
			data = UnPCKData(data, datasize, &datasize);
1493 
	}
1494 
 
1495 
	if ( !data || !datasize )
1496 
		return NULL;
1497 
 
1498 
	CyStringList *lModels = new CyStringList;
1499 
 
1500 
	size_t pos = 0;
1501 
	bool newline = true;
1502 
	bool online = false;
1503 
	while ( pos < datasize )
1504 
	{
1505 
		char c = data[pos];
1506 
		++pos;
1507 
 
1508 
		// skip until next line
1509 
		if ( !newline && !online )
1510 
		{
1511 
			if ( c == '\n' )
1512 
				newline = true;
1513 
			continue;
1514 
		}
1515 
 
1516 
		if ( newline )
1517 
		{
1518 
			if ( c == ' ' || c == 9 || c == '\n' || c == '\r' )
1519 
				continue;
1520 
 
1521 
			newline = false;
1522 
 
1523 
			if ( c == 'P' || c == 'p' )
1524 
			{
1525 
				while ( data[pos] == ' ' ) pos++;
1526 
				unsigned char *line = (data + pos);
1527 
				while ( data[pos] != ' ' && data[pos] != ';' ) pos++;
1528 
				data[pos] = '\0';
1529 
				if ( atoi((const char *)line) == lModels->Count() )
1530 
					online = true;
1531 
			}
1532 
		}
1533 
		// this line is out model
1534 
		else if ( online )
1535 
		{
1536 
			if ( c == 'B' || c == 'b' )
1537 
			{
1538 
				while(data[pos] == ' ') pos++;
1539 
				unsigned char *line = (data + pos);
1540 
				while(data[pos] != ';') pos++;
1541 
				data[pos] = '\0';
1542 
 
1543 
				lModels->PushBack((char *)line);
1544 
				online = false;
1545 
			}
1546 
		}
1547 
	}
1548 
 
1549 
	if ( deleteData )
1550 
		delete data;
1551 
 
1552 
	return lModels;
1553 
}
1554 
 
1555 
void CXspFile::ExtractDummies(CCatFile *catFile, CyStringList *sceneModels, bool add)
1556 
{
1557 
	if ( !sceneModels ) return;
1558 
	if ( catFile->ExtractFile("types/dummies.pck", "tmp") )
1559 
	{
1560 
		CFileIO File("tmp");
1561 
		if ( File.Exists() )
1562 
		{
1563 
			CyString section;
1564 
			int secCount = 0;
1565 
			CyStringList *lines = File.ReadLinesStr();
1566 
			for ( SStringList *node = lines->Head(); node; node = node->next )
1567 
			{
1568 
				node->str.RemoveFirstSpace();
1569 
				node->str.RemoveChar(9);
1570 
				node->str.RemoveChar('\r');
1571 
				if ( node->str.Empty() )
1572 
					continue;
1573 
				if ( node->str[0] == '/' )
1574 
					continue;
1575 
 
1576 
				// not in a section yet
1577 
				if ( secCount <= 0 )
1578 
				{
1579 
					section = node->str.GetToken(";", 1, 1);
1580 
					secCount = node->str.GetToken(";", 2, 2).ToInt();
1581 
				}
1582 
				else
1583 
				{
1584 
					CyString first = node->str.GetToken(";", 1, 1);
1585 
					if ( sceneModels->FindString(first) )
1586 
					{
1587 
						this->AddDummy(section, node->str);
1588 
 
1589 
						if ( add )
1590 
						{
1591 
							int pos = 4;
1592 
							int scene = node->str.GetToken(";", 3, 3).ToInt();
1593 
							for ( int i = 0; i < scene; i++ )
1594 
							{
1595 
								sceneModels->PushBack(node->str.GetToken(";", 5 + (i * 2), 5 + (i * 2)));
1596 
								pos += 2;
1597 
							}
1598 
 
1599 
							int model = node->str.GetToken(";", pos, pos).ToInt();
1600 
							for ( int i = 0; i < model; i++ )
1601 
								sceneModels->PushBack(node->str.GetToken(";", pos + (i * 2) + 1, pos + (i * 2) + 1));
1602 
						}
1603 
					}
1604 
					--secCount;
1605 
 
1606 
				}
1607 
			}
1608 
 
1609 
			delete lines;
1610 
			File.Remove();
1611 
		}
1612 
	}
1613 
}
1614 
 
1615 
void CXspFile::ExtractComponants(CCatFile *catFile, CyStringList *sceneModels)
1616 
{
1617 
	if ( !sceneModels ) return;
1618 
	if ( catFile->ExtractFile("types/components.pck", "tmp") )
1619 
	{
1620 
		CFileIO File("tmp");
1621 
		if ( File.Exists() )
1622 
		{
1623 
			CyString file;
1624 
			CyString section;
1625 
			int secCount = 0;
1626 
			int secCount2 = 0;
1627 
			CyStringList *lines = File.ReadLinesStr();
1628 
			for ( SStringList *node = lines->Head(); node; node = node->next )
1629 
			{
1630 
				node->str.RemoveFirstSpace();
1631 
				node->str.RemoveChar(9);
1632 
				node->str.RemoveChar('\r');
1633 
				if ( node->str.Empty() )
1634 
					continue;
1635 
				if ( node->str[0] == '/' )
1636 
					continue;
1637 
 
1638 
				// not in a section yet
1639 
				if ( secCount2 )
1640 
				{
1641 
					if ( sceneModels->FindString(file) )
1642 
						this->AddComponent(section, file, node->str);
1643 
					--secCount2;
1644 
				}
1645 
				else if ( secCount <= 0 )
1646 
				{
1647 
					section = node->str.GetToken(";", 1, 1);
1648 
					secCount = node->str.GetToken(";", 2, 2).ToInt();
1649 
				}
1650 
				else
1651 
				{
1652 
					file = node->str.GetToken(";", 1, 1);
1653 
					secCount2 = node->str.GetToken(";", 2, 2).ToInt();
1654 
					--secCount;
1655 
				}
1656 
			}
1657 
 
1658 
			delete lines;
1659 
			File.Remove();
1660 
		}
1661 
	}
1662 
}
1663 
 
1664 
bool CXspFile::GetTextureList(CyStringList *list, const unsigned char *olddata, size_t size)
1665 
{
1666 
	if ( !olddata || !size )
1667 
		return false;
1668 
 
1669 
	size_t startLine = 0;
1670 
	CyString line;
1671 
	size_t pos = 0;
1672 
 
1673 
	unsigned char *data = new unsigned char[size];
1674 
	memcpy(data, olddata, size);
1675 
 
1676 
	while ( (pos++) < size )
1677 
	{
1678 
		if ( data[pos] == '\n' )
1679 
		{
1680 
			data[pos] = '\0';
1681 
			line = (char *)(data + startLine);
1682 
			line.RemoveChar(9);
1683 
			line.RemoveChar('\r');
1684 
			line.RemoveFirstSpace();
1685 
 
1686 
			if ( !line.Empty() && line[0] != '/' )
1687 
			{
1688 
				CyString first = line.GetToken(":", 1, 1);
1689 
				if ( first.Compare("MATERIAL6") )
1690 
				{
1691 
					int max;
1692 
					CyString *strs = line.GetToken(":", 2).SplitToken("; ", &max);
1693 
 
1694 
					if ( strs && max >= 2)
1695 
					{
1696 
						for ( int i = 2; i < max; i++ )
1697 
						{
1698 
							CyString s = strs[i];
1699 
							if ( s.IsIn(";") )
1700 
								s = s.GetToken(";", 1, 1);
1701 
							if ( !s.IsNumber() && !s.Compare("NULL") && s.IsIn(".") )
1702 
								list->PushBack(s, "", true);
1703 
						}
1704 
					}
1705 
 
1706 
					CLEANSPLIT(strs, max)
1707 
				}
1708 
			}
1709 
 
1710 
			startLine = pos + 1;
1711 
		}
1712 
	}
1713 
 
1714 
	delete [] data;
1715 
 
1716 
	return true;
1717 
}
1718 
 
1719 
void CXspFile::ExtractTextures(CCatFile *catFile)
1720 
{
1721 
	CyStringList lTextures;
1722 
 
1723 
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
1724 
	{
1725 
		C_File *f = node->Data();
1726 
		if ( f->GetFileType() != FILETYPE_SHIPMODEL )
1727 
			continue;
1728 
 
1729 
		// cant do these yet
1730 
		if ( f->CheckFileExt("pbb") || f->CheckFileExt("bob") )
1731 
		{
1732 
			if ( !f->BobDecompile() )
1733 
				continue;
1734 
		}
1735 
 
1736 
		if ( !f->GetData() )
1737 
		{
1738 
			if ( !f->ReadFromFile() )
1739 
				continue;
1740 
		}
1741 
 
1742 
		unsigned char *data = NULL;
1743 
		size_t size;
1744 
 
1745 
		if ( f->CheckFileExt("pbb") || f->CheckFileExt("pbd") )
1746 
			data = f->UnPCKFile(&size);
1747 
		else
1748 
		{
1749 
			data = f->GetData();
1750 
			size = f->GetDataSize();
1751 
		}
1752 
 
1753 
		this->GetTextureList(&lTextures, data, size);
1754 
	}
1755 
 
1756 
	for ( SStringList *node = lTextures.Head(); node; node = node->next )
1757 
	{
1758 
		if ( CFileIO(node->str).CheckFileExtension("dds") )
1759 
			this->ExtractFileToPackage(catFile, CyString("dds\\") + node->str, FILETYPE_SHIPOTHER);
1760 
		else
1761 
			this->ExtractFileToPackage(catFile, CyString("textures\\") + node->str, FILETYPE_SHIPOTHER);
1762 
	}
1763 
}
1764 
 
1765 
bool CXspFile::AddTextFromFile(CyString file, int textId)
1766 
{
1767 
	bool remove = false;
1768 
	if ( CFileIO(file).CheckFileExtension("pck") )
1769 
	{
1770 
		C_File F(file);
1771 
		F.UnPCKFile();
1772 
		if ( F.WriteToFile("tmp") )
1773 
		{
1774 
			remove = true;
1775 
			file = "tmp";
1776 
		}
1777 
	}
1778 
 
1779 
	FILE *fid = fopen(file.c_str(), "r");
1780 
	if ( fid )
1781 
	{
1782 
		bool ret = this->AddTextFromFile(fid, textId);
1783 
		fclose(fid);
1784 
 
1785 
		if ( remove )
1786 
			CFileIO(file).Remove();
1787 
		m_bChanged = true;
1788 
		return ret;
1789 
	}
1790 
 
1791 
	return false;
1792 
}
1793 
 
1794 
bool CXspFile::ImportBodies(CyStringList *sceneModels, CyString filename)
1795 
{
1796 
	CFileIO File(filename);
1797 
	if ( File.Exists() )
1798 
	{
1799 
		CyString sSection;
1800 
		int section = 0;
1801 
		CyStringList *lines = File.ReadLinesStr();
1802 
		for ( SStringList *node = lines->Head(); node; node = node->next )
1803 
		{
1804 
			node->str.RemoveChar(9);
1805 
			node->str.RemoveChar('\r');
1806 
			node->str.RemoveFirstSpace();
1807 
			if ( node->str.Empty() )
1808 
				continue;
1809 
			if ( node->str[0] == '/' )
1810 
				continue;
1811 
 
1812 
			// are we looking for a section
1813 
			if ( section <= 0 )
1814 
			{
1815 
				sSection = node->str.GetToken(";", 1, 1);
1816 
				section = node->str.GetToken(";", 2, 2).ToInt();
1817 
			}
1818 
			else
1819 
			{
1820 
				int max;
1821 
				CyString *strs = node->str.SplitToken(";", &max);
1822 
				if ( strs && max )
1823 
				{
1824 
					for ( int i = 0; i < max; i++ )
1825 
					{
1826 
						strs[i].RemoveSpaces();
1827 
						if (strs[i].Empty() )
1828 
							continue;
1829 
						if ( sceneModels->FindString(strs[i]) )
1830 
							this->AddBody(sSection, strs[i]);
1831 
						--section;
1832 
					}
1833 
				}
1834 
				CLEANSPLIT(strs, max)
1835 
			}
1836 
		}
1837 
		delete lines;
1838 
		return true;
1839 
	}
1840 
 
1841 
	return false;
1842 
}
1843 
 
1844 
bool CXspFile::ImportCockpits(CyString filename)
1845 
{
1846 
	CFileIO File(filename);
1847 
	if ( File.Exists() )
1848 
	{
1849 
		CyStringList *lines = File.ReadLinesStr();
1850 
		int entries = 0;
1851 
		for ( SStringList *node = lines->Head(); node; node = node->next )
1852 
		{
1853 
			node->str.RemoveChar(9);
1854 
			node->str.RemoveChar('\r');
1855 
			node->str.RemoveFirstSpace();
1856 
			if ( node->str.Empty() )
1857 
				node->remove = true;
1858 
			else if ( node->str[0] == '/' )
1859 
				node->remove = true;
1860 
			else if ( !entries )
1861 
			{
1862 
				entries = node->str.GetToken(";", 2, 2).ToInt();
1863 
				node->remove = true;
1864 
			}
1865 
		}
1866 
		lines->RemoveMarked();
1867 
 
1868 
		// now get all the entries from TShips
1869 
		for ( int i = 0; i < 6; i++ )
1870 
		{
14 cycrow 1871 
			int idx = m_sData.token(";", 32 + (i * 2));
1 cycrow 1872 
			if ( idx < lines->Count() && idx )
1873 
			{
1874 
				CyString turret = lines->GetAt(idx)->str;
1875 
				int pos = -1;
14 cycrow 1876 
				Utils::String id;
1877 
				while ( id.empty() && pos > -100 ) id = turret.GetToken(";", pos, pos--).ToString();
1878 
				m_sData = m_sData.replaceToken(";", 32 + (i * 2), id + "(" + (long)idx + ")");
1 cycrow 1879 
 
1880 
				this->AddCockpit(turret, 0);
1881 
			}
1882 
		}
1883 
 
1884 
		delete lines;
1885 
		return true;
1886 
	}
1887 
	return false;
1888 
}
1889 
 
1890 
bool CXspFile::ExtractCockpits(CCatFile *catFile)
1891 
{
1892 
	if ( catFile->ExtractFile("types/TCockpits.pck", "tmp") )
1893 
	{
1894 
		bool ret = this->ImportCockpits("tmp");
1895 
		CFileIO("tmp").Remove();
1896 
 
1897 
		return ret;
1898 
	}
1899 
 
1900 
	return false;
1901 
}
1902 
 
1903 
bool CXspFile::ExtractBodies(CCatFile *catFile, CyStringList *sceneModels)
1904 
{
1905 
	if ( !sceneModels ) return false;
1906 
	if ( catFile->ExtractFile("types/Bodies.pck", "tmp") )
1907 
	{
1908 
		bool ret = this->ImportBodies(sceneModels, "tmp");
1909 
		CFileIO("tmp").Remove();
1910 
 
1911 
		return ret;
1912 
	}
1913 
 
1914 
	return false;
1915 
}
1916 
 
1917 
bool CXspFile::AddTextFromFile(FILE *id, int textId)
1918 
{
14 cycrow 1919 
	if ( textId == -1 && !m_sData.empty() )
1920 
		textId = m_sData.token(";", 7);
1 cycrow 1921 
 
1922 
	if ( textId <= 0 )
1923 
		return false;
1924 
 
1925 
	CyString line;
1926 
	if ( !id )
1927 
		return false;
1928 
 
1929 
	bool added = false;
1930 
 
1931 
	CyString shipName;
1932 
	CyString shipDesc;
1933 
 
1934 
	int lang = 0;
1935 
	bool inpage = false;
1936 
	while ( !feof(id) )
1937 
	{
1938 
		if ( !shipName.Empty() && !shipDesc.Empty() )
1939 
		{
1940 
			added = true;
1941 
			break;
1942 
		}
1943 
 
1944 
		line.GetEndOfLine(id, 0, false);
1945 
		line.RemoveChar(9);
1946 
		line.RemoveChar('\r');
1947 
		line.RemoveFirstSpace();
1948 
 
1949 
		if ( inpage )
1950 
		{
1951 
			if ( line.Left(6).Compare("</page") )
1952 
				break;
1953 
 
1954 
			// find matching id
1955 
			if ( line.Left(6).Compare("<t id=") )
1956 
			{
1957 
				int pos = line.FindPos("id=\"");
1958 
				if ( pos != -1 )
1959 
				{
1960 
					int endpos = line.FindPos("\"", pos + 5);
1961 
					if ( endpos != -1 )
1962 
					{
1963 
						int id = line.Mid(pos + 5, endpos).ToInt();
1964 
						if ( id == textId || id == (textId + 1) )
1965 
						{
1966 
							pos = line.FindPos(">", endpos);
1967 
							if ( pos != -1 )
1968 
							{
1969 
								endpos = line.FindPos("</t>", pos);
1970 
								if ( endpos != -1 )
1971 
								{
1972 
									if ( id == textId )
1973 
										shipName = line.Mid(pos + 2, endpos - (pos + 1));
1974 
									else
1975 
										shipDesc = line.Mid(pos + 2, endpos - (pos + 1));
1976 
								}
1977 
							}
1978 
						}
1979 
					}
1980 
				}
1981 
			}
1982 
		}
1983 
		else if ( lang ) // search for page 17
1984 
		{
1985 
			if ( line.Left(8).Compare("<page id") )
1986 
			{
1987 
				int pos = line.FindPos("id=\"");
1988 
				if ( pos != -1 )
1989 
				{
1990 
					int endpos = line.FindPos("\"", pos + 5);
1991 
					if ( endpos != -1 )
1992 
					{
1993 
						CyString sId = line.Mid(pos + 5, endpos - (pos + 4));
1994 
						int id = sId.ToInt();
1995 
						if ( id == 17 || sId.Right(4).ToInt() == 17 )
1996 
							inpage = true;
1997 
					}
1998 
				}
1999 
			}
2000 
		}
2001 
		else if ( line.Left(12).Compare("<language id") )
2002 
		{
2003 
			int pos = line.FindPos("id=\"");
2004 
			if ( pos != -1 )
2005 
			{
2006 
				int endpos = line.FindPos("\"", pos + 5);
2007 
				if ( endpos != -1 )
2008 
					lang = line.Mid(pos + 5, endpos - (pos + 4)).ToInt();
2009 
			}
2010 
		}
2011 
	}
2012 
 
2013 
	// incase we only found the shipname
2014 
	if ( !shipName.Empty() )
2015 
		added = true;
2016 
 
2017 
	if ( added )
2018 
	{
2019 
		if ( lang == 44 || m_sName.Empty())
2020 
		{
2021 
			m_sName = shipName;
2022 
			m_sDescription= shipDesc;
2023 
			m_sDescription = m_sDescription.FindReplace("&amp", "&");
2024 
		}
2025 
		this->AddText(lang, shipName, shipDesc);
2026 
		return true;
2027 
	}
2028 
 
2029 
	return false;
2030 
}
2031 
 
2032 
void CXspFile::ExtractTexts(CCatFile *catFile, int textId)
2033 
{
2034 
	for ( CListNode<SInCatFile> *node = catFile->GetFiles()->Front(); node; node = node->next() )
2035 
	{
2036 
		SInCatFile *f = node->Data();
2037 
		if ( !f->sFile.Left(2).Compare("t\\") && !f->sFile.Left(2).Compare("t/") )
2038 
			continue;
2039 
 
2040 
		// extract the text file and read in the data
2041 
		if ( catFile->ExtractFile(f->sFile, "tmp") )
2042 
		{
2043 
			this->AddTextFromFile("tmp", textId);
2044 
			CFileIO("tmp").Remove();
2045 
		}
2046 
	}
2047 
}
2048 
 
2049 
bool CXspFile::ProcessSceneFileSection(int section, CCatFile *catFile, CyStringList *lModels, CProgressInfo *progress)
2050 
{
2051 
	if ( progress ) progress->UpdateStatus(section);
2052 
 
2053 
	switch ( section )
2054 
	{
2055 
		case IMPORTSHIP_COMPONANT:
2056 
			if ( !lModels ) return false;
2057 
			this->ExtractComponants(catFile, lModels);
2058 
			break;
2059 
 
2060 
		case IMPORTSHIP_MODELS:
2061 
			{
2062 
				if ( !lModels ) return false;
2063 
				for ( SStringList *node = lModels->Head(); node; node = node->next )
2064 
				{
2065 
					if ( node->str.IsNumber() ) // count be componants or dummy
2066 
						continue;
2067 
					if ( this->ExtractFileToPackage(catFile, CyString("objects\\") + node->str + ".pbb", FILETYPE_SHIPMODEL, CyString("objects\\") + node->str + ".bob") )
2068 
						continue;
2069 
					if ( this->ExtractFileToPackage(catFile, CyString("objects\\") + node->str + ".pbd", FILETYPE_SHIPMODEL, CyString("objects\\") + node->str + ".bod") )
2070 
						continue;
2071 
					if ( this->ExtractFileToPackage(catFile, CyString("objects\\") + node->str + ".bob", FILETYPE_SHIPMODEL) )
2072 
						continue;
2073 
					if ( this->ExtractFileToPackage(catFile, CyString("objects\\") + node->str + ".bod", FILETYPE_SHIPMODEL) )
2074 
						continue;
2075 
				}
2076 
			}
2077 
			break;
2078 
 
2079 
		case IMPORTSHIP_DUMMIES:
2080 
			if ( !lModels ) return false;
2081 
			this->ExtractDummies(catFile, lModels, true);
2082 
			break;
2083 
 
2084 
		// extract the textures
2085 
		case IMPORTSHIP_TEXTURES:
2086 
			this->ExtractTextures(catFile);
2087 
			break;
2088 
 
2089 
		case IMPORTSHIP_TEXTS:
2090 
			// extract the text file entries
14 cycrow 2091 
			this->ExtractTexts(catFile, m_sData.token(";", 7));
1 cycrow 2092 
			break;
2093 
 
2094 
		case IMPORTSHIP_BODIES:
2095 
			// extract the bodies entries
2096 
			if ( !lModels ) return false;
2097 
			this->ExtractBodies(catFile, lModels);
2098 
			break;
2099 
 
2100 
		case IMPORTSHIP_COCKPITS:
2101 
			// extract the cockpit entries
2102 
			this->ExtractCockpits(catFile);
2103 
			break;
2104 
	}
2105 
 
2106 
	return true;
2107 
}
2108 
 
2109 
bool CXspFile::ProcessSceneFiles(CCatFile *catFile, CProgressInfo *progress)
2110 
{
2111 
	// now lets parse our files
2112 
	if ( progress ) progress->UpdateStatus(IMPORTSHIP_EXTRACTSCENE);
2113 
	CyStringList *lModels = this->ReadSceneModels();
2114 
	if ( !lModels )
2115 
		return false;
2116 
 
2117 
	// extract componants, and add extra items to list
2118 
	if ( !this->ProcessSceneFileSection(IMPORTSHIP_COMPONANT, catFile, lModels, progress) )
2119 
		return false;
2120 
 
2121 
	//lets first find any model files
2122 
	if ( !this->ProcessSceneFileSection(IMPORTSHIP_MODELS, catFile, lModels, progress) )
2123 
		return false;
2124 
 
2125 
	// extract the dummies
2126 
	if ( !this->ProcessSceneFileSection(IMPORTSHIP_DUMMIES, catFile, lModels, progress) )
2127 
		return false;
2128 
 
2129 
	// extract the textures
2130 
	if ( !this->ProcessSceneFileSection(IMPORTSHIP_TEXTURES, catFile, lModels, progress) )
2131 
		return false;
2132 
 
2133 
	// extract the text file entries
2134 
	if ( !this->ProcessSceneFileSection(IMPORTSHIP_TEXTS, catFile, lModels, progress) )
2135 
		return false;
2136 
 
2137 
	// extract the bodies entries
2138 
	if ( !this->ProcessSceneFileSection(IMPORTSHIP_BODIES, catFile, lModels, progress) )
2139 
		return false;
2140 
 
2141 
	// extract the cockpit entries
2142 
	if ( !this->ProcessSceneFileSection(IMPORTSHIP_COCKPITS, catFile, lModels, progress) )
2143 
		return false;
2144 
 
2145 
	delete lModels;
2146 
 
2147 
	return true;
2148 
}
2149 
 
2150 
bool CXspFile::ProcessSceneFiles(CyString catFile, CProgressInfo *progress)
2151 
{
2152 
	CCatFile cat;
2153 
	if ( cat.Open(catFile, "", CATREAD_CATDECRYPT, false) == CATERR_NONE )
2154 
		return ProcessSceneFiles(&cat, progress);
2155 
 
2156 
	return false;
2157 
}
2158 
 
2159 
void CXspFile::PackAllFiles()
2160 
{
2161 
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
2162 
	{
2163 
		C_File *f = node->Data();
2164 
		if ( f->GetFileType() == FILETYPE_SHIPSCENE || f->GetFileType() == FILETYPE_COCKPITSCENE || f->GetFileType() == FILETYPE_SHIPMODEL || f->GetFileType() == FILETYPE_SHIPOTHER )
2165 
		{
2166 
			if ( f->CheckFileExt("bod") )
2167 
			{
2168 
				if ( f->PCKFile() )
2169 
					f->ChangeFileExt("pbd");
2170 
			}
2171 
			else if ( f->CheckFileExt("bob") )
2172 
			{
2173 
				if ( f->PCKFile() )
2174 
					f->ChangeFileExt("pbb");
2175 
			}
2176 
		}
2177 
	}
2178 
}
2179 
 
2180 
void CXspFile::AdjustCockpits()
2181 
{
2182 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
2183 
	{
2184 
		SCockpit *c = node->Data();
2185 
		if ( c->iIndex < 0 )
2186 
			continue;
2187 
 
2188 
		CyString id = c->sCockpit.GetToken(";", 19, 19);
2189 
 
2190 
		for ( int i = 0; i < 6; i++ )
2191 
		{
14 cycrow 2192 
			CyString tId = m_sData.token(";", 32 + (i * 2));
1 cycrow 2193 
			if ( tId.IsNumber() && tId.ToInt() == c->iIndex )
14 cycrow 2194 
				m_sData = m_sData.replaceToken(";", 32 + (i * 2), (id + "(" + CyString::Number(c->iIndex) + ")").c_str());
1 cycrow 2195 
		}
2196 
	}
2197 
}
2198 
 
2199 
CyString CXspFile::FormatShipData(CyStringList *cockpits, int *text, int game)
2200 
{
2201 
	CyString data = (game == GAME_X3) ? this->GetX3ShipData() : this->GetTCShipData();
2202 
	// do turrets
2203 
	for ( int t = 0; t < 6; t++ )
2204 
	{
2205 
		int oldPos = 0;
2206 
		CyString turret = data.GetToken(";", 32 + (t * 2), 32 + (t * 2));
2207 
		if ( !turret.IsNumber() )
2208 
		{
2209 
			if ( turret.IsIn("(") )
2210 
			{
2211 
				oldPos = turret.GetToken("(", 2).GetToken(")", 1, 1).ToInt();
2212 
				turret = turret.GetToken("(", 1, 1);
2213 
			}
2214 
			int pos = cockpits->FindStringPos(turret);
2215 
			if ( pos < 0 )	pos = oldPos;
2216 
			data = data.RepToken(";", 32 + (t * 2), CyString::Number(pos));
2217 
		}
2218 
	}
2219 
	// adjust the weapons
2220 
	int mask = this->GetLaserMask(game - 1);
2221 
	if ( mask != -1 )
2222 
		data = data.RepToken(";", 19, CyString::Number(mask));
2223 
	mask = this->GetMissileMask(game - 1);
2224 
	if ( mask != -1 )
2225 
		data = data.RepToken(";", 25, CyString::Number(mask));
2226 
 
2227 
	// fix the ship text
2228 
	if ( m_iOrgDesc > 0 )
2229 
		(*text) = m_iOrgDesc;
2230 
	data = data.RepToken(";", 7, CyString::Number(*text));
2231 
 
2232 
	// add the ware id
2233 
	data.RemoveChar(9);
2234 
	data.RemoveEndSpace();
2235 
	// remove the end ;
2236 
	while ( data.Right(1) == ";" ) data.Truncate((int)data.Length() - 1);
2237 
	data = data.RepToken(";", data.NumToken(";"), this->GetShipID());
2238 
	if ( data.Right(1) != ";" )
2239 
		data += ";";
2240 
 
2241 
	return data;
2242 
}