Subversion Repositories spk

Rev

Rev 206 | Rev 210 | Go to most recent revision | Details | Compare with Previous | 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 
 
109 cycrow 6 
#define ADDSECTIONLIST(T, L) for(CListNode<T> *node = L.Front(); node; node = node->next()) \
7 
		_addSection(list, node->Data()->sSection, node->Data()->sData);
8 
 
9 
#define GENERATESECTION(F, T, L) if ( !L.empty() ) {						\
10 
									type = F;								\
113 cycrow 11 
									Utils::CList<STypesSection> list;		\
109 cycrow 12 
									ADDSECTIONLIST(T, L);					\
13 
									data = CXspFile::TypesListToString(list, true); \
14 
								}
15 
 
170 cycrow 16 
#define GENERATESTRINGSECTION(F, L, FIRST) if ( !L.empty() ) {				\
109 cycrow 17 
									type = F;								\
113 cycrow 18 
									Utils::CList<STypesSection> list;		\
19 
									_addDataSection(L, list, FIRST);		\
109 cycrow 20 
									data = CXspFile::TypesListToString(list, true); \
21 
								}
22 
 
23 
 
1 cycrow 24 
CXspFile::CXspFile () : CBaseFile()
25 
{
26 
	SetDefaults ();
27 
}
28 
 
29 
void CXspFile::Delete ()
30 
{
31 
	CBaseFile::Delete();
32 
	m_pSceneFile = m_pCockpitFile = NULL;
33 
 
34 
	// delete lists
35 
	m_lMissileMasks.MemoryClear();
36 
	m_lWeaponMasks.MemoryClear();
37 
 
38 
	m_lMissileMasks.destroy();
39 
	m_lWeaponMasks.destroy();
40 
 
41 
	for ( CListNode<SCockpit> *n = m_lCockpit.Front(); n; n = n->next() )
42 
		n->Data()->lWeaponMask.MemoryClear();
43 
	m_lCockpit.MemoryClear();
44 
	m_lCockpit.destroy();
165 cycrow 45 
	_lCutData.clear();
170 cycrow 46 
	_lBodies.clear();
47 
	_lAnimations.clear();
1 cycrow 48 
}
49 
 
50 
void CXspFile::SetDefaults ()
51 
{
52 
	CBaseFile::SetDefaults ();
53 
 
54 
	m_pSceneFile = m_pCockpitFile = NULL;
55 
	m_bLanguageText = m_bExistingShip = false;
56 
	m_iOrgDesc = 0;
57 
 
58 
	m_iShipyard = SHIPYARD_NONE;
59 
}
60 
 
39 cycrow 61 
void CXspFile::AddText ( int id, const Utils::String &name, const Utils::String &desc )
1 cycrow 62 
{
63 
	// first check if theres an existing id
64 
	SText *newtext = NULL;
65 
	for ( SText *t = m_lText.First(); t; t = m_lText.Next() )
66 
	{
67 
		if ( t->iId == id )
68 
		{
69 
			newtext = t;
70 
			break;
71 
		}
72 
	}
73 
 
74 
	if ( !newtext )
75 
	{
76 
		newtext = new SText;
77 
		newtext->iId = id;
78 
		m_lText.push_back ( newtext );
79 
	}
80 
 
81 
	newtext->sName = name;
82 
	newtext->sDesc = desc;
83 
 
50 cycrow 84 
	_changed();
1 cycrow 85 
}
86 
 
87 
void CXspFile::RemoveText(int id)
88 
{
89 
	for ( SText *t = m_lText.First(); t; t = m_lText.Next() )
90 
	{
91 
		if ( t->iId == id )
92 
		{
50 cycrow 93 
			_changed();
1 cycrow 94 
			m_lText.RemoveCurrent();
95 
			return;
96 
		}
97 
	}
98 
}
99 
 
39 cycrow 100 
void CXspFile::AddDummy ( const Utils::String &section, const Utils::String &data )
1 cycrow 101 
{
102 
	SDummy *d = new SDummy;
103 
	d->sData = data;
104 
	d->sSection = section;
105 
 
39 cycrow 106 
	if ( d->sData.right(1) != ";" )
1 cycrow 107 
		d->sData += ";";
108 
 
109 
	m_lDummy.push_back ( d );
110 
 
50 cycrow 111 
	_changed();
1 cycrow 112 
}
113 
 
39 cycrow 114 
void CXspFile::AddComponent ( const Utils::String &section, const Utils::String &section2, const Utils::String &data )
1 cycrow 115 
{
116 
	SComponent *c = new SComponent;
117 
	c->sData = data;
118 
	c->sSection = section;
119 
	c->sSection2 = section2;
120 
 
39 cycrow 121 
	if ( c->sData.right(1) != ";" )
1 cycrow 122 
		c->sData += ";";
123 
 
124 
	m_lComponent.push_back ( c );
125 
 
50 cycrow 126 
	_changed();
1 cycrow 127 
}
128 
 
129 
void CXspFile::AddWeaponMask ( int game, int mask )
130 
{
131 
	// first check if we have one for the game
132 
	SWeaponMask *m = NULL;
133 
	for ( CListNode<SWeaponMask> *node = m_lWeaponMasks.Front(); node; node = node->next() )
134 
	{
135 
		if ( node->Data()->iGame == game )
136 
		{
137 
			m = node->Data();
138 
			break;
139 
		}
140 
	}
141 
 
142 
	// not found, create one
143 
	if ( !m )
144 
	{
145 
		m = new SWeaponMask;
146 
		m_lWeaponMasks.push_back(m);
147 
		m->iGame = game;
148 
	}
149 
 
150 
	m->iMask = mask;
50 cycrow 151 
	_changed();
1 cycrow 152 
}
153 
void CXspFile::AddMissileMask ( int game, int mask )
154 
{
155 
	// first check if we have one for the game
156 
	SWeaponMask *m = NULL;
157 
	for ( CListNode<SWeaponMask> *node = m_lMissileMasks.Front(); node; node = node->next() )
158 
	{
159 
		if ( node->Data()->iGame == game )
160 
		{
161 
			m = node->Data();
162 
			break;
163 
		}
164 
	}
165 
 
166 
	// not found, create one
167 
	if ( !m )
168 
	{
169 
		m = new SWeaponMask;
170 
		m_lMissileMasks.push_back(m);
171 
		m->iGame = game;
172 
	}
173 
 
174 
	m->iMask = mask;
50 cycrow 175 
	_changed();
1 cycrow 176 
}
177 
 
178 
bool CXspFile::IsValid ()
179 
{
50 cycrow 180 
	if ( this->name().empty() )
1 cycrow 181 
		return false;
50 cycrow 182 
	if ( this->author().empty() )
1 cycrow 183 
		return false;
184 
 
185 
	return true;
186 
}
187 
 
207 cycrow 188 
Utils::WString CXspFile::createValuesLine() const
1 cycrow 189 
{
207 cycrow 190 
	Utils::WString values = CBaseFile::createValuesLine ();
1 cycrow 191 
 
207 cycrow 192 
	values += L"Data: " + m_sData.toWString() + L"\n";
193 
	values += L"ID: " + m_sID.toWString() + L"\n";
1 cycrow 194 
 
195 
	if ( m_bLanguageText )
207 cycrow 196 
		values += L"LanguageText\n";
1 cycrow 197 
	if ( m_bExistingShip )
207 cycrow 198 
		values += L"ExistingShip\n";
199 
	values += Utils::WString(L"OrgDesc: ") + (long)m_iOrgDesc + L"\n";
200 
	values += Utils::WString(L"Shipyard: ") + (long)m_iShipyard + L"\n";
1 cycrow 201 
 
14 cycrow 202 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() ) {
203 
		SCockpit *cockpit = node->Data();
207 cycrow 204 
		values += Utils::WString(L"CockpitNew: ") + (long)cockpit->lWeaponMask.size();
14 cycrow 205 
		for ( CListNode<SWeaponMask> *wNode = cockpit->lWeaponMask.Front(); wNode; wNode = wNode->next() ) {
207 cycrow 206 
			values += L":";
14 cycrow 207 
			values += (long)wNode->Data()->iGame;
207 cycrow 208 
			values += L":";
14 cycrow 209 
			values += (long)wNode->Data()->iMask;
1 cycrow 210 
		}
207 cycrow 211 
		values += L" ";
212 
		values += cockpit->sCockpit.toWString() + L"\n";
1 cycrow 213 
	}
214 
 
14 cycrow 215 
	for ( CListNode<SText> *tNode = m_lText.Front(); tNode; tNode = tNode->next() )
207 cycrow 216 
		values += Utils::WString(L"Text: ") + (long)tNode->Data()->iId + L"|" + tNode->Data()->sName.toWString().findReplace(L"|", L"<::PiPe::>") + L"|" + tNode->Data()->sDesc.toWString() + L"\n";
1 cycrow 217 
 
14 cycrow 218 
	for ( CListNode<SComponent> *cNode = m_lComponent.Front(); cNode; cNode = cNode->next() )
207 cycrow 219 
		values += L"Component: " + cNode->Data()->sData.toWString().findReplace(L"|", L"<::PiPe::>") + L"|" + cNode->Data()->sSection.toWString().findReplace(L"|", L"<::PiPe::>") + L"|" + cNode->Data()->sSection2.toWString() + L"\n";
1 cycrow 220 
 
14 cycrow 221 
	for ( CListNode<SDummy> *dNode = m_lDummy.Front(); dNode; dNode = dNode->next() )
207 cycrow 222 
		values += L"Dummy: " + dNode->Data()->sData.toWString().findReplace(L"|", L"<::PiPe::>") + L"|" + dNode->Data()->sSection.toWString() + L"\n";
1 cycrow 223 
 
14 cycrow 224 
	for ( CListNode<SWeaponMask> *wNode = m_lWeaponMasks.Front(); wNode; wNode = wNode->next() )
207 cycrow 225 
		values += Utils::WString(L"WeaponMask: ") + (long)wNode->Data()->iGame + L" " + (long)wNode->Data()->iMask + L"\n";
14 cycrow 226 
	for ( CListNode<SWeaponMask> *mNode = m_lMissileMasks.Front(); mNode; mNode = mNode->next() )
207 cycrow 227 
		values += Utils::WString(L"MissileMask: ") + (long)mNode->Data()->iGame + L" " + (long)mNode->Data()->iMask + L"\n";
170 cycrow 228 
	for (auto itr = _lCutData.begin(); itr != _lCutData.end(); itr++)
207 cycrow 229 
		values += L"CutData: " + (*itr)->str.toWString() + L"\n";
170 cycrow 230 
	for (auto itr = _lBodies.begin(); itr != _lBodies.end(); itr++)
207 cycrow 231 
		values += L"Bodies: " + (*itr)->str.toWString() + L"\n";
170 cycrow 232 
	for (auto itr = _lAnimations.begin(); itr != _lAnimations.end(); itr++)
207 cycrow 233 
		values += L"Animations: " + (*itr)->str.toWString() + L"\n";
1 cycrow 234 
 
235 
	return values;
236 
}
237 
 
207 cycrow 238 
bool CXspFile::parseValueLine(const Utils::WString &sLine)
1 cycrow 239 
{
207 cycrow 240 
	Utils::WString first = sLine.token(L":", 1);
241 
	Utils::WString rest  = sLine.tokens(L":", 2).removeFirstSpace();
1 cycrow 242 
 
207 cycrow 243 
	if ( first.Compare(L"Data") )
244 
		m_sData = rest.toString();
245 
	else if ( first.Compare(L"ID") )
246 
		m_sID = rest.toString();
247 
	else if ( sLine.Compare(L"LanguageText") )
1 cycrow 248 
		m_bLanguageText = true;
207 cycrow 249 
	else if ( sLine.Compare(L"ExistingShip") )
1 cycrow 250 
		m_bExistingShip = true;
207 cycrow 251 
	else if ( first.Compare(L"OrgDesc") || first.Compare(L"OriginalDesc") )
14 cycrow 252 
		m_iOrgDesc = rest;
207 cycrow 253 
	else if ( first.Compare(L"Shipyard") )
14 cycrow 254 
		m_iShipyard = rest;
207 cycrow 255 
	else if ( first.Compare(L"CutData") )
256 
		this->addCutData(rest.toString());
257 
	else if ( first.Compare(L"Bodies") )
258 
		this->addBodies(rest.toString());
259 
	else if ( first.Compare(L"Animations") )
260 
		this->addAnimation(rest.toString());
261 
	else if ( first.Compare(L"Cockpit") )
262 
		this->AddCockpit(rest.toString(), 0);
263 
	else if ( first.Compare(L"CockpitNew") )
1 cycrow 264 
	{
207 cycrow 265 
		Utils::WString cockpit = rest.tokens(L" ", 2);
266 
		Utils::WString sMasks = rest.token(L" ", 1);
267 
		this->AddCockpit(cockpit.toString(), 0, -1);
268 
		int num = sMasks.token(L":", 1);
1 cycrow 269 
		for ( int i = 0; i < num; i++ )
270 
		{
207 cycrow 271 
			int mask = sMasks.token(L":", ((i + 1) * 2) + 1);
272 
			int game = sMasks.token(L":", ((i + 1) * 2));
273 
			this->AddCockpit(cockpit.toString(), game, mask);
1 cycrow 274 
		}
275 
	}
207 cycrow 276 
	else if ( first == L"Web" )	this->setWebSite(rest);
277 
	else if ( first.Compare(L"WeaponMask") )
278 
		this->AddWeaponMask(rest.token(L" ", 1), rest.token(L" ", 2));
279 
	else if ( first.Compare(L"MissileMask") )
280 
		this->AddMissileMask(rest.token(L" ", 1), rest.token(L" ", 2));
281 
	else if ( first == L"Text" )
1 cycrow 282 
	{
283 
		SText *text = new SText;
207 cycrow 284 
		text->iId = rest.token(L"|", 1);
285 
		text->sName = rest.token(L"|", 2).toString();
286 
		text->sName = text->sName.findReplace(L"<::PiPe::>", L"|");
287 
		text->sDesc = rest.tokens(L"|", 3).toString();
1 cycrow 288 
		m_lText.push_back ( text );
289 
	}
207 cycrow 290 
	else if ( first == L"Component" )
1 cycrow 291 
	{
292 
		SComponent *c = new SComponent;
207 cycrow 293 
		c->sData = rest.token(L"|", 1).toString();
294 
		c->sData = c->sData.findReplace (L"<::PiPe::>", L"|");
295 
		c->sSection = rest.token(L"|", 2).toString();
296 
		c->sSection = c->sSection.findReplace (L"<::PiPe::>", L"|");
297 
		c->sSection2 = rest.tokens(L"|", 3).toString();
1 cycrow 298 
		m_lComponent.push_back ( c );
299 
	}
207 cycrow 300 
	else if ( first == L"Dummy" )
1 cycrow 301 
	{
302 
		SDummy *d = new SDummy;
207 cycrow 303 
		d->sData = rest.token(L"|", 1).toString();
304 
		d->sData = d->sData.findReplace (L"<::PiPe::>", L"|");
305 
		d->sSection = rest.tokens(L"|", 2).toString();
1 cycrow 306 
		m_lDummy.push_back ( d );
307 
	}
207 cycrow 308 
	else if ( first == L"Comment" )	this->setDescription(rest.findReplace(L"<newline>", L"<br>"));
1 cycrow 309 
	else
207 cycrow 310 
		return CBaseFile::parseValueLine(sLine);
1 cycrow 311 
 
312 
	return true;
313 
}
314 
 
203 cycrow 315 
Utils::WString CXspFile::shipName(int lang)
1 cycrow 316 
{
203 cycrow 317 
	Utils::WString name;
1 cycrow 318 
	if ( (m_bLanguageText) && (lang) )
319 
	{
320 
		for ( SText *text = m_lText.First(); text; text = m_lText.Next() )
321 
		{
322 
			if ( text->iId == lang )
323 
			{
203 cycrow 324 
				name = text->sName.toWString();
1 cycrow 325 
				break;
326 
			}
327 
		}
328 
	}
329 
 
39 cycrow 330 
	if ( name.empty() )
171 cycrow 331 
		name = this->name(lang);
1 cycrow 332 
 
333 
	return name;
334 
}
335 
 
39 cycrow 336 
//TODO: split this up
337 
bool CXspFile::ConvertOld(const Utils::String &file)
1 cycrow 338 
{
339 
	// open the file
340 
	FILE *id = fopen(file.c_str(), "rb");
341 
	if ( !id )
342 
		return false;
343 
 
344 
	// read to memory
345 
	fseek(id, 0, SEEK_END);
346 
	size_t size = ftell(id);
347 
	fseek(id, 0, SEEK_SET);
348 
	unsigned char *data = new unsigned char[size + 1];
349 
	fread(data, sizeof(unsigned char), size, id);
350 
	data[size] = '\0';
351 
	fclose(id);
352 
 
353 
	// uncompress the file
354 
	size_t len;
355 
	unsigned char *compr = LZMADecode_C ( data, size, &len, NULL );
356 
 
357 
	delete data;
358 
 
359 
	if ( !compr )
360 
		return false;
361 
 
362 
	this->Delete();
363 
	this->SetDefaults();
364 
 
365 
	// now read the data line by line
366 
	size_t pos = 0;
367 
	size_t start = 0;
368 
	int packageVersion = 0;
369 
	while ( pos < len )
370 
	{
371 
		while ( compr[pos++] != '\n' && pos < len );
372 
 
373 
		compr[pos - 1] = '\0';
39 cycrow 374 
		Utils::String line = (char *)(compr + start);
1 cycrow 375 
		start = pos;
39 cycrow 376 
		if ( line.empty() )
1 cycrow 377 
			continue;
39 cycrow 378 
		Utils::String first = line.token(":", 1);
379 
		Utils::String rest = line.tokens(":", 2);
380 
		rest = rest.removeFirstSpace();
1 cycrow 381 
 
382 
		// now check each line
383 
		if ( first.Compare("Packager") )
39 cycrow 384 
			packageVersion = rest;
1 cycrow 385 
		else if ( first.Compare("Shipyard") )
386 
		{
387 
			int max;
39 cycrow 388 
			Utils::String *strs = rest.tokenise(";", &max);
1 cycrow 389 
			if ( strs && max )
390 
			{
391 
				int cur = 1;
392 
				for ( int i = 0; i < max; i++, cur *= 2 )
393 
				{
394 
					if ( strs[i] == "1" )
395 
						this->AddShipyard(cur);
396 
				}
397 
			}
398 
			CLEANSPLIT(strs, max)
399 
		}
400 
		else if ( first.Compare("ScreenShot") )
401 
		{
39 cycrow 402 
			int size = rest.token(" ", 1);
403 
			Utils::String ext = rest.token(" ", 2);
1 cycrow 404 
 
170 cycrow 405 
			C_File *newFile = this->addFile(m_sID + "_" + (long)(this->countFiles(FILETYPE_SCREEN) + 1) + "." + ext, "", FILETYPE_SCREEN);
1 cycrow 406 
			newFile->ReadFromData((char *)(compr + pos), size);
407 
 
408 
			start += (size + 1);
409 
		}
410 
		else if ( first.Compare("SceneFile") )
411 
		{
39 cycrow 412 
			Utils::String file = rest.tokens(" ", 3);
196 cycrow 413 
			m_pSceneFile = this->addFile(CFileIO(file).filenameStr(), CFileIO(file).dir().toString(), FILETYPE_SHIPSCENE);
39 cycrow 414 
			m_pSceneFile->SetCreationTime((long)rest.token(" ", 1));
415 
			m_pSceneFile->ReadFromData((char *)(compr + pos), rest.token(" ", 2));
1 cycrow 416 
 
417 
			start += m_pSceneFile->GetDataSize();
418 
		}
419 
		else if ( first.Compare("CockpitFile") )
420 
		{
39 cycrow 421 
			Utils::String file = rest.tokens(" ", 3);
196 cycrow 422 
			m_pCockpitFile = this->addFile(CFileIO(file).filenameStr(), CFileIO(file).dir().toString(), FILETYPE_COCKPITSCENE);
39 cycrow 423 
			m_pCockpitFile->SetCreationTime((long)rest.token(" ", 1));
424 
			m_pCockpitFile->ReadFromData((char *)(compr + pos), rest.token(" ", 2));
1 cycrow 425 
 
426 
			start += m_pCockpitFile->GetDataSize();
427 
		}
428 
		else if ( first.Compare("Model") )
429 
		{
39 cycrow 430 
			Utils::String file = rest.tokens(" ", 3);
196 cycrow 431 
			C_File *newFile= this->addFile(CFileIO(file).filenameStr(), CFileIO(file).dir().toString(), FILETYPE_SHIPMODEL);
39 cycrow 432 
			newFile->SetCreationTime((long)rest.token(" ", 1));
433 
			newFile->ReadFromData((char *)(compr + pos), rest.token(" ", 2));
1 cycrow 434 
 
435 
			start += (newFile->GetDataSize() + 1);
436 
		}
437 
		else if ( first.Compare("Files") )
438 
		{
39 cycrow 439 
			Utils::String file = rest.tokens(" ", 3);
1 cycrow 440 
 
441 
			C_File *newFile = NULL;
442 
			int special = 0;
443 
			if ( file.Compare("types/CutData.txt") || file.Compare("types/CutData.pck") )
444 
			{
127 cycrow 445 
				newFile = new C_File(file);
1 cycrow 446 
				special = 1;
447 
			}
448 
			else if ( file.Compare("types/Bodies.txt") || file.Compare("types/Bodies.pck") )
449 
			{
127 cycrow 450 
				newFile = new C_File(file);
1 cycrow 451 
				special = 2;
452 
			}
453 
			else if ( file.Compare("types/Animations.txt") || file.Compare("types/Animations.pck") )
454 
			{
127 cycrow 455 
				newFile = new C_File(file);
1 cycrow 456 
				special = 3;
457 
			}
458 
			else
459 
			{
196 cycrow 460 
				newFile = this->addFile(CFileIO(file).filenameStr(), CFileIO(file).dir().toString(), FILETYPE_SHIPOTHER);
39 cycrow 461 
				newFile->SetCreationTime((long)rest.token(" ", 1));
1 cycrow 462 
			}
39 cycrow 463 
			newFile->ReadFromData((char *)(compr + pos), rest.token(" ", 2));
1 cycrow 464 
			start += (newFile->GetDataSize() + 1);
465 
 
466 
			if ( special )
467 
			{
178 cycrow 468 
				if (newFile->checkFileExt("pck"))
1 cycrow 469 
					newFile->UnPCKFile();
470 
 
471 
				// read data into lines
170 cycrow 472 
				Utils::String data((const char *)newFile->GetData());
473 
				data.removeChar('\r');
1 cycrow 474 
				int iLines;
170 cycrow 475 
				Utils::String *sLines = data.tokenise("\n", &iLines);
1 cycrow 476 
 
477 
				if ( sLines && iLines )
478 
				{
479 
					// cut data
170 cycrow 480 
					size_t entries = -1;
1 cycrow 481 
					if ( special == 1 )
482 
					{
170 cycrow 483 
						Utils::CStringList newLines;
1 cycrow 484 
						for ( int i = 0; i < iLines; i++ )
485 
						{
170 cycrow 486 
							Utils::String line = sLines[i];
487 
							line.removeChar(' ');
488 
							line.removeChar(9);
489 
							if ( line.empty() || line[0] == '/' )
1 cycrow 490 
								continue;
491 
							if ( entries == -1 )
492 
							{
170 cycrow 493 
								entries	= line.token(";", 1).toInt() - 36;
1 cycrow 494 
								if ( entries <= 0 )
495 
									break;
496 
							}
497 
							else
498 
							{
170 cycrow 499 
								int id = line.token(";", 1).toInt();
1 cycrow 500 
								if ( id >= 9000 && id <= 9017 )
501 
									continue;
502 
 
503 
								switch (id)
504 
								{
505 
									case 948:
506 
									case 4111:
507 
									case 4112:
508 
									case 4064:
509 
									case 4169:
510 
									case 4178:
511 
									case 4177:
512 
									case 4163:
513 
									case 4194:
514 
									case 4162:
515 
									case 4191:
516 
									case 4200:
517 
									case 4161:
518 
									case 4097:
519 
									case 4205:
520 
									case 4206:
521 
									case 4207:
522 
									case 4107:
523 
										break;
524 
 
525 
									default:
170 cycrow 526 
										newLines.pushBack(line);
1 cycrow 527 
								}
170 cycrow 528 
								if ( newLines.size() == entries )
1 cycrow 529 
									break;
530 
							}
531 
						}
532 
 
170 cycrow 533 
						for(auto itr = newLines.begin(); itr != newLines.end(); itr++)
534 
							this->addCutData((*itr)->str);
1 cycrow 535 
					}
536 
					// bodies
537 
					else if ( special == 2 )
538 
					{
539 
						entries = 0;
39 cycrow 540 
						Utils::String section;
1 cycrow 541 
						for ( int i = 0; i < iLines; i++ )
542 
						{
170 cycrow 543 
							Utils::String line = sLines[i];
39 cycrow 544 
							line.removeChar(' ');
545 
							line.removeChar(9);
546 
							if ( line.empty() || line[0] == '/' )
1 cycrow 547 
								continue;
548 
							if ( entries <= 0)
549 
							{
39 cycrow 550 
								section = line.token(";", 1);
170 cycrow 551 
								entries	= line.token(";", 2).toInt();
1 cycrow 552 
							}
553 
							else
554 
							{
39 cycrow 555 
								if ( !line.isin(";") )
1 cycrow 556 
									continue;
39 cycrow 557 
								if ( line.countToken(";") <= 2 )
1 cycrow 558 
								{
170 cycrow 559 
									this->addBodies(section + ";" + line.token(";", 1) + ";");
1 cycrow 560 
									--entries;
561 
								}
562 
								else
563 
								{
564 
									bool done = false;
565 
									while (!done)
566 
									{
567 
										int num;
39 cycrow 568 
										Utils::String *strs = line.tokenise(";", &num);
1 cycrow 569 
										done = true;
570 
										for ( int j = 0; j < num; j++ )
571 
										{
572 
											if ( !entries )
573 
											{
39 cycrow 574 
												line = line.tokens(";", j + 1);
575 
												if ( !line.empty() )
1 cycrow 576 
													done = false;
577 
												break;
578 
											}
579 
 
39 cycrow 580 
											if ( strs[j].empty() )
1 cycrow 581 
												continue;
582 
 
170 cycrow 583 
											this->addBodies(section + ";" + strs[j] + ";");
1 cycrow 584 
											--entries;
585 
										}
586 
										//we must be at another section
587 
										if ( !done )
588 
										{
39 cycrow 589 
											section = line.token(";", 1);
170 cycrow 590 
											entries	= line.token(";", 2).toInt();
39 cycrow 591 
											line = line.remToken(";", 1);
592 
											line = line.remToken(";", 1);
1 cycrow 593 
 
39 cycrow 594 
											if (line.empty())
1 cycrow 595 
												done = true;
596 
										}
597 
 
598 
										CLEANSPLIT(strs, num)
599 
									}
600 
								}
601 
							}
602 
						}
603 
					}
604 
					// animations
605 
					else if ( special == 3 )
606 
					{
170 cycrow 607 
						Utils::CStringList in;
1 cycrow 608 
						for ( int i = 0; i < iLines; i++ )
170 cycrow 609 
							in.pushBack(sLines[i]);
1 cycrow 610 
 
170 cycrow 611 
						Utils::CStringList out;
612 
						if ( CXspFile::ReadAnimations(in, out, 87) )
613 
							this->addAnimation(out);
1 cycrow 614 
					}
615 
				}
616 
				CLEANSPLIT(sLines, iLines)
617 
				delete newFile;
618 
			}
619 
		}
620 
		else if ( first.Compare("Script") )
621 
		{
39 cycrow 622 
			Utils::String file = rest.words(3);
170 cycrow 623 
			C_File *newFile= this->addFile(file, Utils::String::Null(), FILETYPE_SCRIPT);
39 cycrow 624 
			newFile->SetCreationTime((long)rest.word(1));
625 
			newFile->ReadFromData((char *)(compr + pos), rest.word(2));
1 cycrow 626 
 
627 
			start += (newFile->GetDataSize() + 1);
628 
		}
629 
		else if ( first.Compare("Text") )
39 cycrow 630 
			this->AddText(rest.token(":", 1), rest.token(":", 2), rest.tokens(":", 3));
1 cycrow 631 
		else if ( first.Compare("Component") )
39 cycrow 632 
			this->AddComponent(rest.token(";", 1), rest.token(";", 2), rest.tokens(";", 3));
1 cycrow 633 
		else if ( first.Compare("Dummy") )
634 
		{
635 
			SDummy *d = new SDummy;
39 cycrow 636 
			d->sData = rest.tokens(";", 2);
637 
			d->sSection = rest.token(";", 1);
1 cycrow 638 
			m_lDummy.push_back ( d );
639 
		}
207 cycrow 640 
		else if ( !this->parseValueLine(line) )
1 cycrow 641 
		{
642 
		//	printf ( "Command: %s, Rest: %s\n", first.c_str(), rest.c_str());
643 
		}
644 
 
645 
		pos = start;
646 
	}
647 
 
648 
	// assume all old ones are for X3
14 cycrow 649 
	if ( !m_sData.empty() )
1 cycrow 650 
	{
14 cycrow 651 
		this->AddWeaponMask(GAME_X3 - 1, m_sData.token(";", 19));
652 
		this->AddMissileMask(GAME_X3 - 1, m_sData.token(";", 25));
1 cycrow 653 
	}
654 
 
655 
	return true;
656 
}
657 
 
658 
 
659 
int GetMaxShipyards() { return (int)SHIPYARD_MAX; }
660 
 
39 cycrow 661 
Utils::String GetShipyardName (int s)
1 cycrow 662 
{
663 
	switch (s)
664 
	{
665 
		case SHIPYARD_ARGON:
666 
			return "Argon";
667 
		case SHIPYARD_BORON:
668 
			return "Boron";
669 
		case SHIPYARD_PARANID:
670 
			return "Paranid";
671 
		case SHIPYARD_SPLIT:
672 
			return "Split";
673 
		case SHIPYARD_TELADI:
674 
			return "Teladi";
675 
		case SHIPYARD_PIRATES:
676 
			return "Pirates";
677 
		case SHIPYARD_FRIEND:
678 
			return "Friendly";
679 
		case SHIPYARD_XENON:
680 
			return "Xenon";
681 
		case SHIPYARD_TERRAN:
682 
			return "Terran";
683 
	}
684 
 
685 
	return "Unknown";
686 
}
687 
 
175 cycrow 688 
bool CXspFile::writeHeader(CFileIO &file, int valueheader, int valueComprLen) const
1 cycrow 689 
{
52 cycrow 690 
	return file.write("XSPCycrow;%.2f;%d;%d\n", FILEVERSION, valueheader, valueComprLen);
1 cycrow 691 
}
692 
 
175 cycrow 693 
bool CXspFile::_checkHeader(const Utils::String header) const
1 cycrow 694 
{
695 
	if ( header.Compare("XSPCycrow") )
696 
		return true;
697 
	return false;
698 
}
699 
 
700 
void CXspFile::SetLaserMask(int game, int mask)
701 
{
702 
	for ( CListNode<SWeaponMask> *node = m_lWeaponMasks.Front(); node; node = node->next() )
703 
	{
704 
		SWeaponMask *m = node->Data();
705 
		if ( m->iGame == game )
706 
		{
707 
			m->iMask = mask;
708 
			return;
709 
		}
710 
	}
711 
 
712 
	// no found, need to add it
713 
	this->AddWeaponMask(game, mask);
714 
}
715 
 
716 
void CXspFile::SetMissileMask(int game, int mask)
717 
{
718 
	for ( CListNode<SWeaponMask> *node = m_lMissileMasks.Front(); node; node = node->next() )
719 
	{
720 
		SWeaponMask *m = node->Data();
721 
		if ( m->iGame == game )
722 
		{
723 
			m->iMask = mask;
724 
			return;
725 
		}
726 
	}
727 
 
728 
	// no found, need to add it
729 
	this->AddMissileMask(game, mask);
730 
}
731 
int CXspFile::GetLaserMask(int game, bool getOnly)
732 
{
733 
	int mask = -1;
734 
	for ( CListNode<SWeaponMask> *node = m_lWeaponMasks.Front(); node; node = node->next() )
735 
	{
736 
		SWeaponMask *m = node->Data();
737 
		if ( m->iGame == game )
738 
			return m->iMask;
739 
 
740 
		if ( !mask && !getOnly )
741 
			mask = m->iMask;
742 
	}
743 
 
744 
	return mask;
745 
}
746 
 
747 
int CXspFile::GetMissileMask(int game, bool getOnly)
748 
{
749 
	int mask = -1;
750 
	for ( CListNode<SWeaponMask> *node = m_lMissileMasks.Front(); node; node = node->next() )
751 
	{
752 
		SWeaponMask *m = node->Data();
753 
		if ( m->iGame == game )
754 
			return m->iMask;
755 
 
756 
		if ( !mask && !getOnly )
757 
			mask = m->iMask;
758 
	}
759 
 
760 
	return mask;
761 
}
762 
 
165 cycrow 763 
void CXspFile::clearCutData()
764 
{
765 
	_lCutData.clear();
766 
}
170 cycrow 767 
void CXspFile::clearAnimations()
768 
{
769 
	_lAnimations.clear();
770 
}
771 
void CXspFile::clearBodies()
772 
{
773 
	_lBodies.clear();
774 
}
165 cycrow 775 
 
39 cycrow 776 
Utils::String CXspFile::GetShipClass()
1 cycrow 777 
{
14 cycrow 778 
	if ( !m_sData.empty() )
779 
		return m_sData.token(";", TSHIPPOS_CLASS);
1 cycrow 780 
	return "OBJ_SHIP_M5";
781 
}
782 
 
127 cycrow 783 
bool CXspFile::GeneratePackagerScript(bool wildcard, Utils::CStringList *list, int game, const Utils::CStringList &gameAddons, bool datafile)
1 cycrow 784 
{
127 cycrow 785 
	if ( !CBaseFile::GeneratePackagerScript(wildcard, list, game, gameAddons, datafile) )
1 cycrow 786 
		return false;
787 
 
126 cycrow 788 
	list->pushBack("# File Type, Script or Ship");
789 
	list->pushBack("FileType: Ship");
790 
	list->pushBack("");
98 cycrow 791 
 
1 cycrow 792 
	if ( m_iShipyard )
793 
	{
126 cycrow 794 
		list->pushBack("# Shipyards, Set which shipyards to add ships for sale to");
1 cycrow 795 
		for ( int i = SHIPYARD_ARGON; i <= SHIPYARD_MAX; i *= 2 )
796 
		{
797 
			if ( this->IsShipyard(i) )
126 cycrow 798 
				list->pushBack("Shipyard: " + GetShipyardName(i));
1 cycrow 799 
		}
126 cycrow 800 
		list->pushBack("");
1 cycrow 801 
	}
802 
 
803 
	if ( m_iOrgDesc > 0 )
804 
	{
126 cycrow 805 
		list->pushBack("# Use Original Description, overrides text entrys to use one of the built in text");
806 
		list->pushBack(Utils::String("OriginalDescription: ") + (long)m_iOrgDesc);
807 
		list->pushBack("");
1 cycrow 808 
	}
809 
 
14 cycrow 810 
	if ( !m_sID.empty() )
1 cycrow 811 
	{
126 cycrow 812 
		list->pushBack("# Ship ID, the ship id to identify the ship as");
813 
		list->pushBack("ShipID: " + m_sID);
1 cycrow 814 
	}
815 
 
108 cycrow 816 
	if ( m_bExistingShip )
817 
	{
126 cycrow 818 
		list->pushBack("# Existing Ship, replaces an existing ship in the game with ship package instead of creating a new entry");
819 
		list->pushBack("ExistingShip");
820 
		list->pushBack("");
108 cycrow 821 
	}
822 
 
14 cycrow 823 
	if ( !m_sData.empty() )
1 cycrow 824 
	{
126 cycrow 825 
		list->pushBack("# Ship Data, the TShip data entry to add to the game (parts of this are adjusted and auto generated by the installer)");
826 
		list->pushBack("ShipData: " + m_sData);
827 
		list->pushBack("");
1 cycrow 828 
	}
829 
 
108 cycrow 830 
	if ( m_lText.size() ) {
126 cycrow 831 
		list->pushBack("# Ship Texts, the name/description of the ship in each language: <LANGID> <NAME>|<DESCRIPTION>");
108 cycrow 832 
		for(CListNode<SText> *node = m_lText.Front(); node; node = node->next()) {
126 cycrow 833 
			list->pushBack(Utils::String("ShipText: ") + (long)node->Data()->iId + " " + node->Data()->sName + "|" + node->Data()->sDesc);
108 cycrow 834 
		}
835 
 
126 cycrow 836 
		list->pushBack("");
1 cycrow 837 
	}
838 
 
108 cycrow 839 
	if ( this->m_lWeaponMasks.size() ) {
126 cycrow 840 
		list->pushBack("# Weapon Masks, the weapons for each game: <GAME> <MASK>");
108 cycrow 841 
		for(CListNode<SWeaponMask> *node = m_lWeaponMasks.Front(); node; node = node->next()) {
126 cycrow 842 
			list->pushBack(Utils::String("WeaponMask: ") + (long)node->Data()->iGame + " " + (long)node->Data()->iMask);
108 cycrow 843 
		}
844 
 
126 cycrow 845 
		list->pushBack("");
108 cycrow 846 
	}
847 
 
848 
	if ( this->m_lMissileMasks.size() ) {
126 cycrow 849 
		list->pushBack("# Missile Masks, the missiles for each game: <GAME> <MASK>");
108 cycrow 850 
		for(CListNode<SWeaponMask> *node = m_lMissileMasks.Front(); node; node = node->next()) {
126 cycrow 851 
			list->pushBack(Utils::String("WeaponMask: ") + (long)node->Data()->iGame + " " + (long)node->Data()->iMask);
108 cycrow 852 
		}
853 
 
126 cycrow 854 
		list->pushBack("");
108 cycrow 855 
	}
856 
 
857 
	if ( this->m_lComponent.size() ) {
126 cycrow 858 
		list->pushBack("# Ship Components, each component used in the ships scene: <SECTION> <MODELENTRY> <VALUES>");
108 cycrow 859 
		for(CListNode<SComponent> *node = m_lComponent.Front(); node; node = node->next()) {
126 cycrow 860 
			list->pushBack(Utils::String("Component: ") + node->Data()->sSection + " " + node->Data()->sSection2 + " " + node->Data()->sData);
108 cycrow 861 
		}
126 cycrow 862 
		list->pushBack("");
108 cycrow 863 
	}
864 
 
865 
	if ( this->m_lDummy.size() ) {
126 cycrow 866 
		list->pushBack("# Ship Dummies, each dummy entry used in the ships scene: <SECTION> <VALUE>");
108 cycrow 867 
		for(CListNode<SDummy> *node = m_lDummy.Front(); node; node = node->next()) {
126 cycrow 868 
			list->pushBack("Dummy: " + node->Data()->sSection + " " + node->Data()->sData);
108 cycrow 869 
		}
126 cycrow 870 
		list->pushBack("");
108 cycrow 871 
	}
872 
 
873 
	if ( this->m_lCockpit.size() ) {
126 cycrow 874 
		list->pushBack("# Cockpit entries, each cockpit value with thier weapons mask");
108 cycrow 875 
		for(CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next()) {
126 cycrow 876 
			list->pushBack("Cockpit: " + node->Data()->sCockpit.token(";", 19) + " " + node->Data()->sCockpit);
108 cycrow 877 
			for(SWeaponMask *mask = node->Data()->lWeaponMask.First(); mask; mask = node->Data()->lWeaponMask.Next()) {
126 cycrow 878 
				list->pushBack("CockpitWeapon: " + node->Data()->sCockpit.token(";", 19) + " " + (long)mask->iGame + " " + (long)mask->iMask);
108 cycrow 879 
			}
880 
		}
881 
 
126 cycrow 882 
		list->pushBack("");
108 cycrow 883 
	}
884 
 
170 cycrow 885 
	if (!this->_lCutData.empty())
886 
	{
126 cycrow 887 
		list->pushBack("# Ship Cut Data");
165 cycrow 888 
		for(auto itr = _lCutData.begin(); itr != _lCutData.end(); itr++)
889 
			list->pushBack("CutData: " + (*itr)->str);
126 cycrow 890 
		list->pushBack("");
108 cycrow 891 
	}
892 
 
170 cycrow 893 
	if (!this->_lBodies.empty())
894 
	{
126 cycrow 895 
		list->pushBack("# Ship Bodies");
170 cycrow 896 
		for(auto itr = _lBodies.begin(); itr != _lBodies.end(); itr++)
897 
			list->pushBack("Bodies: " + (*itr)->str);
126 cycrow 898 
		list->pushBack("");
108 cycrow 899 
	}
900 
 
170 cycrow 901 
	if (!this->_lAnimations.empty())
902 
	{
126 cycrow 903 
		list->pushBack("# Ship Animations");
170 cycrow 904 
		for (auto itr = _lAnimations.begin(); itr != _lAnimations.end(); itr++)
905 
			list->pushBack("Animation: " + (*itr)->str);
126 cycrow 906 
		list->pushBack("");
108 cycrow 907 
	}
908 
 
1 cycrow 909 
	if ( !datafile )
910 
	{
127 cycrow 911 
		if ( !CBaseFile::GeneratePackagerScriptFile(wildcard, list, game, gameAddons) )
1 cycrow 912 
			return false;
913 
	}
914 
 
915 
	return true;
916 
}
917 
 
113 cycrow 918 
void CXspFile::_addSection(Utils::CList<STypesSection> &list, const Utils::String &section, const Utils::String &data)
109 cycrow 919 
{
920 
	STypesSection *currentSubSection = NULL;
113 cycrow 921 
	for(Utils::CList<STypesSection>::iterator itr = list.begin(); itr != list.end(); itr++) {
109 cycrow 922 
		if ( (*itr)->sSection.Compare(section) ) {
923 
			currentSubSection = *itr;
924 
			break;
925 
		}
926 
	}
927 
 
928 
	if ( !currentSubSection ) {
929 
		currentSubSection = new STypesSection;
930 
		currentSubSection->sSection = section;
931 
		list.push_back(currentSubSection);
932 
	}
933 
 
934 
	currentSubSection->lEntries.pushBack(data, "");
935 
}
936 
 
165 cycrow 937 
void CXspFile::_addDataSection(Utils::CStringList& list, Utils::CList<STypesSection>& sectionList, bool bUseFirst)
938 
{
939 
	for(auto itr = list.begin(); itr != list.end(); itr++)
940 
	{
941 
		if (bUseFirst) {
942 
			Utils::String data = (*itr)->str;
943 
			_addSection(sectionList, data.token(";", 1), data.tokens(";", 2));
944 
		}
945 
		else {
946 
			_addSection(sectionList, (*itr)->str, (*itr)->data);
947 
		}
948 
	}
949 
}
950 
 
113 cycrow 951 
void CXspFile::addDummiesToList(Utils::CList<STypesSection> &list)
109 cycrow 952 
{
953 
	ADDSECTIONLIST(SDummy, m_lDummy);
954 
}
955 
 
956 
void CXspFile::addComponentsToList(CLinkList<SComponentEntry> &componentList)
957 
{
958 
	for(CListNode<SComponent> *node = m_lComponent.Front(); node; node = node->next()) {
959 
		SComponentEntry *currentSection = NULL;
960 
		for(CListNode<SComponentEntry> *cNode = componentList.Front(); cNode; cNode = cNode->next()) {
961 
			if ( cNode->Data()->sSection.Compare(node->Data()->sSection) ) {
962 
				currentSection = cNode->Data();
963 
				break;
964 
			}
965 
		}
966 
 
967 
		if ( !currentSection ) {
968 
			currentSection = new SComponentEntry();
969 
			currentSection->sSection = node->Data()->sSection;
970 
			componentList.push_back(currentSection);
971 
		}
972 
 
973 
		_addSection(currentSection->lEntries, node->Data()->sSection2, node->Data()->sData);
974 
	}
975 
}
976 
 
113 cycrow 977 
void CXspFile::addCutDataToList(Utils::CList<STypesSection> &list)
109 cycrow 978 
{
165 cycrow 979 
	_addDataSection(this->_lCutData, list, false);
109 cycrow 980 
}
981 
 
113 cycrow 982 
void CXspFile::addBodiesToList(Utils::CList<STypesSection> &list)
109 cycrow 983 
{
170 cycrow 984 
	_addDataSection(this->_lBodies, list, true);
109 cycrow 985 
}
986 
 
113 cycrow 987 
void CXspFile::addAnimationsToList(Utils::CList<STypesSection> &list)
109 cycrow 988 
{
170 cycrow 989 
	_addDataSection(this->_lAnimations, list, false);
109 cycrow 990 
}
991 
 
992 
 
993 
void CXspFile::addGeneratedFiles(HZIP &hz)
994 
{
995 
	TCHAR buf[5000];
996 
 
997 
	CFileIO tmpFile(CPackages::tempDirectory() + "/temp.tmp");
998 
 
999 
	for(int i = 0; i < 5; i++) {
1000 
		Utils::String type;
1001 
		Utils::String data;
1002 
		switch(i) {
1003 
			case 0:
1004 
				data = "50;1\r\n" + this->m_sData;
1005 
				type = "TShips";
1006 
				break;
1007 
			case 1:
1008 
				if ( !this->m_lCockpit.empty() ) {
1009 
					data = Utils::String("51;") + (long)this->m_lCockpit.size() + ";\r\n";
1010 
					for(CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next()) {
1011 
						data += node->Data()->sCockpit + "\r\n";
1012 
					}
1013 
					type = "TCockpits";
1014 
				}
1015 
				break;
1016 
			case 2:
1017 
				if ( !this->m_lComponent.empty() ) {
1018 
					type = "Components";
1019 
					CLinkList<SComponentEntry> componentList;
1020 
					this->addComponentsToList(componentList);
1021 
					for(CListNode<SComponentEntry> *node = componentList.Front(); node; node = node->next()) {
1022 
						data += node->Data()->sSection + "; " + (long)node->Data()->lEntries.size() + ";\r\n";
1023 
						data += CXspFile::TypesListToString(node->Data()->lEntries, true);
1024 
					}
1025 
				}
1026 
				break;
1027 
			case 3:
1028 
				GENERATESECTION("Dummies", SDummy, this->m_lDummy);
1029 
				break;
1030 
			case 4:
170 cycrow 1031 
				GENERATESTRINGSECTION("Bodies", this->_lBodies, true);
109 cycrow 1032 
				break;
1033 
		}
1034 
 
1035 
		if ( type.empty() ) continue;
1036 
 
1037 
		Utils::String fname = "GENERATED/types/" + type + ".txt";
1038 
 
1039 
		Utils::String fileData = "// Exported " + type + " file, Generated by SPK Libraries V" + Utils::String::FromFloat(GetLibraryVersion(), 2) + "\r\n" + data;
1040 
		if ( tmpFile.startWrite() ) {
1041 
			tmpFile.write(fileData.c_str(), fileData.length());
1042 
			tmpFile.close();
1043 
		}
1044 
 
1045 
		// tships files
1046 
		wsprintf(buf, L"%hs", fname.c_str());
1047 
 
1048 
		if ( tmpFile.startRead() ) {
1049 
			size_t dataSize = 0;
1050 
			unsigned char *data = tmpFile.readAll(&dataSize);
1051 
			ZipAdd(hz, buf, data, dataSize);
1052 
		}
1053 
	}
1054 
}
1055 
 
197 cycrow 1056 
bool CXspFile::loadPackageData(const Utils::WString &sFirst, const Utils::WString &sRest, const Utils::WString &sMainGame, Utils::WStringList &otherGames, Utils::WStringList &gameAddons, CProgressInfo *progress)
1 cycrow 1057 
{
197 cycrow 1058 
	if ( sFirst.Compare(L"Shipyard") )
1 cycrow 1059 
	{
1060 
		for ( int i = SHIPYARD_ARGON; i <= SHIPYARD_MAX; i *= 2 )
1061 
		{
39 cycrow 1062 
			if ( sRest.Compare(GetShipyardName(i)) )
1 cycrow 1063 
			{
1064 
				this->AddShipyard(i);
1065 
				break;
1066 
			}
1067 
		}
1068 
	}
197 cycrow 1069 
	else if ( sFirst.Compare(L"OriginalDescription") )
14 cycrow 1070 
		m_iOrgDesc = sRest;
197 cycrow 1071 
	else if ( sFirst.Compare(L"ShipData") )
1072 
		m_sData = sRest.toString();
1073 
	else if ( sFirst.Compare(L"ReadData") ) // read data from a tships file
1 cycrow 1074 
	{
1075 
		CPackages p;
197 cycrow 1076 
		m_sData = p.readShipData(sRest.tokens(L" ", 2).toString(), sRest.token(L" ", 1).toString());
1 cycrow 1077 
	}
197 cycrow 1078 
	else if ( sFirst.Compare(L"ExistingShip") )
1 cycrow 1079 
		m_bExistingShip = true;
197 cycrow 1080 
	else if ( sFirst.Compare(L"ShipID") )
1081 
		m_sID = sRest.toString();
1082 
	else if ( sFirst.Compare(L"ShipText") )
1083 
		this->AddText(sRest.token(L" ", 1).toLong(), sRest.tokens(L" ", 2).token(L"|", 1).toString(), sRest.tokens(L" ", 2).tokens(L"|", 2).toString());
1084 
	else if ( sFirst.Compare(L"Component") )
1085 
		this->AddComponent(sRest.token(L" ", 1).toString(), sRest.token(L" ", 2).toString(), sRest.tokens(L" ", 3).toString());
1086 
	else if ( sFirst.Compare(L"Cockpit") )
1087 
		this->AddCockpit(sRest.tokens(L" ", 2).replaceToken(L";", 19, sRest.token(L" ", 1)).toString(), 0);
1088 
	else if ( sFirst.Compare(L"CockpitWeapon") )
1089 
		this->AddCockpitWeapon(sRest.token(L" ", 1).toString(), sRest.token(L" ", 2), sRest.token(L" ", 3));
1090 
	else if ( sFirst.Compare(L"WeaponMask") )
1091 
		this->AddWeaponMask(sRest.token(L" ", 1), sRest.token(L" ", 2));
1092 
	else if ( sFirst.Compare(L"MissileMask") )
1093 
		this->AddMissileMask(sRest.token(L" ", 1), sRest.token(L" ", 2));
1094 
	else if ( sFirst.Compare(L"Dummy") )
1095 
		this->AddDummy(sRest.token(L" ", 1).toString(), sRest.token(L" ", 2).toString());
1096 
	else if ( sFirst.Compare(L"CutData") )
1097 
		this->addCutData(sRest.toString());
1098 
	else if ( sFirst.Compare(L"Animation") )
1099 
		this->addAnimation(sRest.toString());
1100 
	else if ( sFirst.Compare(L"Bodies") )
1101 
		this->addBodies(sRest.toString());
1102 
	else if ( !CBaseFile::loadPackageData(sFirst, sRest, sMainGame, otherGames, gameAddons, progress) )
1 cycrow 1103 
	{
1104 
		return false;
1105 
	}
1106 
 
1107 
	return true;
1108 
}
1109 
 
1110 
 
39 cycrow 1111 
Utils::String CXspFile::GetX3ShipData()
1 cycrow 1112 
{
39 cycrow 1113 
	Utils::String data = m_sData;
1 cycrow 1114 
 
1115 
	// change the ship subtype, Reunion uses number, TC uses a define
39 cycrow 1116 
	Utils::String sSubType = data.token(";", 6);
1117 
	if ( !((long)sSubType) && sSubType != "0" )
170 cycrow 1118 
		data = data.replaceToken(";", 6, (long)CShipData::ConvertShipSubType(sSubType));
1 cycrow 1119 
 
39 cycrow 1120 
	Utils::String sClass = data.token(";", TSHIPPOS_CLASS);
1121 
	if ( !((long)sClass) && sClass != "0" )
1 cycrow 1122 
	{
1123 
		int num = 0;
1124 
		for ( int i = 0; i < OBJ_SHIP_MAX; i++ )
1125 
		{
94 cycrow 1126 
			if ( sClass.Compare(CShipData::ConvertShipClass(CShipData::GetShipClassFromNum(i))) )
1 cycrow 1127 
			{
1128 
				num = i;
1129 
				break;
1130 
			}
1131 
		}
1132 
 
39 cycrow 1133 
		data = data.replaceToken(";", TSHIPPOS_CLASS, (long)num);
1 cycrow 1134 
	}
1135 
 
1136 
	return data;
1137 
}
1138 
 
39 cycrow 1139 
Utils::String CXspFile::GetTCShipData()
1 cycrow 1140 
{
39 cycrow 1141 
	Utils::String data = m_sData;
1 cycrow 1142 
 
39 cycrow 1143 
	Utils::String sSubType = data.token(";", 6);
1144 
	if ( ((long)sSubType) || sSubType == "0" )
170 cycrow 1145 
		data = data.replaceToken(";", 6, CShipData::ConvertShipSubType((long)sSubType));
1 cycrow 1146 
 
39 cycrow 1147 
	Utils::String sClass = data.token(";", TSHIPPOS_CLASS);
1148 
	if ( ((long)sClass) || sClass == "0" )
94 cycrow 1149 
		data = data.replaceToken(";", TSHIPPOS_CLASS, CShipData::ConvertShipClass((long)sClass));
1 cycrow 1150 
 
1151 
	return data;
1152 
}
1153 
 
170 cycrow 1154 
bool CXspFile::removeCockpit(const Utils::String &sCockpitId)
1 cycrow 1155 
{
39 cycrow 1156 
	Utils::String cockpitid = sCockpitId;
1 cycrow 1157 
	// if its a whole line, just get the end
39 cycrow 1158 
	if ( cockpitid.isin(";") )
1 cycrow 1159 
	{
39 cycrow 1160 
		cockpitid = cockpitid.tokens(";", -2);
1161 
		while ( cockpitid.right(1) == ";" )
1162 
			cockpitid.truncate(-1);
1 cycrow 1163 
	}
1164 
 
1165 
	bool ret = false;
1166 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
1167 
	{
39 cycrow 1168 
		Utils::String id = node->Data()->sCockpit.token(";", 19);
1 cycrow 1169 
		if ( id.Compare(cockpitid) )
1170 
		{
1171 
			node->DeleteData();
1172 
			ret = true;
1173 
			break;
1174 
		}
1175 
	}
1176 
 
1177 
	m_lCockpit.RemoveEmpty();
1178 
 
1179 
	return ret;
1180 
}
1181 
 
170 cycrow 1182 
bool CXspFile::removeComponent(const Utils::String &section1, const Utils::String &section2, const Utils::String &data)
1 cycrow 1183 
{
1184 
	bool ret = false;
1185 
	for ( CListNode<SComponent> *node = m_lComponent.Front(); node; node = node->next() )
1186 
	{
1187 
		if ( node->Data()->sSection.Compare(section1) && node->Data()->sSection2.Compare(section2) && node->Data()->sData.Compare(data) )
1188 
		{
1189 
			ret = true;
1190 
			node->DeleteData();
1191 
			break;
1192 
		}
1193 
	}
1194 
	m_lComponent.RemoveEmpty();
1195 
	return ret;
1196 
}
1197 
 
170 cycrow 1198 
bool CXspFile::removeDummy(const Utils::String &section, const Utils::String &data)
1 cycrow 1199 
{
1200 
	bool ret = false;
1201 
	for ( CListNode<SDummy> *node = m_lDummy.Front(); node; node = node->next() )
1202 
	{
1203 
		if ( node->Data()->sSection.Compare(section) && node->Data()->sData.Compare(data) )
1204 
		{
1205 
			ret = true;
1206 
			node->DeleteData();
1207 
			break;
1208 
		}
1209 
	}
1210 
	m_lDummy.RemoveEmpty();
1211 
 
1212 
	return ret;
1213 
}
1214 
 
39 cycrow 1215 
Utils::String CXspFile::GetCockpitData(const Utils::String &cid)
1 cycrow 1216 
{
1217 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
1218 
	{
39 cycrow 1219 
		Utils::String id = node->Data()->sCockpit.token(";", 19);
1 cycrow 1220 
		if ( id.Compare(cid) )
1221 
			return node->Data()->sCockpit;
1222 
	}
1223 
 
39 cycrow 1224 
	return "";
1 cycrow 1225 
}
1226 
 
39 cycrow 1227 
SCockpit *CXspFile::FindCockpit(const Utils::String &cid)
1 cycrow 1228 
{
1229 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
1230 
	{
39 cycrow 1231 
		Utils::String id = node->Data()->sCockpit.token(";", 19);
1 cycrow 1232 
		if ( id.Compare(cid) )
1233 
			return node->Data();
1234 
	}
1235 
 
1236 
	return NULL;
1237 
}
1238 
 
39 cycrow 1239 
void CXspFile::EditCockpit(const Utils::String &cid, const Utils::String &cockpit)
1 cycrow 1240 
{
1241 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
1242 
	{
39 cycrow 1243 
		Utils::String id = node->Data()->sCockpit.token(";", 19);
1 cycrow 1244 
		if ( id.Compare(cid) )
1245 
		{
1246 
			node->Data()->sCockpit = cockpit;
1247 
			break;
1248 
		}
1249 
	}
1250 
}
1251 
 
39 cycrow 1252 
void CXspFile::EditCockpit(const Utils::String &cid, const Utils::String &scene, int mask)
1 cycrow 1253 
{
1254 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
1255 
	{
39 cycrow 1256 
		Utils::String id = node->Data()->sCockpit.token(";", 19);
1 cycrow 1257 
		if ( id.Compare(cid) )
1258 
		{
39 cycrow 1259 
			Utils::String cockpit = node->Data()->sCockpit;
1260 
			cockpit = cockpit.replaceToken(";", 8, scene);
1261 
			cockpit = cockpit.replaceToken(";", 9, (long)mask);
1 cycrow 1262 
			node->Data()->sCockpit = cockpit;
1263 
			break;
1264 
		}
1265 
	}
1266 
}
39 cycrow 1267 
void CXspFile::NewCockpit(const Utils::String &id, const Utils::String &scene, int mask)
1 cycrow 1268 
{
39 cycrow 1269 
	Utils::String cockpit = "0;0;0;0;0;0;0;";
1 cycrow 1270 
	cockpit += scene + ";";
39 cycrow 1271 
	cockpit += (long)mask;
1 cycrow 1272 
	cockpit += ";0;0;0;0;0;0;-100000;0;0;";
1273 
	cockpit += id + ";";
1274 
	this->AddCockpit(cockpit, -1);
1275 
}
1276 
 
165 cycrow 1277 
bool CXspFile::removeCutData(const Utils::String &cut)
1 cycrow 1278 
{
1279 
	bool ret = false;
165 cycrow 1280 
	for(size_t i = 0; i < _lCutData.size(); i++)
1 cycrow 1281 
	{
165 cycrow 1282 
		Utils::String str = _lCutData[i]->str;
1283 
		if (str.token(";", 1).Compare(cut.token(";", 1)))
1 cycrow 1284 
		{
1285 
			ret = true;
165 cycrow 1286 
			_lCutData.remove(str);
1 cycrow 1287 
			break;
1288 
		}
1289 
	}
1290 
 
1291 
	return ret;
1292 
}
1293 
 
170 cycrow 1294 
bool CXspFile::removeBodies(const Utils::String &cut)
1 cycrow 1295 
{
1296 
	bool ret = false;
170 cycrow 1297 
	for (auto itr = _lBodies.begin(); itr != _lBodies.end(); itr++)
1 cycrow 1298 
	{
170 cycrow 1299 
		if ((*itr)->str.remove(' ').Compare(cut.remove(' ')))
1 cycrow 1300 
		{
170 cycrow 1301 
			_lBodies.remove(itr);
1302 
			return true;
1 cycrow 1303 
		}
1304 
	}
1305 
 
170 cycrow 1306 
	return false;
1 cycrow 1307 
}
1308 
 
170 cycrow 1309 
bool CXspFile::removeAnimation(const Utils::String &cut)
1 cycrow 1310 
{
170 cycrow 1311 
	for(auto itr = _lAnimations.begin(); itr != _lAnimations.end(); itr++)
1 cycrow 1312 
	{
170 cycrow 1313 
		if ((*itr)->str.remove(' ').remove('\n').Compare(cut.remove(' ').remove('\n')))
1 cycrow 1314 
		{
170 cycrow 1315 
			_lAnimations.remove(itr);
1316 
			return true;
1 cycrow 1317 
		}
1318 
	}
1319 
 
170 cycrow 1320 
	return false;
1 cycrow 1321 
}
1322 
 
108 cycrow 1323 
SCockpit *CXspFile::_findCockpit(const Utils::String &sID)
1 cycrow 1324 
{
108 cycrow 1325 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() ) {
1326 
		Utils::String id = node->Data()->sCockpit.token(";", 19);
1327 
		if ( id.Compare(sID) )
1328 
			return node->Data();
1329 
	}
1 cycrow 1330 
 
108 cycrow 1331 
	return NULL;
1332 
}
1333 
 
1334 
void CXspFile::AddCockpitWeapon(const Utils::String &cockpit, int game, int mask)
1335 
{
1336 
	SCockpit *pCockpit = _findCockpit(cockpit);
1337 
 
1338 
	// search if the game mask already exists
1339 
	SWeaponMask *wm = NULL;
1340 
	for ( CListNode<SWeaponMask> *node = pCockpit->lWeaponMask.Front(); node; node = node->next() )
1 cycrow 1341 
	{
108 cycrow 1342 
		if ( node->Data()->iGame == game )
1 cycrow 1343 
		{
108 cycrow 1344 
			wm = node->Data();
1 cycrow 1345 
			break;
1346 
		}
1347 
	}
1348 
 
108 cycrow 1349 
	if ( !wm )
1350 
	{
1351 
		wm = new SWeaponMask;
1352 
		pCockpit->lWeaponMask.push_back(wm);
1353 
	}
1354 
 
1355 
	wm->iGame = game;
1356 
	if ( mask == -1 )
1357 
		wm->iMask = pCockpit->sCockpit.token(";", 9);
1358 
	else
1359 
		wm->iMask = mask;
1360 
	_changed();
1361 
}
1362 
 
1363 
void CXspFile::AddCockpit(const Utils::String &cockpit, int game, int mask, int index)
1364 
{
1365 
	Utils::String cid = cockpit.token(";", 19);
1366 
	SCockpit *pCockpit = _findCockpit(cid);
1367 
 
1 cycrow 1368 
	if ( !pCockpit )
1369 
	{
1370 
		pCockpit = new SCockpit;
1371 
		pCockpit->sCockpit = cockpit;
1372 
		pCockpit->iIndex = index;
1373 
		m_lCockpit.push_back(pCockpit);
1374 
	}
1375 
	if ( index != -1 )
1376 
		pCockpit->iIndex = index;
1377 
 
1378 
	// now add the game mask
1379 
	if ( game > 0 )
108 cycrow 1380 
		AddCockpitWeapon(cid, game, mask);
50 cycrow 1381 
	_changed();
1 cycrow 1382 
}
1383 
 
170 cycrow 1384 
void CXspFile::addBody(const Utils::String &section, const Utils::String &data)
1 cycrow 1385 
{
170 cycrow 1386 
	this->addBodies(section + ";" + data);
50 cycrow 1387 
	_changed();
1 cycrow 1388 
}
170 cycrow 1389 
void CXspFile::addBodies(const Utils::String &sData)
1 cycrow 1390 
{
39 cycrow 1391 
	Utils::String data = sData;
1392 
	if ( !data.isNumber() )
1 cycrow 1393 
	{
39 cycrow 1394 
		if ( data[(int)(data.length() - 5)] == '.' )
1395 
			data = data.left(-5);
1396 
		else if ( data[(int)(data.length() - 4)] == '.' )
1397 
			data = data.left(-4);
1398 
		if ( data.right(1) != ";" )
1 cycrow 1399 
			data += ";";
1400 
	}
170 cycrow 1401 
	if(!_lBodies.contains(data))
1402 
		_lBodies.pushBack(data);
50 cycrow 1403 
	_changed();
1 cycrow 1404 
}
1405 
 
165 cycrow 1406 
void CXspFile::addCutData(const Utils::String& data)
1407 
{
1408 
	if (!_lCutData.contains(data))
1409 
	{
1410 
		_lCutData.pushBack(data);
1411 
		_changed();
1412 
	}
1413 
}
1414 
 
1415 
 
39 cycrow 1416 
int CXspFile::GetAnimationType(const Utils::String &type)
1 cycrow 1417 
{
1418 
	if ( type.Compare("TAT_TAGSINGLESTEP") )
1419 
		return TAT_SINGLE;
1420 
	else if ( type.Compare("TAT_TAGONESHOT")
1421 
				|| type.Compare("TAT_TAGONESHOT_REINIT")
1422 
				|| type.Compare("TAT_PINGPONG")
1423 
				|| type.Compare("TAT_TAGLOOP") )
1424 
		return TAT_3;
1425 
 
1426 
	return TAT_NONE;
1427 
}
1428 
 
113 cycrow 1429 
Utils::String CXspFile::TypesListToString(Utils::CList<STypesSection> &list, bool deleteAfter)
109 cycrow 1430 
{
1431 
	Utils::String data;
1432 
 
113 cycrow 1433 
	for(Utils::CList<STypesSection>::iterator itr = list.begin(); itr != list.end(); itr++) {
109 cycrow 1434 
		data += (*itr)->sSection + "; " + (long)(*itr)->lEntries.size() + ";\r\n";
112 cycrow 1435 
		for(Utils::SStringList *str = (*itr)->lEntries.first(); str; str = (*itr)->lEntries.next()) {
109 cycrow 1436 
			data += str->str + "\r\n";
1437 
		}
1438 
 
1439 
		if ( deleteAfter ) {
112 cycrow 1440 
			(*itr)->lEntries.clear();
109 cycrow 1441 
		}
1442 
	}
1443 
 
1444 
	return data;
1445 
}
1446 
 
170 cycrow 1447 
bool CXspFile::ReadAnimations(const Utils::CStringList &lIn, Utils::CStringList &lOut, int startRecord)
1 cycrow 1448 
{
39 cycrow 1449 
	Utils::String lastComment;
1450 
	Utils::String addEntry;
1 cycrow 1451 
	int remaining = 0;
39 cycrow 1452 
	Utils::String lastType;
1 cycrow 1453 
	int newEntries = 0;
1454 
	int entries = -1;
170 cycrow 1455 
	for(auto itr = lIn.begin(); itr != lIn.end(); itr++)
1 cycrow 1456 
	{
170 cycrow 1457 
		Utils::String line = (*itr)->str;
39 cycrow 1458 
		line.removeChar('\r');
1459 
		line.removeChar(9);
1460 
		if ( line.empty() || line[0] == '/' )
1 cycrow 1461 
			continue;
1462 
		if ( entries == -1)
1463 
		{
39 cycrow 1464 
			entries	= line.token(";", 1);
1 cycrow 1465 
			newEntries = entries - startRecord;
1466 
		}
1467 
		else
1468 
		{
1469 
			// remove comments, endspaces and last ;
39 cycrow 1470 
			Utils::String sStriped = line;
1471 
			if ( sStriped.isin("//") )
1 cycrow 1472 
			{
1473 
				if ( entries <= newEntries )
39 cycrow 1474 
					lastComment = "//" + sStriped.tokens("//", 2);
1475 
				sStriped = sStriped.token("//", 1);
1 cycrow 1476 
			}
39 cycrow 1477 
			sStriped.removeEndSpace();
1478 
			if ( sStriped.right(1) == ";" )
1479 
				sStriped.truncate(-1);
1 cycrow 1480 
 
39 cycrow 1481 
			Utils::String sRemainingLeft;
1 cycrow 1482 
			if ( remaining > 0 )
1483 
				sRemainingLeft = sStriped;
1484 
			else
1485 
			{
1486 
				// each line should be a new entry, with some exceptions
1487 
				// potection for new lines
39 cycrow 1488 
				lastType = sStriped.token(";", 1);
1 cycrow 1489 
 
1490 
				switch (CXspFile::GetAnimationType(lastType))
1491 
				{
1492 
					case TAT_SINGLE:
39 cycrow 1493 
						remaining = (long)sStriped.token(";", 5) + 1;
1494 
						sRemainingLeft = sStriped.tokens(";", 6);
1 cycrow 1495 
						if ( entries <= newEntries )
39 cycrow 1496 
							addEntry = sStriped.tokens(";", 1, 5) + ";";
1 cycrow 1497 
						break;
1498 
					case TAT_3:
39 cycrow 1499 
						remaining = (long)sStriped.token(";", 5) + 1;
1500 
						sRemainingLeft = sStriped.tokens(";", 6);
1 cycrow 1501 
						if ( entries <= newEntries )
39 cycrow 1502 
							addEntry = sStriped.tokens(";", 1, 5) + ";";
1 cycrow 1503 
						break;
1504 
 
1505 
					default:
1506 
						remaining = 0;
1507 
						if ( entries <= newEntries )
1508 
							addEntry = sStriped;
1509 
 
1510 
				}
1511 
			}
1512 
 
39 cycrow 1513 
			if ( !sRemainingLeft.empty() )
1 cycrow 1514 
			{
1515 
				int tatType = CXspFile::GetAnimationType(lastType);
1516 
				if ( tatType == TAT_SINGLE )
1517 
				{
39 cycrow 1518 
					if ( sRemainingLeft.isin(";") )
1519 
						remaining -= sRemainingLeft.countToken(";");
1520 
					else if ( !sRemainingLeft.empty() )
1 cycrow 1521 
						--remaining;
1522 
 
1523 
					if ( entries <= newEntries )
1524 
						addEntry += sRemainingLeft + ";";
1525 
				}
1526 
				else if ( tatType == TAT_3 )
1527 
				{
1528 
					// last entry
1529 
					if ( remaining == 1 )
1530 
						--remaining;
39 cycrow 1531 
					else if ( sRemainingLeft.isin(";") )
1 cycrow 1532 
					{
39 cycrow 1533 
						if ( !sRemainingLeft.isin("TATF_COORDS") )
1 cycrow 1534 
						{
39 cycrow 1535 
							int amt = sRemainingLeft.countToken(";") / 3;
1 cycrow 1536 
							remaining -= amt;
39 cycrow 1537 
							if ( remaining == 1 && (sRemainingLeft.countToken(";") - (amt * 3)) == 1 )
1 cycrow 1538 
								--remaining;
1539 
						}
1540 
						else
1541 
						{
39 cycrow 1542 
							int iRem = sRemainingLeft.countToken(";");
1 cycrow 1543 
							int iPos = 1;
1544 
							while ( iPos < iRem )
1545 
							{
39 cycrow 1546 
								Utils::String first = sRemainingLeft.token(";", iPos);
1547 
								if ( first.isin("TATF_COORDS") )
1 cycrow 1548 
									iPos += 5;
1549 
								else
1550 
									iPos += 3;
1551 
								--remaining;
1552 
							}
1553 
 
1554 
							if ( remaining == 1 && iPos == iRem )
1555 
								--remaining;
1556 
						}
1557 
					}
1558 
 
1559 
					if ( entries <= newEntries )
1560 
						addEntry += sRemainingLeft + ";";
1561 
				}
1562 
			}
1563 
 
1564 
			if ( remaining <= 0 )
1565 
			{
39 cycrow 1566 
				if ( entries <= newEntries && !addEntry.empty())
1 cycrow 1567 
				{
39 cycrow 1568 
					if ( addEntry[(int)addEntry.length() - 1] != ';' )
1 cycrow 1569 
						addEntry += ";";
170 cycrow 1570 
					lOut.pushBack(addEntry + lastComment);
1 cycrow 1571 
				}
1572 
				--entries;
1573 
			}
1574 
		}
1575 
	}
1576 
 
170 cycrow 1577 
	return !lOut.empty();
1 cycrow 1578 
}
1579 
 
170 cycrow 1580 
void CXspFile::addAnimation(const Utils::CStringList &list)
1 cycrow 1581 
{
170 cycrow 1582 
	for(auto itr = list.begin(); itr != list.end(); itr++)
1583 
		this->addAnimation((*itr)->str);
50 cycrow 1584 
	_changed();
1 cycrow 1585 
}
1586 
 
170 cycrow 1587 
void CXspFile::addAnimation(const Utils::String& data)
1588 
{
1589 
	if (!_lAnimations.contains(data))
1590 
	{
1591 
		_lAnimations.pushBack(data);
1592 
		_changed();
1593 
	}
1594 
}
1595 
 
1 cycrow 1596 
SText *CXspFile::FindShipText(int lang)
1597 
{
1598 
	if ( m_lText.empty() )
1599 
		return NULL;
1600 
 
1601 
	SText *english = NULL;
1602 
	SText *german = NULL;
1603 
	SText *found = NULL;
1604 
	for ( CListNode<SText> *node = m_lText.Front(); node; node = node->next() )
1605 
	{
1606 
		SText *text = node->Data();
1607 
		// matched language
1608 
		if ( text->iId == lang )
1609 
			return text;
1610 
		else if ( text->iId == 44 )
1611 
			english = text;
1612 
		else if ( text->iId == 49 )
1613 
			german = text;
1614 
		else if ( !found )
1615 
			found = text;
1616 
	}
1617 
 
1618 
	// if we've found an english version, use that
1619 
	if ( english )
1620 
		return english;
1621 
	// otherwise try a german
1622 
	if ( german )
1623 
		return german;
1624 
	// otherwise use any we've found (usually first one)
1625 
	return found;
1626 
}
1627 
 
206 cycrow 1628 
Utils::WString CXspFile::textName(int lang)
1 cycrow 1629 
{
1630 
	SText *t = FindShipText(lang);
1631 
	if ( t )
1632 
	{
1633 
		// return the correct language text
39 cycrow 1634 
		if ( !t->sName.empty() )
1 cycrow 1635 
			return t->sName;
1636 
		// we have found a text, but there is no ship name ??
1637 
		else if ( lang != 44 )
1638 
		{
1639 
			// reget the english one
1640 
			t = FindShipText(44);
39 cycrow 1641 
			if ( t && !t->sName.empty() )
1 cycrow 1642 
				return t->sName;
1643 
		}
1644 
	}
1645 
 
1646 
	// still not found one, return the ships name
203 cycrow 1647 
	return this->shipName(lang);
1 cycrow 1648 
}
1649 
 
206 cycrow 1650 
Utils::WString CXspFile::textDescription(int lang)
1 cycrow 1651 
{
1652 
	SText *t = FindShipText(lang);
1653 
	if ( t )
1654 
	{
1655 
		// return the correct language text
39 cycrow 1656 
		if ( !t->sDesc.empty() )
1 cycrow 1657 
			return t->sDesc;
1658 
		// we have found a text, but there is no ship name ??
1659 
		else if ( lang != 44 )
1660 
		{
1661 
			// reget the english one
1662 
			t = FindShipText(44);
39 cycrow 1663 
			if ( t && !t->sDesc.empty() )
1 cycrow 1664 
				return t->sDesc;
1665 
		}
1666 
	}
1667 
 
1668 
	// still not found one, return the ships name
48 cycrow 1669 
	if ( !this->description().empty() ) return this->description();
206 cycrow 1670 
	return this->shipName(lang);
1 cycrow 1671 
}
1672 
 
35 cycrow 1673 
bool CXspFile::startExtractShip(CVirtualFileSystem *pVfs, const Utils::String &sId, CProgressInfo *pProgress)
1 cycrow 1674 
{
39 cycrow 1675 
	m_sID = sId.remove('\r');
35 cycrow 1676 
	while ( m_sID.right(1) == ";" )
1677 
		m_sID.truncate(-1);
1 cycrow 1678 
 
197 cycrow 1679 
	m_sData = pVfs->getTShipsEntry(m_sID).toString();
35 cycrow 1680 
 
1 cycrow 1681 
	// get scene files
35 cycrow 1682 
	if ( pProgress ) pProgress->UpdateStatus(IMPORTSHIP_SCENE);
1683 
	if ( !this->extractSceneFiles(pVfs) )
1 cycrow 1684 
		return false;
1685 
 
1686 
	return true;
1687 
}
1688 
 
35 cycrow 1689 
bool CXspFile::extractShip(CVirtualFileSystem *pVfs, const Utils::String &sId, CProgressInfo *progress)
1 cycrow 1690 
{
35 cycrow 1691 
	if ( !this->startExtractShip(pVfs, sId, progress) )
1 cycrow 1692 
		return false;
1693 
 
1694 
	// read the scene file and get the files list
35 cycrow 1695 
	if ( !this->processSceneFiles(pVfs, progress) )
1 cycrow 1696 
		return false;
1697 
 
1698 
	// pack all the ship files
1699 
	this->PackAllFiles();
1700 
 
1701 
	return true;
1702 
}
1703 
 
35 cycrow 1704 
bool CXspFile::extractSceneFiles(CVirtualFileSystem *pVfs)
1 cycrow 1705 
{
35 cycrow 1706 
	m_pSceneFile = pVfs->extractGameFileToPackage(this, "objects\\" + m_sData.token(";", 17) + ".pbd", FILETYPE_SHIPSCENE, "objects\\" + m_sData.token(";", 17) + ".bod");
1707 
	if ( !m_pSceneFile ) return false;
1708 
	m_pCockpitFile = pVfs->extractGameFileToPackage(this, "objects\\" + m_sData.token(";", 18) + ".pbd", FILETYPE_COCKPITSCENE, "objects\\" + m_sData.token(";", 18) + ".bod");
1 cycrow 1709 
 
1710 
	return true;
1711 
}
1712 
 
170 cycrow 1713 
bool CXspFile::readSceneModels(Utils::CStringList& out)
1 cycrow 1714 
{
1715 
	// read the scene file
170 cycrow 1716 
	if (!m_pSceneFile)
1 cycrow 1717 
		m_pSceneFile = this->GetFirstFile(FILETYPE_SHIPSCENE);
1718 
 
170 cycrow 1719 
	if (!m_pSceneFile)
1720 
		return false;
1 cycrow 1721 
 
1722 
	// check if its packed
1723 
	size_t datasize;
170 cycrow 1724 
	unsigned char* data = m_pSceneFile->UncompressData((long*)&datasize, 0);
1725 
 
1 cycrow 1726 
	// if data wasn't compressed, then copy it itself as we are editing it
1727 
	bool deleteData = false;
170 cycrow 1728 
	if (data == m_pSceneFile->GetData())
1 cycrow 1729 
	{
1730 
		data = new unsigned char[m_pSceneFile->GetDataSize()];
1731 
		memcpy(data, m_pSceneFile->GetData(), m_pSceneFile->GetDataSize());
1732 
		deleteData = true;
1733 
	}
1734 
 
170 cycrow 1735 
	if (data && datasize)
1 cycrow 1736 
	{
170 cycrow 1737 
		if (m_pSceneFile->CheckPackedExtension())
1 cycrow 1738 
			data = UnPCKData(data, datasize, &datasize);
1739 
	}
1740 
 
170 cycrow 1741 
	if (!data || !datasize)
1742 
		return false;
1 cycrow 1743 
 
1744 
	size_t pos = 0;
1745 
	bool newline = true;
1746 
	bool online = false;
170 cycrow 1747 
	while (pos < datasize)
1 cycrow 1748 
	{
1749 
		char c = data[pos];
1750 
		++pos;
1751 
 
1752 
		// skip until next line
170 cycrow 1753 
		if (!newline && !online)
1 cycrow 1754 
		{
170 cycrow 1755 
			if (c == '\n')
1 cycrow 1756 
				newline = true;
1757 
			continue;
1758 
		}
1759 
 
170 cycrow 1760 
		if (newline)
1 cycrow 1761 
		{
170 cycrow 1762 
			if (c == ' ' || c == 9 || c == '\n' || c == '\r')
1 cycrow 1763 
				continue;
1764 
 
1765 
			newline = false;
1766 
 
170 cycrow 1767 
			if (c == 'P' || c == 'p')
1 cycrow 1768 
			{
170 cycrow 1769 
				while (data[pos] == ' ') pos++;
1770 
				unsigned char* line = (data + pos);
1771 
				while (data[pos] != ' ' && data[pos] != ';') pos++;
1 cycrow 1772 
				data[pos] = '\0';
170 cycrow 1773 
				if (atoi((const char*)line) == out.size())
1 cycrow 1774 
					online = true;
1775 
			}
1776 
		}
1777 
		// this line is out model
170 cycrow 1778 
		else if (online)
1 cycrow 1779 
		{
170 cycrow 1780 
			if (c == 'B' || c == 'b')
1 cycrow 1781 
			{
170 cycrow 1782 
				while (data[pos] == ' ') pos++;
1783 
				unsigned char* line = (data + pos);
1784 
				while (data[pos] != ';') pos++;
1 cycrow 1785 
				data[pos] = '\0';
1786 
 
170 cycrow 1787 
				out.pushBack((char*)line);
1 cycrow 1788 
				online = false;
1789 
			}
1790 
		}
1791 
	}
1792 
 
170 cycrow 1793 
	if (deleteData)
1 cycrow 1794 
		delete data;
1795 
 
170 cycrow 1796 
	return true;
1 cycrow 1797 
}
1798 
 
170 cycrow 1799 
void CXspFile::extractCutData(CVirtualFileSystem *pVfs, Utils::CStringList &sceneModels, bool add)
42 cycrow 1800 
{
1801 
	std::vector<int> cuts;
170 cycrow 1802 
	for ( CListNode<SDummy> *node = m_lDummy.Front(); node; node = node->next() )
1803 
	{
42 cycrow 1804 
		Utils::String data = node->Data()->sData;
1805 
		int states = data.token(";", 3);
1806 
		for ( int i = 0; i < states; i++ ) {
1807 
			int cutid = data.token(";", (i * 2) + 5);
1808 
			if ( !cutid ) continue;
1809 
			cuts.push_back(cutid);
1810 
		}
1811 
	}
1812 
 
1813 
	if ( cuts.empty() ) return;
1814 
 
197 cycrow 1815 
	if ( pVfs->extractGameFile(L"types/CutData.pck", CPackages::tempDirectory() + L"tmp.dat").empty()) return;
42 cycrow 1816 
 
197 cycrow 1817 
	CFileIO File(CPackages::tempDirectory() + L"tmp.dat");
52 cycrow 1818 
	if ( !File.exists() ) return;
42 cycrow 1819 
 
170 cycrow 1820 
	std::vector<Utils::String> lines;
1821 
	File.readLines(lines);
42 cycrow 1822 
	int count = -1;
170 cycrow 1823 
	for (auto itr = lines.begin(); itr != lines.end(); itr++) {
1824 
		Utils::String line = *itr;
42 cycrow 1825 
		line.removeChar('\r');
1826 
		line.removeChar(' ');
1827 
		line.removeFirstSpace();
1828 
		if ( line[0] == '/' ) continue;
1829 
		if ( count == -1 ) count = line.token(";", 1);
1830 
		else {
1831 
			int max;
1832 
			Utils::String *words = line.tokenise(";", &max);
1833 
			if ( words && max ) {
1834 
				for ( int i = 0; i < max; i += 2 ) {
1835 
					int cutid = words[i];
1836 
					if ( !cutid ) continue;
1837 
					for ( std::vector<int>::iterator itr = cuts.begin(); itr != cuts.end(); itr++ ) {
1838 
						if ( (*itr) == cutid ) {
165 cycrow 1839 
							this->addCutData(words[i] + ";" + words[i + 1] + ";");
42 cycrow 1840 
							if ( add ) {
170 cycrow 1841 
								sceneModels.pushBack(words[i + 1]);
42 cycrow 1842 
							}
1843 
							break;
1844 
						}
1845 
					}
1846 
				}
1847 
				CLEANSPLIT(words, max);
1848 
			}
1849 
		}
1850 
	}
1851 
}
1852 
 
170 cycrow 1853 
void CXspFile::extractDummies(CVirtualFileSystem *pVfs, Utils::CStringList& sceneModels, bool add)
1 cycrow 1854 
{
170 cycrow 1855 
	if (sceneModels.empty()) return;
31 cycrow 1856 
 
1857 
	bool extracted = false;
197 cycrow 1858 
	if ( !pVfs->extractGameFile(L"types/dummies.pck", CPackages::tempDirectory() + L"tmp.dat").empty()) {
1859 
		CFileIO File(CPackages::tempDirectory() + L"tmp.dat");
52 cycrow 1860 
		if ( File.exists() )
1 cycrow 1861 
		{
39 cycrow 1862 
			Utils::String section;
1 cycrow 1863 
			int secCount = 0;
170 cycrow 1864 
			std::vector<Utils::String> lines;
1865 
			if (File.readLines(lines))
1 cycrow 1866 
			{
170 cycrow 1867 
				for(auto itr = lines.begin(); itr != lines.end(); itr++)
1868 
				{
1869 
					Utils::String str = itr->remove(9).remove('\r');
1870 
					str.removeFirstSpace();
1871 
					if (str.empty())
1872 
						continue;
1873 
					if (str[0] == '/')
1874 
						continue;
1 cycrow 1875 
 
170 cycrow 1876 
					// not in a section yet
1877 
					if (secCount <= 0)
1 cycrow 1878 
					{
170 cycrow 1879 
						section = str.token(";", 1);
1880 
						secCount = str.token(";", 2).toInt();
1881 
					}
1882 
					else
1883 
					{
1884 
						Utils::String first = str.token(";", 1);
1885 
						if (sceneModels.contains(first))
1886 
						{
1887 
							this->AddDummy(section, str);
1 cycrow 1888 
 
170 cycrow 1889 
							if (add)
1 cycrow 1890 
							{
170 cycrow 1891 
								int pos = 4;
1892 
								int scene = str.token(";", 3).toInt();
1893 
								for (int i = 0; i < scene; i++)
1894 
								{
1895 
									sceneModels.pushBack(str.token(";", 5 + (i * 2)));
1896 
									pos += 2;
1897 
								}
1898 
 
1899 
								int model = str.token(";", pos).toInt();
1900 
								for (int i = 0; i < model; i++)
1901 
									sceneModels.pushBack(str.token(";", pos + (i * 2) + 1));
1 cycrow 1902 
							}
170 cycrow 1903 
						}
1904 
						--secCount;
1 cycrow 1905 
 
1906 
					}
1907 
				}
1908 
			}
1909 
 
52 cycrow 1910 
			File.remove();
1 cycrow 1911 
		}
1912 
	}
1913 
}
1914 
 
170 cycrow 1915 
void CXspFile::extractComponants(CVirtualFileSystem *pVfs, const Utils::CStringList& sceneModels)
1 cycrow 1916 
{
170 cycrow 1917 
	if (sceneModels.empty()) return;
197 cycrow 1918 
	if ( !pVfs->extractGameFile(L"types/components.pck", CPackages::tempDirectory() + L"tmp.dat").empty())
1 cycrow 1919 
	{
197 cycrow 1920 
		CFileIO File(CPackages::tempDirectory() + L"tmp.dat");
52 cycrow 1921 
		if ( File.exists() )
1 cycrow 1922 
		{
39 cycrow 1923 
			Utils::String file;
1924 
			Utils::String section;
1 cycrow 1925 
			int secCount = 0;
1926 
			int secCount2 = 0;
170 cycrow 1927 
			std::vector<Utils::String> lines;
1928 
			if (File.readLines(lines))
1 cycrow 1929 
			{
170 cycrow 1930 
				for(auto itr = lines.begin(); itr != lines.end(); itr++)
1931 
				{
1932 
					Utils::String str = itr->remove(9).remove('\r');
1933 
					str.removeFirstSpace();
1934 
					if (str.empty())
1935 
						continue;
1936 
					if (str[0] == '/')
1937 
						continue;
1 cycrow 1938 
 
170 cycrow 1939 
					// not in a section yet
1940 
					if (secCount2)
1941 
					{
1942 
						if (sceneModels.contains(file))
1943 
							this->AddComponent(section, file, str);
1944 
						--secCount2;
1945 
					}
1946 
					else if (secCount <= 0)
1947 
					{
1948 
						section = str.token(";", 1);
1949 
						secCount = str.token(";", 2).toInt();
1950 
					}
1951 
					else
1952 
					{
1953 
						file = str.token(";", 1);
1954 
						secCount2 = str.token(";", 2).toInt();
1955 
						--secCount;
1956 
					}
1 cycrow 1957 
				}
1958 
			}
1959 
 
52 cycrow 1960 
			File.remove();
1 cycrow 1961 
		}
1962 
	}
1963 
}
1964 
 
197 cycrow 1965 
bool CXspFile::getTextureList(Utils::WStringList &list, const unsigned char *olddata, size_t size) const
1 cycrow 1966 
{
1967 
	if ( !olddata || !size )
1968 
		return false;
1969 
 
1970 
	size_t startLine = 0;
114 cycrow 1971 
	Utils::String line;
1 cycrow 1972 
	size_t pos = 0;
1973 
 
1974 
	unsigned char *data = new unsigned char[size];
1975 
	memcpy(data, olddata, size);
1976 
 
1977 
	while ( (pos++) < size )
1978 
	{
1979 
		if ( data[pos] == '\n' )
1980 
		{
1981 
			data[pos] = '\0';
1982 
			line = (char *)(data + startLine);
114 cycrow 1983 
			line.removeChar(9);
1984 
			line.removeChar('\r');
1985 
			line.removeFirstSpace();
1 cycrow 1986 
 
114 cycrow 1987 
			if ( !line.empty() && line[0] != '/' )
1 cycrow 1988 
			{
114 cycrow 1989 
				Utils::String first = line.token(":", 1);
1 cycrow 1990 
				if ( first.Compare("MATERIAL6") )
1991 
				{
1992 
					int max;
114 cycrow 1993 
					Utils::String material = line.tokens(":", 2);
1994 
					Utils::String *strs = material.tokens(";", 6).tokenise("; ", &max);
1 cycrow 1995 
 
114 cycrow 1996 
					int num = material.token(";", 5);
1 cycrow 1997 
					if ( strs && max >= 2)
1998 
					{
114 cycrow 1999 
						for(int i = 0; i < max; i++) {
2000 
							Utils::String type = strs[i].token(";", 1);
2001 
							Utils::String valtype = strs[i].token(";", 2);
2002 
							if ( valtype.Compare("SPTYPE_STRING") ) {
2003 
								Utils::String file = strs[i].token(";", 3);
170 cycrow 2004 
								if(!list.contains(file))
2005 
									list.pushBack(file, "");
114 cycrow 2006 
							}
2007 
						}
1 cycrow 2008 
					}
2009 
 
2010 
					CLEANSPLIT(strs, max)
2011 
				}
2012 
			}
2013 
 
2014 
			startLine = pos + 1;
2015 
		}
2016 
	}
2017 
 
2018 
	delete [] data;
2019 
 
2020 
	return true;
2021 
}
2022 
 
35 cycrow 2023 
void CXspFile::extractTextures(CVirtualFileSystem *pVfs)
1 cycrow 2024 
{
197 cycrow 2025 
	Utils::WStringList lTextures;
1 cycrow 2026 
 
2027 
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
2028 
	{
2029 
		C_File *f = node->Data();
2030 
		if ( f->GetFileType() != FILETYPE_SHIPMODEL )
2031 
			continue;
2032 
 
115 cycrow 2033 
		bool deleteData = false;
114 cycrow 2034 
		unsigned char *data = NULL;
2035 
		size_t size;
2036 
 
1 cycrow 2037 
		// cant do these yet
197 cycrow 2038 
		if (f->checkFileExt(L"pbb") || f->checkFileExt(L"bob"))
1 cycrow 2039 
		{
115 cycrow 2040 
			data = f->BobDecompile(&size);
2041 
			if ( !data || !size ) {
114 cycrow 2042 
				// search for the pbd or bod files that match and use them instead
197 cycrow 2043 
				Utils::WString file;
114 cycrow 2044 
 
197 cycrow 2045 
				file = CFileIO(f->getNameDirectory(NULL)).changeFileExtension(L"pbd");
2046 
				file = pVfs->extractGameFile(file, CPackages::tempDirectory() + L"tmp.tmp");
114 cycrow 2047 
 
2048 
				if ( file.empty() ) {
197 cycrow 2049 
					file = CFileIO(f->getNameDirectory(NULL)).changeFileExtension(L"bod");
2050 
					file = pVfs->extractGameFile(file, CPackages::tempDirectory() + L"tmp.tmp");
114 cycrow 2051 
				}
2052 
 
2053 
				if ( !file.empty() ) {
2054 
					CFileIO File(file);
2055 
					if ( File.exists() ) {
2056 
						data = File.readAll(&size);
2057 
						File.remove();
2058 
					}
2059 
				}
2060 
 
2061 
				if ( data && size )
170 cycrow 2062 
					this->getTextureList(lTextures, data, size);
1 cycrow 2063 
				continue;
114 cycrow 2064 
			}
1 cycrow 2065 
 
115 cycrow 2066 
			deleteData = true;
1 cycrow 2067 
		}
2068 
 
115 cycrow 2069 
		if ( !data || !size ) {
2070 
			if ( !f->GetData() )
2071 
			{
2072 
				if ( !f->ReadFromFile() )
2073 
					continue;
2074 
			}
1 cycrow 2075 
 
115 cycrow 2076 
 
178 cycrow 2077 
			if ( f->checkFileExt("pbb") || f->checkFileExt("pbd") )
115 cycrow 2078 
				data = f->UnPCKFile(&size);
2079 
			else
2080 
			{
2081 
				data = f->GetData();
2082 
				size = f->GetDataSize();
2083 
			}
1 cycrow 2084 
		}
170 cycrow 2085 
		this->getTextureList(lTextures, data, size);
1 cycrow 2086 
 
115 cycrow 2087 
		if ( deleteData ) delete data;
1 cycrow 2088 
	}
2089 
 
170 cycrow 2090 
	for(auto itr = lTextures.begin(); itr != lTextures.end(); itr++)
1 cycrow 2091 
	{
170 cycrow 2092 
		CFileIO F((*itr)->str);
196 cycrow 2093 
		if ( F.isFileExtension(L"fx") ) {
116 cycrow 2094 
			/*
2095 
			if ( !pVfs->extractGameFileToPackage(this, "shader\\1_1\\" + Utils::String(node->str.ToString()), FILETYPE_SHIPOTHER) )
2096 
				pVfs->extractGameFileToPackage(this, "shader\\1_1\\" + CFileIO(node->str.ToString()).ChangeFileExtension("fb").ToString(), FILETYPE_SHIPOTHER);
2097 
			if ( !pVfs->extractGameFileToPackage(this, "shader\\1_4\\" + Utils::String(node->str.ToString()), FILETYPE_SHIPOTHER) )
2098 
				pVfs->extractGameFileToPackage(this, "shader\\1_4\\" + CFileIO(node->str.ToString()).ChangeFileExtension("fb").ToString(), FILETYPE_SHIPOTHER);
2099 
			if ( !pVfs->extractGameFileToPackage(this, "shader\\2_0\\" + Utils::String(node->str.ToString()), FILETYPE_SHIPOTHER) )
2100 
				pVfs->extractGameFileToPackage(this, "shader\\2_0\\" + CFileIO(node->str.ToString()).ChangeFileExtension("fb").ToString(), FILETYPE_SHIPOTHER);
2101 
			if ( !pVfs->extractGameFileToPackage(this, "shader\\2_a\\" + Utils::String(node->str.ToString()), FILETYPE_SHIPOTHER) )
2102 
				pVfs->extractGameFileToPackage(this, "shader\\2_a\\" + CFileIO(node->str.ToString()).ChangeFileExtension("fb").ToString(), FILETYPE_SHIPOTHER);
2103 
			if ( !pVfs->extractGameFileToPackage(this, "shader\\2_b\\" + Utils::String(node->str.ToString()), FILETYPE_SHIPOTHER) )
2104 
				pVfs->extractGameFileToPackage(this, "shader\\2_b\\" + CFileIO(node->str.ToString()).ChangeFileExtension("fb").ToString(), FILETYPE_SHIPOTHER);
2105 
			if ( !pVfs->extractGameFileToPackage(this, "shader\\3_0\\" + Utils::String(node->str.ToString()), FILETYPE_SHIPOTHER) )
2106 
				pVfs->extractGameFileToPackage(this, "shader\\3_0\\" + CFileIO(node->str.ToString()).ChangeFileExtension("fb").ToString(), FILETYPE_SHIPOTHER);
2107 
				*/
114 cycrow 2108 
		}
2109 
		else {
197 cycrow 2110 
			if ( pVfs->extractGameFileToPackage(this, L"dds\\" + (*itr)->str, FILETYPE_SHIPOTHER) )
116 cycrow 2111 
				continue;
2112 
 
197 cycrow 2113 
			if ( pVfs->extractGameFileToPackage(this, L"dds\\" + (*itr)->str.token(L".", -1), FILETYPE_SHIPOTHER) )
116 cycrow 2114 
				continue;
2115 
 
197 cycrow 2116 
			if ( pVfs->extractGameFileToPackage(this, L"dds\\" + (*itr)->str + L".dds", FILETYPE_SHIPOTHER) )
116 cycrow 2117 
				continue;
2118 
 
197 cycrow 2119 
			if ( pVfs->extractGameFileToPackage(this, L"dds\\" + F.changeFileExtension(L"dds"), FILETYPE_SHIPOTHER) )
116 cycrow 2120 
				continue;
2121 
 
197 cycrow 2122 
			if ( pVfs->extractGameFileToPackage(this, L"textures\\" + (*itr)->str, FILETYPE_SHIPOTHER) )
116 cycrow 2123 
				continue;
2124 
 
197 cycrow 2125 
			if ( pVfs->extractGameFileToPackage(this, L"textures\\" + (*itr)->str.token(L".", -1), FILETYPE_SHIPOTHER) )
116 cycrow 2126 
				continue;
2127 
 
197 cycrow 2128 
			if ( pVfs->extractGameFileToPackage(this, L"textures\\" + (*itr)->str + L".jpg", FILETYPE_SHIPOTHER) )
116 cycrow 2129 
				continue;
2130 
 
197 cycrow 2131 
			if ( pVfs->extractGameFileToPackage(this, L"textures\\" + F.changeFileExtension(L"jpg"), FILETYPE_SHIPOTHER) )
116 cycrow 2132 
				continue;
114 cycrow 2133 
		}
1 cycrow 2134 
	}
2135 
}
2136 
 
197 cycrow 2137 
bool CXspFile::addTextFromFile(const Utils::WString &sFile, int textId)
1 cycrow 2138 
{
197 cycrow 2139 
	Utils::WString file = sFile;
39 cycrow 2140 
 
1 cycrow 2141 
	bool remove = false;
196 cycrow 2142 
	if ( CFileIO(file).isFileExtension(L"pck") )
1 cycrow 2143 
	{
39 cycrow 2144 
		C_File F;
170 cycrow 2145 
		F.setFilename(file);
1 cycrow 2146 
		F.UnPCKFile();
197 cycrow 2147 
		if (F.writeToFile(CPackages::tempDirectory() + L"tmp.dat"))
1 cycrow 2148 
		{
2149 
			remove = true;
197 cycrow 2150 
			file = CPackages::tempDirectory() + L"tmp.dat";
1 cycrow 2151 
		}
2152 
	}
2153 
 
78 cycrow 2154 
	/*
68 cycrow 2155 
	std::wfstream fileStream(file.c_str());
2156 
	if ( fileStream.is_open() ) {
2157 
		while(!fileStream.eof()) {
2158 
			std::wstring line;
2159 
			std::getline(fileStream, line);
2160 
			int i =0;
2161 
		}
2162 
		fileStream.close();
2163 
	}
78 cycrow 2164 
	*/
68 cycrow 2165 
 
118 cycrow 2166 
	CFileIO F(file);
2167 
	if ( F.exists() && F.startRead() ) {
2168 
		bool ret = this->_addTextFromFile(F, textId);
2169 
		F.close();
1 cycrow 2170 
 
52 cycrow 2171 
		if ( remove ) CFileIO::Remove(file);
50 cycrow 2172 
		_changed();
1 cycrow 2173 
		return ret;
2174 
	}
2175 
 
2176 
	return false;
2177 
}
2178 
 
170 cycrow 2179 
bool CXspFile::importBodies(const Utils::CStringList &sceneModels, const Utils::String &filename)
1 cycrow 2180 
{
2181 
	CFileIO File(filename);
52 cycrow 2182 
	if ( File.exists() )
1 cycrow 2183 
	{
39 cycrow 2184 
		Utils::String sSection;
1 cycrow 2185 
		int section = 0;
170 cycrow 2186 
		std::vector<Utils::String> lines;
2187 
		if (File.readLines(lines))
1 cycrow 2188 
		{
170 cycrow 2189 
			for(auto itr = lines.begin(); itr != lines.end(); itr++)
1 cycrow 2190 
			{
170 cycrow 2191 
				Utils::String l = *itr;
2192 
				l.removeChar(9);
2193 
				l.removeChar('\r');
2194 
				l.removeFirstSpace();
2195 
				if (l.empty())
2196 
					continue;
2197 
				if (l[0] == '/')
2198 
					continue;
2199 
 
2200 
				// are we looking for a section
2201 
				if (section <= 0)
1 cycrow 2202 
				{
170 cycrow 2203 
					sSection = l.token(";", 1);
2204 
					section = l.token(";", 2).toInt();
2205 
				}
2206 
				else
2207 
				{
2208 
					int max;
2209 
					Utils::String* strs = l.tokenise(";", &max);
2210 
					if (strs && max)
1 cycrow 2211 
					{
170 cycrow 2212 
						for (int i = 0; i < max; i++)
2213 
						{
2214 
							strs[i].removeEndSpace();
2215 
							strs[i].removeFirstSpace();
2216 
							if (strs[i].empty())
2217 
								continue;
2218 
							if (sceneModels.contains(strs[i]))
2219 
								this->addBody(sSection, strs[i]);
2220 
							--section;
2221 
						}
1 cycrow 2222 
					}
170 cycrow 2223 
					CLEANSPLIT(strs, max)
1 cycrow 2224 
				}
2225 
			}
170 cycrow 2226 
			return true;
1 cycrow 2227 
		}
2228 
	}
2229 
 
2230 
	return false;
2231 
}
2232 
 
39 cycrow 2233 
bool CXspFile::ImportCockpits(const Utils::String &filename)
1 cycrow 2234 
{
2235 
	CFileIO File(filename);
52 cycrow 2236 
	if ( File.exists() )
1 cycrow 2237 
	{
170 cycrow 2238 
		std::vector<Utils::String> lines;
2239 
		if (File.readLines(lines))
1 cycrow 2240 
		{
170 cycrow 2241 
			int entries = 0;
2242 
			auto itr = lines.begin();
2243 
			while(itr != lines.end())
1 cycrow 2244 
			{
170 cycrow 2245 
				Utils::String str = itr->remove(9).remove('\r');
2246 
				str.removeFirstSpace();
2247 
				if (str.empty())
2248 
					itr = lines.erase(itr);
2249 
				else if (str[0] == '/')
2250 
					itr = lines.erase(itr);
2251 
				else if (!entries)
2252 
				{
2253 
					entries = str.token(";", 2).toInt();
2254 
					itr = lines.erase(itr);
2255 
				}
2256 
				else
2257 
					itr++;
1 cycrow 2258 
			}
2259 
 
170 cycrow 2260 
			// now get all the entries from TShips
2261 
			for (int i = 0; i < 6; i++)
1 cycrow 2262 
			{
170 cycrow 2263 
				int idx = m_sData.token(";", 32 + (i * 2));
2264 
				if (static_cast<size_t>(idx) < lines.size() && idx)
2265 
				{
2266 
					Utils::String turret = lines[idx];
2267 
					int pos = -1;
2268 
					Utils::String id;
2269 
					while (id.empty() && pos > -100) id = turret.token(";", pos--);
2270 
					m_sData = m_sData.replaceToken(";", 32 + (i * 2), id + "(" + (long)idx + ")");
1 cycrow 2271 
 
170 cycrow 2272 
					this->AddCockpit(turret, 0);
2273 
				}
1 cycrow 2274 
			}
2275 
		}
2276 
		return true;
2277 
	}
2278 
	return false;
2279 
}
2280 
 
35 cycrow 2281 
bool CXspFile::extractCockpits(CVirtualFileSystem *pVfs)
1 cycrow 2282 
{
197 cycrow 2283 
	if ( !pVfs->extractGameFile(L"types/TCockpits.pck", CPackages::tempDirectory() + L"tmp.dat").empty() ) {
2284 
		bool ret = this->ImportCockpits((CPackages::tempDirectory() + L"tmp.dat").toString());
2285 
		CFileIO::Remove(CPackages::tempDirectory() + L"tmp.dat");
1 cycrow 2286 
 
2287 
		return ret;
2288 
	}
2289 
 
2290 
	return false;
2291 
}
2292 
 
170 cycrow 2293 
bool CXspFile::extractBodies(CVirtualFileSystem *pVfs, const Utils::CStringList &sceneModels)
1 cycrow 2294 
{
170 cycrow 2295 
	if (sceneModels.empty()) return false;
31 cycrow 2296 
 
197 cycrow 2297 
	if ( !pVfs->extractGameFile(L"types/Bodies.pck", CPackages::tempDirectory() + L"tmp.dat").empty() ) {
2298 
		bool ret = this->importBodies(sceneModels, (CPackages::tempDirectory() + L"tmp.dat").toString());
2299 
		CFileIO::Remove(CPackages::tempDirectory() + L"tmp.dat");
1 cycrow 2300 
 
2301 
		return ret;
2302 
	}
2303 
 
2304 
	return false;
2305 
}
2306 
 
118 cycrow 2307 
bool CXspFile::_addTextFromFile(CFileIO &F, int textId)
1 cycrow 2308 
{
14 cycrow 2309 
	if ( textId == -1 && !m_sData.empty() )
2310 
		textId = m_sData.token(";", 7);
1 cycrow 2311 
 
2312 
	if ( textId <= 0 )
2313 
		return false;
2314 
 
118 cycrow 2315 
	if ( !F.isOpened() )
1 cycrow 2316 
		return false;
2317 
 
2318 
	bool added = false;
2319 
 
39 cycrow 2320 
	Utils::String shipName;
2321 
	Utils::String shipDesc;
1 cycrow 2322 
 
68 cycrow 2323 
	int lastAddedGameID = 0;
2324 
	int currentGameID = 0;
1 cycrow 2325 
	int lang = 0;
2326 
	bool inpage = false;
118 cycrow 2327 
 
2328 
	while(!F.atEnd()) {
39 cycrow 2329 
		if ( !shipName.empty() && !shipDesc.empty() )
1 cycrow 2330 
		{
2331 
			added = true;
2332 
			break;
2333 
		}
2334 
 
197 cycrow 2335 
		Utils::String line = F.readEndOfLineStr();
39 cycrow 2336 
		line.removeChar(9);
2337 
		line.removeChar('\r');
2338 
		line.removeFirstSpace();
118 cycrow 2339 
 
1 cycrow 2340 
		if ( inpage )
2341 
		{
68 cycrow 2342 
			if ( line.left(6).Compare("</page") ) {
2343 
				inpage = false;
2344 
				continue;
2345 
			}
1 cycrow 2346 
 
2347 
			// find matching id
39 cycrow 2348 
			if ( line.left(6).Compare("<t id=") )
1 cycrow 2349 
			{
39 cycrow 2350 
				int pos = line.findPos("id=\"", 0);
1 cycrow 2351 
				if ( pos != -1 )
2352 
				{
68 cycrow 2353 
					pos += 4;
2354 
					int endpos = line.findPos("\"", pos);
1 cycrow 2355 
					if ( endpos != -1 )
2356 
					{
68 cycrow 2357 
						int id = line.mid(pos, endpos);
1 cycrow 2358 
						if ( id == textId || id == (textId + 1) )
2359 
						{
39 cycrow 2360 
							pos = line.findPos(">", endpos);
1 cycrow 2361 
							if ( pos != -1 )
2362 
							{
39 cycrow 2363 
								endpos = line.findPos("</t>", pos);
1 cycrow 2364 
								if ( endpos != -1 )
2365 
								{
2366 
									if ( id == textId )
68 cycrow 2367 
										shipName = line.mid(pos + 1, endpos);
1 cycrow 2368 
									else
68 cycrow 2369 
										shipDesc = line.mid(pos + 1, endpos);
2370 
									lastAddedGameID = currentGameID;
1 cycrow 2371 
								}
2372 
							}
2373 
						}
2374 
					}
2375 
				}
2376 
			}
2377 
		}
2378 
		else if ( lang ) // search for page 17
2379 
		{
39 cycrow 2380 
			if ( line.left(8).Compare("<page id") )
1 cycrow 2381 
			{
39 cycrow 2382 
				int pos = line.findPos("id=\"");
1 cycrow 2383 
				if ( pos != -1 )
2384 
				{
68 cycrow 2385 
					pos += 4;
2386 
					int endpos = line.findPos("\"", pos);
1 cycrow 2387 
					if ( endpos != -1 )
2388 
					{
68 cycrow 2389 
						Utils::String sId = line.mid(pos, endpos);
39 cycrow 2390 
						int id = sId;
68 cycrow 2391 
						if ( sId.length() > 4 ) {
2392 
							id = sId.right(4);
2393 
							currentGameID = sId.left(sId.length() - 4);
2394 
						}
2395 
 
2396 
						if ( currentGameID >= lastAddedGameID && id == 17 )
1 cycrow 2397 
							inpage = true;
2398 
					}
2399 
				}
2400 
			}
2401 
		}
39 cycrow 2402 
		else if ( line.left(12).Compare("<language id") )
1 cycrow 2403 
		{
39 cycrow 2404 
			int pos = line.findPos("id=\"");
1 cycrow 2405 
			if ( pos != -1 )
2406 
			{
68 cycrow 2407 
				// move past the id=
2408 
				pos += 4;
2409 
 
2410 
				Utils::String s = line.right(-pos);
2411 
				Utils::String s2 = line.mid(pos, -1);
2412 
				int endpos = line.findPos("\"", pos);
1 cycrow 2413 
				if ( endpos != -1 )
68 cycrow 2414 
					lang = line.mid(pos, endpos);
1 cycrow 2415 
			}
2416 
		}
2417 
	}
2418 
 
2419 
	// incase we only found the shipname
39 cycrow 2420 
	if ( !shipName.empty() )
1 cycrow 2421 
		added = true;
2422 
 
2423 
	if ( added )
2424 
	{
50 cycrow 2425 
		if ( lang == 44 || this->name().empty())
1 cycrow 2426 
		{
50 cycrow 2427 
			this->setName(shipName);
48 cycrow 2428 
			this->setDescription(shipDesc.findReplace("&amp", "&"));
1 cycrow 2429 
		}
2430 
		this->AddText(lang, shipName, shipDesc);
2431 
		return true;
2432 
	}
2433 
 
2434 
	return false;
2435 
}
2436 
 
31 cycrow 2437 
void CXspFile::ExtractTexts(CCatFile *catFile, CCatFile *secondCatFile, int textId)
1 cycrow 2438 
{
124 cycrow 2439 
	for (auto itr = catFile->GetFiles()->begin(); itr != catFile->GetFiles()->end(); itr++ )
1 cycrow 2440 
	{
124 cycrow 2441 
		SInCatFile *f = *itr;
2442 
		if ( !f->sFile.left(2).Compare("t\\") && !f->sFile.left(2).Compare("t/") )
1 cycrow 2443 
			continue;
2444 
 
2445 
		// extract the text file and read in the data
181 cycrow 2446 
		bool extracted = catFile->extractFile(f->sFile, CPackages::tempDirectory() + "/tmp.dat");
2447 
		if ( !extracted && secondCatFile ) extracted = secondCatFile->extractFile(f->sFile, CPackages::tempDirectory() + "/tmp.dat");
31 cycrow 2448 
		if ( extracted ) {
197 cycrow 2449 
			this->addTextFromFile(CPackages::tempDirectory() + L"/tmp.dat", textId);
2450 
			CFileIO::Remove(CPackages::tempDirectory() + L"/tmp.dat");
1 cycrow 2451 
		}
2452 
	}
2453 
}
2454 
 
170 cycrow 2455 
bool CXspFile::processSceneFileSection(int section, CVirtualFileSystem *pVfs, Utils::CStringList &lModels, CProgressInfo *progress)
1 cycrow 2456 
{
2457 
	if ( progress ) progress->UpdateStatus(section);
2458 
 
2459 
	switch ( section )
2460 
	{
2461 
		case IMPORTSHIP_COMPONANT:
170 cycrow 2462 
			if (lModels.empty()) return false;
35 cycrow 2463 
			this->extractComponants(pVfs, lModels);
1 cycrow 2464 
			break;
2465 
 
2466 
		case IMPORTSHIP_MODELS:
2467 
			{
170 cycrow 2468 
				if (lModels.empty()) return false;
2469 
				for(auto itr = lModels.begin(); itr != lModels.end(); itr++)
1 cycrow 2470 
				{
170 cycrow 2471 
					if ((*itr)->str.isNumber() ) // count be componants or dummy
1 cycrow 2472 
						continue;
170 cycrow 2473 
					if ( pVfs->extractGameFileToPackage(this, "objects\\" + (*itr)->str + ".pbb", FILETYPE_SHIPMODEL, "objects\\" + (*itr)->str + ".bob") )
1 cycrow 2474 
						continue;
170 cycrow 2475 
					if ( pVfs->extractGameFileToPackage(this, "objects\\" + (*itr)->str + ".pbd", FILETYPE_SHIPMODEL, "objects\\" + (*itr)->str + ".bod") )
1 cycrow 2476 
						continue;
2477 
				}
2478 
			}
2479 
			break;
2480 
 
2481 
		case IMPORTSHIP_DUMMIES:
170 cycrow 2482 
			if (lModels.empty()) return false;
35 cycrow 2483 
			this->extractDummies(pVfs, lModels, true);
42 cycrow 2484 
			this->extractCutData(pVfs, lModels, true);
1 cycrow 2485 
			break;
2486 
 
2487 
		// extract the textures
2488 
		case IMPORTSHIP_TEXTURES:
35 cycrow 2489 
			this->extractTextures(pVfs);
1 cycrow 2490 
			break;
2491 
 
2492 
		case IMPORTSHIP_TEXTS:
2493 
			// extract the text file entries
35 cycrow 2494 
			pVfs->extractTexts(this, m_sData.token(";", 7));
1 cycrow 2495 
			break;
2496 
 
2497 
		case IMPORTSHIP_BODIES:
2498 
			// extract the bodies entries
170 cycrow 2499 
			if (lModels.empty()) return false;
35 cycrow 2500 
			this->extractBodies(pVfs, lModels);
1 cycrow 2501 
			break;
2502 
 
2503 
		case IMPORTSHIP_COCKPITS:
2504 
			// extract the cockpit entries
35 cycrow 2505 
			this->extractCockpits(pVfs);
1 cycrow 2506 
			break;
2507 
	}
2508 
 
2509 
	return true;
2510 
}
2511 
 
35 cycrow 2512 
bool CXspFile::processSceneFiles(CVirtualFileSystem *pVfs, CProgressInfo *progress)
1 cycrow 2513 
{
2514 
	// now lets parse our files
2515 
	if ( progress ) progress->UpdateStatus(IMPORTSHIP_EXTRACTSCENE);
170 cycrow 2516 
	Utils::CStringList lModels;
2517 
	if(!readSceneModels(lModels))
1 cycrow 2518 
		return false;
2519 
 
2520 
	// extract componants, and add extra items to list
35 cycrow 2521 
	if ( !this->processSceneFileSection(IMPORTSHIP_COMPONANT, pVfs, lModels, progress) )
1 cycrow 2522 
		return false;
2523 
 
2524 
	//lets first find any model files
35 cycrow 2525 
	if ( !this->processSceneFileSection(IMPORTSHIP_MODELS, pVfs, lModels, progress) )
1 cycrow 2526 
		return false;
2527 
 
2528 
	// extract the dummies
35 cycrow 2529 
	if ( !this->processSceneFileSection(IMPORTSHIP_DUMMIES, pVfs, lModels, progress) )
1 cycrow 2530 
		return false;
2531 
 
2532 
	// extract the textures
35 cycrow 2533 
	if ( !this->processSceneFileSection(IMPORTSHIP_TEXTURES, pVfs, lModels, progress) )
1 cycrow 2534 
		return false;
2535 
 
2536 
	// extract the text file entries
35 cycrow 2537 
	if ( !this->processSceneFileSection(IMPORTSHIP_TEXTS, pVfs, lModels, progress) )
1 cycrow 2538 
		return false;
2539 
 
2540 
	// extract the bodies entries
35 cycrow 2541 
	if ( !this->processSceneFileSection(IMPORTSHIP_BODIES, pVfs, lModels, progress) )
1 cycrow 2542 
		return false;
2543 
 
2544 
	// extract the cockpit entries
35 cycrow 2545 
	if ( !this->processSceneFileSection(IMPORTSHIP_COCKPITS, pVfs, lModels, progress) )
1 cycrow 2546 
		return false;
2547 
 
2548 
	return true;
2549 
}
2550 
 
2551 
 
2552 
void CXspFile::PackAllFiles()
2553 
{
2554 
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
2555 
	{
2556 
		C_File *f = node->Data();
2557 
		if ( f->GetFileType() == FILETYPE_SHIPSCENE || f->GetFileType() == FILETYPE_COCKPITSCENE || f->GetFileType() == FILETYPE_SHIPMODEL || f->GetFileType() == FILETYPE_SHIPOTHER )
41 cycrow 2558 
		{
2559 
			/*
1 cycrow 2560 
			if ( f->CheckFileExt("bod") )
2561 
			{
2562 
				if ( f->PCKFile() )
2563 
					f->ChangeFileExt("pbd");
41 cycrow 2564 
			}
42 cycrow 2565 
 
178 cycrow 2566 
			else */if ( f->checkFileExt("bob") )
1 cycrow 2567 
			{
2568 
				if ( f->PCKFile() )
178 cycrow 2569 
					f->changeFileExt("pbb");
42 cycrow 2570 
			}
1 cycrow 2571 
		}
2572 
	}
2573 
}
2574 
 
2575 
void CXspFile::AdjustCockpits()
2576 
{
2577 
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
2578 
	{
2579 
		SCockpit *c = node->Data();
2580 
		if ( c->iIndex < 0 )
2581 
			continue;
2582 
 
39 cycrow 2583 
		Utils::String id = c->sCockpit.token(";", 19);
1 cycrow 2584 
 
2585 
		for ( int i = 0; i < 6; i++ )
2586 
		{
39 cycrow 2587 
			Utils::String tId = m_sData.token(";", 32 + (i * 2));
2588 
			if ( tId.isNumber() && ((int)tId) == c->iIndex )
50 cycrow 2589 
				m_sData = m_sData.replaceToken(";", 32 + (i * 2), (id + "(" + Utils::String::Number(c->iIndex) + ")").c_str());
1 cycrow 2590 
		}
2591 
	}
2592 
}
2593 
 
170 cycrow 2594 
Utils::String CXspFile::formatShipData(const Utils::CStringList &cockpits, int *text, int game)
1 cycrow 2595 
{
39 cycrow 2596 
	Utils::String data = (game == GAME_X3) ? this->GetX3ShipData() : this->GetTCShipData();
1 cycrow 2597 
	// do turrets
2598 
	for ( int t = 0; t < 6; t++ )
2599 
	{
2600 
		int oldPos = 0;
39 cycrow 2601 
		Utils::String turret = data.token(";", 32 + (t * 2));
2602 
		if ( !turret.isNumber() )
1 cycrow 2603 
		{
39 cycrow 2604 
			if ( turret.isin("(") )
1 cycrow 2605 
			{
39 cycrow 2606 
				oldPos = turret.tokens("(", 2).token(")", 1);
2607 
				turret = turret.token("(", 1);
1 cycrow 2608 
			}
170 cycrow 2609 
			int pos = cockpits.findPos(turret);
1 cycrow 2610 
			if ( pos < 0 )	pos = oldPos;
170 cycrow 2611 
			if (static_cast<size_t>(pos) >= cockpits.size()) pos = 0;
39 cycrow 2612 
			data = data.replaceToken(";", 32 + (t * 2), (long)pos);
1 cycrow 2613 
		}
2614 
	}
2615 
	// adjust the weapons
2616 
	int mask = this->GetLaserMask(game - 1);
2617 
	if ( mask != -1 )
39 cycrow 2618 
		data = data.replaceToken(";", 19, (long)mask);
1 cycrow 2619 
	mask = this->GetMissileMask(game - 1);
2620 
	if ( mask != -1 )
39 cycrow 2621 
		data = data.replaceToken(";", 25, (long)mask);
1 cycrow 2622 
 
2623 
	// fix the ship text
2624 
	if ( m_iOrgDesc > 0 )
2625 
		(*text) = m_iOrgDesc;
39 cycrow 2626 
	data = data.replaceToken(";", 7, (long)*text);
1 cycrow 2627 
 
2628 
	// add the ware id
39 cycrow 2629 
	data.removeChar(9);
2630 
	data.removeEndSpace();
1 cycrow 2631 
	// remove the end ;
39 cycrow 2632 
	while ( data.right(1) == ";" ) data.truncate(-1);
2633 
	data = data.replaceToken(";", data.countToken(";"), this->GetShipID());
2634 
	if ( data.right(1) != ";" )
1 cycrow 2635 
		data += ";";
2636 
 
2637 
	return data;
35 cycrow 2638 
}
2639