WebSVN – spk – Diff – //libspk/src/XspFile.cpp



 
	return name;
}
 
//TODO: split this up
bool CXspFile::convertOld(const Utils::WString &file)
{
	// open the file
	FILE *id = _wfopen(file.c_str(), L"rb");
	if ( !id )
		return false;
 
	// read to memory
	fseek(id, 0, SEEK_END);

 
	// uncompress the file
	size_t len;
	unsigned char *compr = LZMADecode_C ( data, size, &len, NULL );
 
	delete[] data;
 
	if ( !compr )
		return false;
 
	this->Delete();

	while ( pos < len )
	{
		while ( compr[pos++] != '\n' && pos < len );
 
		compr[pos - 1] = '\0';
		Utils::WString line = Utils::WString::FromString((char *)(compr + start));
		start = pos;
		if ( line.empty() )
			continue;
		Utils::WString first = line.token(L":", 1);
		Utils::WString rest = line.tokens(L":", 2);
		rest = rest.removeFirstSpace();
 
		// now check each line
		if ( first.Compare(L"Packager") )
			packageVersion = rest;
		else if ( first.Compare(L"Shipyard") )
		{
 
			std::vector<Utils::WString&gt; strs;
			if(rest.tokenise(L";&quot;, strs))
			{
				int cur = 1;
				for (size_t i = 0; i < strs.size(); i++, cur *= 2 )
				{
					if ( strs[i] == L"1" )
						this->AddShipyard(cur);
				}
			}
 
		}
		else if ( first.Compare("ScreenShot") )
		{
			int size = rest.token(L" ", 1);
			Utils::WString ext = rest.token(L" ", 2);
 
			C_File *newFile = this->addFile(m_sID + L"_" + (long)(this->countFiles(FILETYPE_SCREEN) + 1) + L"." + ext, L"", FILETYPE_SCREEN);
			newFile->ReadFromData((char *)(compr + pos), size); 
 
			start += (size + 1);
		}
		else if ( first.Compare(L"SceneFile") )
		{
			Utils::WString file = rest.tokens(L" ", 3);
			m_pSceneFile = this->addFile(CFileIO(file).filename(), CFileIO(file).dir(), FILETYPE_SHIPSCENE);
			m_pSceneFile->SetCreationTime((long)rest.token(L" ", 1));
			m_pSceneFile->ReadFromData((char *)(compr + pos), rest.token(L" ", 2));
 
			start += m_pSceneFile->GetDataSize();
		}
		else if ( first.Compare(L"CockpitFile") )
		{
			Utils::WString file = rest.tokens(L" ", 3);
			m_pCockpitFile = this->addFile(CFileIO(file).filename(), CFileIO(file).dir(), FILETYPE_COCKPITSCENE);
			m_pCockpitFile->SetCreationTime((long)rest.token(L" ", 1));
			m_pCockpitFile->ReadFromData((char *)(compr + pos), rest.token(L" ", 2));
 
			start += m_pCockpitFile->GetDataSize();
		}
		else if ( first.Compare(L"Model") )
		{
			Utils::WString file = rest.tokens(L" ", 3);
			C_File *newFile= this->addFile(CFileIO(file).filename(), CFileIO(file).dir(), FILETYPE_SHIPMODEL);
			newFile->SetCreationTime((long)rest.token(L" ", 1));
			newFile->ReadFromData((char *)(compr + pos), rest.token(L" ", 2));
 
			start += (newFile->GetDataSize() + 1);
		}
		else if ( first.Compare(L"Files") )
		{
			Utils::WString file = rest.tokens(L" ", 3);
 
			C_File *newFile = NULL;
			int special = 0;
			if ( file.Compare(L"types/CutData.txt") || file.Compare(L"types/CutData.pck") )
			{

				special = 3;
			}
			else
			{
				newFile = this->addFile(CFileIO(file).filename(), CFileIO(file).dir(), FILETYPE_SHIPOTHER);
				newFile->SetCreationTime((long)rest.token(L" ", 1));
			}
			newFile->ReadFromData((char *)(compr + pos), rest.token(L" ", 2));
			start += (newFile->GetDataSize() + 1);
 
			if ( special )
			{
				if (newFile->checkFileExt(L"pck"))
					newFile->UnPCKFile();
 
				// read data into lines
				Utils::WString data = Utils::WString::FromString((const char *)newFile->GetData());
				data.removeChar('\r');
 
				std::vector<Utils::WString&gt; sLines;
 
				if(data.tokenise(L&quot;\n", sLines))
				{
					// cut data
					size_t entries = -1;
					if ( special == 1 )
					{
						Utils::WStringList newLines;
						for (size_t i = 0; i <; sLines.size(); i++)
						{
							Utils::WString line = sLines[i];
							line.removeChar(' ');
							line.removeChar(9);
							if ( line.empty() || line[0] == '/' )
								continue;
							if ( entries == -1 )
							{
								entries	= line.token(L";", 1).toInt() - 36;
								if ( entries <= 0 )
									break;
							}
							else
							{
								int id = line.token(L";", 1).toInt();
								if ( id >= 9000 && id <= 9017 )
									continue;
 
								switch (id)
								{

					}
					// bodies
					else if ( special == 2 )
					{
						entries = 0;
						Utils::WString section;
						for (size_t i = 0; i < sLines.size(); i++ )
						{
							Utils::WString line = sLines[i];
							line.removeChar(' ');
							line.removeChar(9);
							if ( line.empty() || line[0] == '/' )
								continue;
							if ( entries <= 0)
							{
								section = line.token(L";", 1);
								entries	= line.token(L";", 2).toInt();
							}
							else
							{
								if ( !line.isin(L";") )
									continue;
								if ( line.countToken(L";") <= 2 )
								{
									this->addBodies(section + ";" + line.token(L";", 1) + L";");
									--entries;
								}
								else
								{
									bool done = false;
									while (!done)
									{
 
										std::vector<Utils::WString&gt; strs;
										done = true;
										line.tokenise(L";", strs);
										for (size_t j = 0; j <; strs.size(); j++)
										{
											if ( !entries )
											{
												line = line.tokens(L";", j + 1);
												if ( !line.empty() )
													done = false;
												break;
											}
 
											if ( strs[j].empty() )
												continue;
											
											this->addBodies(section + L";" + strs[j] + L";");
											--entries;
										}
										//we must be at another section
										if ( !done )
										{
											section = line.token(L";", 1);
											entries	= line.token(L";", 2).toInt();
											line = line.remToken(L";", 1);
											line = line.remToken(L";", 1);
 
											if (line.empty())
												done = true;
										}
 
 
									}									
								}
							}
						}
					}
					// animations
					else if ( special == 3 )
					{
						Utils::WStringList in;
						for (size_t i = 0; i <; sLines.size(); i++)
							in.pushBack(sLines[i]);
 
						Utils::WStringList out;
						if ( CXspFile::ReadAnimations(in, out, 87) )
							this->addAnimation(out);
					}
				}
 
				delete newFile;
			}
		}
		else if ( first.Compare(L"Script") )
		{
			Utils::WString file = rest.words(3);
			C_File *newFile= this->addFile(file, Utils::WString::Null(), FILETYPE_SCRIPT);
			newFile->SetCreationTime((long)rest.word(1));
			newFile->ReadFromData((char *)(compr + pos), rest.word(2));
 
			start += (newFile->GetDataSize() + 1);
		}
		else if ( first.Compare(L"Text") )
			this->addText(rest.token(L":", 1), rest.token(L":", 2), rest.tokens(L":", 3));
		else if ( first.Compare(L"Component") )
			this->addComponent(rest.token(L";", 1), rest.token(L";", 2), rest.tokens(L";", 3));
		else if ( first.Compare(L"Dummy") )
		{
			SDummy *d = new SDummy;
			d->sData = rest.tokens(L";", 2);
			d->sSection = rest.token(L";", 1);
			m_lDummy.push_back ( d );
		}
		else if ( !this->parseValueLine(line) )
		{
		//	printf ( "Command: %s, Rest: %s\n", first.c_str(), rest.c_str());

	// assume all old ones are for X3
	if ( !m_sData.empty() )
	{
		this->AddWeaponMask(GAME_X3 - 1, m_sData.token(L";", 19));
		this->AddMissileMask(GAME_X3 - 1, m_sData.token(L";", 25));
	}
 
	return true;
}
 
 
int GetMaxShipyards() { return (int)SHIPYARD_MAX; }

		return true;
	return false;
}
 
void CXspFile::SetLaserMask(int game, int mask)
{
	for ( CListNode<SWeaponMask> *node = m_lWeaponMasks.Front(); node; node = node->next() )
	{
		SWeaponMask *m = node->Data();
		if ( m->iGame == game )
		{
			m->iMask = mask;
			return;
		}
	}
 
	// no found, need to add it
	this->AddWeaponMask(game, mask);
}
 
void CXspFile::SetMissileMask(int game, int mask)
{
	for ( CListNode<SWeaponMask> *node = m_lMissileMasks.Front(); node; node = node->next() )
	{
		SWeaponMask *m = node->Data();

}
int CXspFile::GetLaserMask(int game, bool getOnly)
{
	int mask = -1;
	for ( CListNode<SWeaponMask> *node = m_lWeaponMasks.Front(); node; node = node->next() )
	{
		SWeaponMask *m = node->Data();
		if ( m->iGame == game )
			return m->iMask;
 
		if ( !mask && !getOnly )
			mask = m->iMask;
	}
 
	return mask;
}
 
int CXspFile::GetMissileMask(int game, bool getOnly)
{
	int mask = -1;
	for ( CListNode<SWeaponMask> *node = m_lMissileMasks.Front(); node; node = node->next() )
	{
		SWeaponMask *m = node->Data();
		if ( m->iGame == game )
			return m->iMask;
 
		if ( !mask && !getOnly )
			mask = m->iMask;
	}
 
	return mask;
}
 
void CXspFile::clearCutData()
{
	_lCutData.clear();
}

 
	if ( m_lText.size() ) {
		list->pushBack(L"# Ship Texts, the name/description of the ship in each language: <LANGID> <NAME>|<DESCRIPTION>");
		for(CListNode<SText> *node = m_lText.Front(); node; node = node->next()) {
			list->pushBack(Utils::WString(L"ShipText: ") + (long)node->Data()->iId + L" " + node->Data()->sName + L"|" + node->Data()->sDesc);
		}
 
		list->pushBack(L"");
	}
 
	if ( this->m_lWeaponMasks.size() ) {
		list->pushBack(L"# Weapon Masks, the weapons for each game: <GAME> <MASK>");

			list->pushBack(L"Cockpit: " + node->Data()->sCockpit.token(L";", 19) + L" " + node->Data()->sCockpit);
			for(SWeaponMask *mask = node->Data()->lWeaponMask.First(); mask; mask = node->Data()->lWeaponMask.Next()) {
				list->pushBack(L"CockpitWeapon: " + node->Data()->sCockpit.token(L";", 19) + L" " + (long)mask->iGame + L" " + (long)mask->iMask);
			}
		}
 
		list->pushBack(L"");
	}
 
	if (!this->_lCutData.empty())
	{
		list->pushBack(L"# Ship Cut Data");
		for(auto itr = _lCutData.begin(); itr != _lCutData.end(); itr++)
			list->pushBack(L"CutData: " + (*itr)->str);
		list->pushBack(L"");
	}
 
	if (!this->_lBodies.empty())
	{
		list->pushBack(L"# Ship Bodies");

	{
		list->pushBack(L"# Ship Animations");
		for (auto itr = _lAnimations.begin(); itr != _lAnimations.end(); itr++)
			list->pushBack(L"Animation: " + (*itr)->str);	
		list->pushBack(L"");
	}
 
	if ( !datafile )
	{
		if ( !CBaseFile::GeneratePackagerScriptFile(wildcard, list, game, gameAddons) )
			return false;
	}

}
 
void CXspFile::addDummiesToList(Utils::CList<STypesSection> &list)
{
	ADDSECTIONLIST(SDummy, m_lDummy);
}
 
void CXspFile::addComponentsToList(CLinkList<SComponentEntry> &componentList)
{
	for(CListNode<SComponent> *node = m_lComponent.Front(); node; node = node->next()) {
		SComponentEntry *currentSection = NULL;
		for(CListNode<SComponentEntry> *cNode = componentList.Front(); cNode; cNode = cNode->next()) {

					}
				}
				break;
			case 3:
				GENERATESECTION(L"Dummies", SDummy, this->m_lDummy);
				break;
			case 4:
				GENERATESTRINGSECTION(L"Bodies", this->_lBodies, true);
				break;
		}
 
		if ( type.empty() ) continue;
 
		Utils::WString fname = L"GENERATED/types/" + type + L".txt";
		
		Utils::WString fileData = L"// Exported " + type + L" file, Generated by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2) + L"\r\n" + data;

		wsprintf(buf, L"%hs", fname.c_str());
		if ( tmpFile.startRead() ) {
			*/
		ZipAdd(hz, fname.c_str(), (void *)fileData.c_str(), fileData.length() * sizeof(wchar_t));
		//}
	}
}
 
bool CXspFile::loadPackageData(const Utils::WString &sFirst, const Utils::WString &sRest, const Utils::WString &sMainGame, Utils::WStringList &otherGames, Utils::WStringList &gameAddons, CProgressInfo *progress)
{
	if ( sFirst.Compare(L"Shipyard") )
	{

	else if ( sFirst.Compare(L"Animation") )
		this->addAnimation(sRest);
	else if ( sFirst.Compare(L"Bodies") )
		this->addBodies(sRest);
	else if ( !CBaseFile::loadPackageData(sFirst, sRest, sMainGame, otherGames, gameAddons, progress) )
	{
		return false;
	}
 
	return true;
}
 
 
Utils::WString CXspFile::getX3ShipData() const
{
	Utils::WString data = m_sData;

	Utils::WString sClass = data.token(L";", TSHIPPOS_CLASS);
	if ( !((long)sClass) && sClass != L"0" )
	{
		int num = 0;
		for ( int i = 0; i < OBJ_SHIP_MAX; i++ )
		{
			if ( sClass.Compare(CShipData::ConvertShipClass(CShipData::GetShipClassFromNum(i))) )
			{
				num = i;
				break;
			}
		}
 
		data = data.replaceToken(L";", TSHIPPOS_CLASS, (long)num);
	}
 
	return data;
}
 
Utils::WString CXspFile::getTCShipData() const
{
	Utils::WString data = m_sData;
 
	Utils::WString sSubType = data.token(L";", 6);
	if ( ((long)sSubType) || sSubType == L"0" )
		data = data.replaceToken(L";", 6, CShipData::ConvertShipSubType((long)sSubType));
 

	bool ret = false;
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
	{
		Utils::WString id = node->Data()->sCockpit.token(L";", 19);
		if ( id.Compare(cockpitid) )
		{
			node->DeleteData();
			ret = true;
			break;
		}
	}
 
	m_lCockpit.RemoveEmpty();
 
	return ret;

{
	bool ret = false;
	for ( CListNode<SComponent> *node = m_lComponent.Front(); node; node = node->next() )
	{
		if ( node->Data()->sSection.Compare(section1) && node->Data()->sSection2.Compare(section2) && node->Data()->sData.Compare(data) )
		{
			ret = true;
			node->DeleteData();
			break;
		}
	}
	m_lComponent.RemoveEmpty();
	return ret;
}

		}
	}
	m_lDummy.RemoveEmpty();
 
	return ret;
}
 
Utils::WString CXspFile::getCockpitData(const Utils::WString &cid)
{
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
	{
		Utils::WString id = node->Data()->sCockpit.token(L";", 19);
		if ( id.Compare(cid) )
			return node->Data()->sCockpit;
	}
 
	return L"";
}
 
SCockpit *CXspFile::findCockpit(const Utils::WString &cid)
{
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
	{
		Utils::WString id = node->Data()->sCockpit.token(L";", 19);
		if ( id.Compare(cid) )
			return node->Data();
	}
 
	return nullptr;
}
 
void CXspFile::editCockpit(const Utils::WString &cid, const Utils::WString &cockpit)
{
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
	{
		Utils::WString id = node->Data()->sCockpit.token(L";", 19);
		if ( id.Compare(cid) )
		{
			node->Data()->sCockpit = cockpit;
			break;
		}
	}
}
 
void CXspFile::editCockpit(const Utils::WString &cid, const Utils::WString &scene, int mask)
{
	for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )
	{
		Utils::WString id = node->Data()->sCockpit.token(L";", 19);
		if ( id.Compare(cid) )

			node->Data()->sCockpit = cockpit;
			break;
		}
	}
}
void CXspFile::newCockpit(const Utils::WString &id, const Utils::WString &scene, int mask)
{
	Utils::WString cockpit = L"0;0;0;0;0;0;0;";
	cockpit += scene + L";";
	cockpit += (long)mask;
	cockpit += L";0;0;0;0;0;0;-100000;0;0;";
	cockpit += id + L";";
	this->addCockpit(cockpit, -1);
}
 
bool CXspFile::removeCutData(const Utils::WString &cut)
{

		_changed();
	}
}
 
 
int CXspFile::GetAnimationType(const Utils::WString &type)
{
	if ( type.Compare(L"TAT_TAGSINGLESTEP") )
		return TAT_SINGLE;
	else if ( type.Compare(L"TAT_TAGONESHOT") 
				|| type.Compare(L"TAT_TAGONESHOT_REINIT") 
				|| type.Compare(L"TAT_PINGPONG")
				|| type.Compare(L"TAT_TAGLOOP") )
		return TAT_3;
 
	return TAT_NONE;
}
 

	}
 
	return data;
}
 
bool CXspFile::ReadAnimations(const Utils::WStringList &lIn, Utils::WStringList &lOut, int startRecord)
{
	Utils::WString lastComment;
	Utils::WString addEntry;
	int remaining = 0;
	Utils::WString lastType;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
	int newEntries = 0;
	int entries = -1;
	for(auto itr = lIn.begin(); itr != lIn.end(); itr++)
	{
		Utils::WString line = (*itr)->str;
		line.removeChar('\r');
		line.removeChar(9);
		if ( line.empty() || line[0] == '/' )
			continue;
		if ( entries == -1)
		{
			entries	= line.token(L";", 1);
			newEntries = entries - startRecord;
		}
		else
		{
			// remove comments, endspaces and last ;
			Utils::WString sStriped = line;
			if ( sStriped.contains(L"//") )
			{
				if ( entries <= newEntries )
					lastComment = L"//" + sStriped.tokens(L"//", 2);
				sStriped = sStriped.token(L"//", 1);
			}
			sStriped.removeEndSpace();
			if ( sStriped.right(1) == L";" )
				sStriped.truncate(-1);
 
			Utils::WString sRemainingLeft;
			if ( remaining > 0 )
				sRemainingLeft = sStriped;
			else
			{
				// each line should be a new entry, with some exceptions
				// potection for new lines
				lastType = sStriped.token(L";", 1);
 
				switch (CXspFile::GetAnimationType(lastType))
				{
					case TAT_SINGLE:
						remaining = (long)sStriped.token(L";", 5) + 1;
						sRemainingLeft = sStriped.tokens(L";", 6);
						if ( entries <= newEntries )
							addEntry = sStriped.tokens(L";", 1, 5) + L";";
						break;
					case TAT_3:
						remaining = (long)sStriped.token(L";", 5) + 1;
						sRemainingLeft = sStriped.tokens(L";", 6);
						if ( entries <= newEntries )
							addEntry = sStriped.tokens(L";", 1, 5) + L";";
						break;
 
					default:
						remaining = 0;
						if ( entries <= newEntries )

			if ( !sRemainingLeft.empty() )
			{
				int tatType = CXspFile::GetAnimationType(lastType);
				if ( tatType == TAT_SINGLE )
				{
					if ( sRemainingLeft.isin(L";") )
						remaining -= sRemainingLeft.countToken(L";");
					else if ( !sRemainingLeft.empty() )
						--remaining;
 
					if ( entries <= newEntries )
						addEntry += sRemainingLeft + L";";
				}
				else if ( tatType == TAT_3 )
				{
					// last entry
					if ( remaining == 1 )
						--remaining;
					else if ( sRemainingLeft.isin(L";") )
					{
						if ( !sRemainingLeft.isin(L"TATF_COORDS") )
						{
							int amt = sRemainingLeft.countToken(L";") / 3;
							remaining -= amt;
							if ( remaining == 1 && (sRemainingLeft.countToken(L";") - (amt * 3)) == 1 )
								--remaining;
						}
						else
						{
							int iRem = sRemainingLeft.countToken(L";");
							int iPos = 1;
							while ( iPos < iRem )
							{
								Utils::WString first = sRemainingLeft.token(L";", iPos);
								if ( first.isin(L"TATF_COORDS") )
									iPos += 5;
								else
									iPos += 3;
								--remaining;
							}
 
							if ( remaining == 1 && iPos == iRem )
								--remaining;
						}
					}
 
					if ( entries <= newEntries )
						addEntry += sRemainingLeft + L";";
				}
			}
 
			if ( remaining <= 0 )
			{
				if ( entries <= newEntries && !addEntry.empty())
				{
					if ( addEntry[(int)addEntry.length() - 1] != ';' )
						addEntry += L";";
					lOut.pushBack(addEntry + lastComment);
				}
				--entries;
			}
		}
	}
 
	return !lOut.empty();
}
 
void CXspFile::addAnimation(const Utils::WStringList &list)
{
	for(auto itr = list.begin(); itr != list.end(); itr++)
		this->addAnimation((*itr)->str);
	_changed();
}

	// still not found one, return the ships name
	if ( !this->description().empty() ) return this->description();
	return this->shipName(lang);
}
 
bool CXspFile::startExtractShip(CVirtualFileSystem *pVfs, const Utils::WString &sId, CProgressInfo *pProgress)
{
	m_sID = sId.remove('\r');
	while ( m_sID.right(1) == L";" )
		m_sID.truncate(-1);
 
	m_sData = pVfs->getTShipsEntry(m_sID);
 

		return false;
 
	return true;
}
 
bool CXspFile::extractShip(CVirtualFileSystem *pVfs, const Utils::WString &sId, CProgressInfo *progress)
{
	if ( !this->startExtractShip(pVfs, sId, progress) )
		return false;
 
	// read the scene file and get the files list

	m_pCockpitFile = pVfs->extractGameFileToPackage(this, L"objects\\" + m_sData.token(L";", 18) + L".pbd", FILETYPE_COCKPITSCENE, L"objects\\" + m_sData.token(L";", 18) + L".bod");
 
	return true;
}
 
bool CXspFile::readSceneModels(Utils::WStringList& out)
{
	// read the scene file
	if (!m_pSceneFile)
		m_pSceneFile = this->GetFirstFile(FILETYPE_SHIPSCENE);
 

			}
		}
	}
 
	if (deleteData)
		delete []data;
 
	return true;
}
 
void CXspFile::extractCutData(CVirtualFileSystem *pVfs, Utils::WStringList &sceneModels, bool add)
{
	std::vector<int> cuts;
	for ( CListNode<SDummy> *node = m_lDummy.Front(); node; node = node->next() )
	{
		Utils::WString data = node->Data()->sData;
		int states = data.token(L";", 3);
		for ( int i = 0; i < states; i++ )
		{
			int cutid = data.token(L";", (i * 2) + 5);
			if ( !cutid ) continue;
			cuts.push_back(cutid);
		}
	}

	if ( pVfs->extractGameFile(L"types/CutData.pck", CPackages::tempDirectory() + L"tmp.dat").empty()) return;
	
	CFileIO File(CPackages::tempDirectory() + L"tmp.dat");
	if ( !File.exists() ) return;
	
	std::vector<Utils::WString> lines;
	File.readLines(lines);
	int count = -1;
	for (auto itr = lines.begin(); itr != lines.end(); itr++)
	{
		Utils::WString line = *itr;
		line.removeChar('\r');
		line.removeChar(' ');
		line.removeFirstSpace();
		if ( line[0] == '/' ) continue;
		if ( count == -1 ) count = line.token(L";", 1);
		else 
		{
			std::vector<Utils::WString&gt; words;
			if(line.tokenise(L";&quot;, words))
			{
				for (size_t i = 0; i <; words.size(); i += 2) {
					int cutid = words[i];
					if ( !cutid ) continue;
					for ( std::vector<int>::iterator itr = cuts.begin(); itr != cuts.end(); itr++ )
					{
						if ( (*itr) == cutid )
						{
							this->addCutData(words[i] + L";" + words[i + 1] + L";");
							if ( add ) 
								sceneModels.pushBack(words[i + 1]);
 
							break;
						}
					}
				}
 
			}
		}
	}
}
 
void CXspFile::extractDummies(CVirtualFileSystem *pVfs, Utils::WStringList& sceneModels, bool add)
{
	if (sceneModels.empty()) return;
 
	bool extracted = false;
	if ( !pVfs->extractGameFile(L"types/dummies.pck", CPackages::tempDirectory() + L"tmp.dat").empty()) 
	{
		CFileIO File(CPackages::tempDirectory() + L"tmp.dat");
		if ( File.exists() )
		{
			Utils::WString section;
			int secCount = 0;
			std::vector<Utils::WString> lines;
			if (File.readLines(lines))
			{
				for(auto itr = lines.begin(); itr != lines.end(); itr++)
				{
					Utils::WString str = itr->remove(9).remove('\r');
					str.removeFirstSpace();
					if (str.empty())
						continue;
					if (str[0] == '/')
						continue;
 
					// not in a section yet
					if (secCount <= 0)
					{
						section = str.token(L";", 1);
						secCount = str.token(L";", 2).toInt();
					}
					else
					{
						Utils::WString first = str.token(L";", 1);
						if (sceneModels.contains(first))
						{
							this->addDummy(section, str);
 
							if (add)
							{
								int pos = 4;
								int scene = str.token(L";", 3).toInt();
								for (int i = 0; i < scene; i++)
								{
									sceneModels.pushBack(str.token(L";", 5 + (i * 2)));
									pos += 2;
								}
 
								int model = str.token(L";", pos).toInt();
								for (int i = 0; i < model; i++)
									sceneModels.pushBack(str.token(L";", pos + (i * 2) + 1));
							}
						}
						--secCount;
 
					}
				}
			}
 
			File.remove();
		}
	}
}
 
void CXspFile::extractComponants(CVirtualFileSystem *pVfs, const Utils::WStringList& sceneModels)
{
	if (sceneModels.empty()) return;
	if ( !pVfs->extractGameFile(L"types/components.pck", CPackages::tempDirectory() + L"tmp.dat").empty())
	{
		CFileIO File(CPackages::tempDirectory() + L"tmp.dat");
		if ( File.exists() )
		{
			Utils::WString file;
			Utils::WString section;
			int secCount = 0;
			int secCount2 = 0;
			std::vector<Utils::WString> lines;
			if (File.readLines(lines))
			{
				for(auto itr = lines.begin(); itr != lines.end(); itr++)
				{
					Utils::WString str = itr->remove(9).remove('\r');
					str.removeFirstSpace();
					if (str.empty())
						continue;
					if (str[0] == '/')
						continue;
 
					// not in a section yet
					if (secCount2)
					{
						if (sceneModels.contains(file))
							this->addComponent(section, file, str);
						--secCount2;
					}
					else if (secCount <= 0)
					{
						section = str.token(L";", 1);
						secCount = str.token(L";", 2).toInt();
					}
					else
					{
						file = str.token(L";", 1);
						secCount2 = str.token(L";", 2).toInt();
						--secCount;
					}
				}
			}
 
			File.remove();
		}
	}
}
 
bool CXspFile::getTextureList(Utils::WStringList &list, const unsigned char *olddata, size_t size) const
{
	if ( !olddata || !size )
		return false;
 
	size_t startLine = 0;
	Utils::WString line;
	size_t pos = 0;
 
	unsigned char *data = new unsigned char[size];
	memcpy(data, olddata, size);
 
	while ( (pos++) < size )
	{
		if ( data[pos] == '\n' )
		{
			data[pos] = '\0';
			line = Utils::WString::FromString((char *)(data + startLine));
			line.removeChar(9);
			line.removeChar('\r');
			line.removeFirstSpace();
 
			if ( !line.empty() && line[0] != '/' )
			{
				Utils::WString first = line.token(L":", 1);
				if ( first.Compare(L"MATERIAL6") )
				{
 
					Utils::WString material = line.tokens(L":", 2);
					std::vector<Utils::WString&gt; strs;
 
					int num = material.token(L";", 5);
					if(material.tokens(L";", 6).tokenise(L&quot;; &quot;, strs))
					{
						for(size_t i = 0; i < strs.size(); i++) {
							Utils::WString type = strs[i].token(L";", 1);
							Utils::WString valtype = strs[i].token(L";", 2);			
							if ( valtype.Compare(L"SPTYPE_STRING") ) {
								Utils::WString file = strs[i].token(L";", 3);
								if(!list.contains(file))
									list.pushBack(file, L"");
							}
						}
					}
 
 
				}
			}
 
			startLine = pos + 1;
		}

	for(auto itr = lTextures.begin(); itr != lTextures.end(); itr++)
	{
		CFileIO F((*itr)->str);
		if ( F.isFileExtension(L"fx") ) {
			/*
			if ( !pVfs->extractGameFileToPackage(this, "shader\\1_1\\" + Utils::WString(node->str.ToString()), FILETYPE_SHIPOTHER) )
				pVfs->extractGameFileToPackage(this, "shader\\1_1\\" + CFileIO(node->str.ToString()).ChangeFileExtension("fb").ToString(), FILETYPE_SHIPOTHER);
			if ( !pVfs->extractGameFileToPackage(this, "shader\\1_4\\" + Utils::WString(node->str.ToString()), FILETYPE_SHIPOTHER) )
				pVfs->extractGameFileToPackage(this, "shader\\1_4\\" + CFileIO(node->str.ToString()).ChangeFileExtension("fb").ToString(), FILETYPE_SHIPOTHER);
			if ( !pVfs->extractGameFileToPackage(this, "shader\\2_0\\" + Utils::WString(node->str.ToString()), FILETYPE_SHIPOTHER) )
				pVfs->extractGameFileToPackage(this, "shader\\2_0\\" + CFileIO(node->str.ToString()).ChangeFileExtension("fb").ToString(), FILETYPE_SHIPOTHER);
			if ( !pVfs->extractGameFileToPackage(this, "shader\\2_a\\" + Utils::WString(node->str.ToString()), FILETYPE_SHIPOTHER) )
				pVfs->extractGameFileToPackage(this, "shader\\2_a\\" + CFileIO(node->str.ToString()).ChangeFileExtension("fb").ToString(), FILETYPE_SHIPOTHER);
			if ( !pVfs->extractGameFileToPackage(this, "shader\\2_b\\" + Utils::WString(node->str.ToString()), FILETYPE_SHIPOTHER) )
				pVfs->extractGameFileToPackage(this, "shader\\2_b\\" + CFileIO(node->str.ToString()).ChangeFileExtension("fb").ToString(), FILETYPE_SHIPOTHER);
			if ( !pVfs->extractGameFileToPackage(this, "shader\\3_0\\" + Utils::WString(node->str.ToString()), FILETYPE_SHIPOTHER) )
				pVfs->extractGameFileToPackage(this, "shader\\3_0\\" + CFileIO(node->str.ToString()).ChangeFileExtension("fb").ToString(), FILETYPE_SHIPOTHER);
				*/
		}
		else {
			if ( pVfs->extractGameFileToPackage(this, L"dds\\" + (*itr)->str, FILETYPE_SHIPOTHER) )
				continue;
 
			if ( pVfs->extractGameFileToPackage(this, L"dds\\" + (*itr)->str.token(L".", -1), FILETYPE_SHIPOTHER) )
				continue;
 
			if ( pVfs->extractGameFileToPackage(this, L"dds\\" + (*itr)->str + L".dds", FILETYPE_SHIPOTHER) )
				continue;
 
			if ( pVfs->extractGameFileToPackage(this, L"dds\\" + F.changeFileExtension(L"dds"), FILETYPE_SHIPOTHER) )
				continue;
 
			if ( pVfs->extractGameFileToPackage(this, L"textures\\" + (*itr)->str, FILETYPE_SHIPOTHER) )
				continue;
 
			if ( pVfs->extractGameFileToPackage(this, L"textures\\" + (*itr)->str.token(L".", -1), FILETYPE_SHIPOTHER) )
				continue;
 
			if ( pVfs->extractGameFileToPackage(this, L"textures\\" + (*itr)->str + L".jpg", FILETYPE_SHIPOTHER) )
				continue;
 
			if ( pVfs->extractGameFileToPackage(this, L"textures\\" + F.changeFileExtension(L"jpg"), FILETYPE_SHIPOTHER) )
				continue;
		}
	}
}
 
bool CXspFile::addTextFromFile(const Utils::WString &sFile, int textId)
{
	Utils::WString file = sFile;
 

	}
 
	return false;
}
 
bool CXspFile::importBodies(const Utils::WStringList &sceneModels, const Utils::WString &filename)
{
	CFileIO File(filename);
	if ( File.exists() )
	{
		Utils::WString sSection;
		int section = 0;
		std::vector<Utils::WString> lines;
		if (File.readLines(lines))
		{
			for(auto itr = lines.begin(); itr != lines.end(); itr++)
			{
				Utils::WString l = *itr;
				l.removeChar(9);
				l.removeChar('\r');
				l.removeFirstSpace();
				if (l.empty())
					continue;

					continue;
 
				// are we looking for a section
				if (section <= 0)
				{
					sSection = l.token(L";", 1);
					section = l.token(L";", 2).toInt();
				}
				else
				{
 
					std::vector<Utils::WString&gt; strs;
					if(l.tokenise(L&quot;;";, strs))
					{
						for (size_t i = 0; i < strs.size(); i++)
						{
							strs[i].removeEndSpace();
							strs[i].removeFirstSpace();
							if (strs[i].empty())
								continue;
							if (sceneModels.contains(strs[i]))
								this->addBody(sSection, strs[i]);
							--section;
						}
					}
 
				}
			}
			return true;
		}
	}
 
	return false;
}
 
bool CXspFile::ImportCockpits(const Utils::WString &filename)
{
	CFileIO File(filename);
	if ( File.exists() )
	{
		std::vector<Utils::WString> lines;

}
 
bool CXspFile::extractCockpits(CVirtualFileSystem *pVfs)
{
	if ( !pVfs->extractGameFile(L"types/TCockpits.pck", CPackages::tempDirectory() + L"tmp.dat").empty() ) {
		bool ret = this->ImportCockpits((CPackages::tempDirectory() + L"tmp.dat"));
		CFileIO::Remove(CPackages::tempDirectory() + L"tmp.dat");
 
		return ret;
	}
 
	return false;
}
 
bool CXspFile::extractBodies(CVirtualFileSystem *pVfs, const Utils::WStringList &sceneModels)
{
	if (sceneModels.empty()) return false;
 
	if ( !pVfs->extractGameFile(L"types/Bodies.pck", CPackages::tempDirectory() + L"tmp.dat").empty() ) {
		bool ret = this->importBodies(sceneModels, (CPackages::tempDirectory() + L"tmp.dat"));
		CFileIO::Remove(CPackages::tempDirectory() + L"tmp.dat");
 
		return ret;
	}
 

			CFileIO::Remove(CPackages::tempDirectory() + L"/tmp.dat");
		}
	}
}
 
bool CXspFile::processSceneFileSection(int section, CVirtualFileSystem *pVfs, Utils::WStringList &lModels, CProgressInfo *progress)
{
	if ( progress ) progress->UpdateStatus(section);
 
	switch ( section )
	{

				if (lModels.empty()) return false;
				for(auto itr = lModels.begin(); itr != lModels.end(); itr++)
				{
					if ((*itr)->str.isNumber() ) // count be componants or dummy
						continue;
					if ( pVfs->extractGameFileToPackage(this, L"objects\\" + (*itr)->str + L".pbb", FILETYPE_SHIPMODEL, L"objects\\" + (*itr)->str + L".bob") )
						continue;
					if ( pVfs->extractGameFileToPackage(this, L"objects\\" + (*itr)->str + ".pbd", FILETYPE_SHIPMODEL, L"objects\\" + (*itr)->str + L".bod") )
						continue;
				}
			}
			break;
 

 
bool CXspFile::processSceneFiles(CVirtualFileSystem *pVfs, CProgressInfo *progress)
{
	// now lets parse our files
	if ( progress ) progress->UpdateStatus(IMPORTSHIP_EXTRACTSCENE);
	Utils::WStringList lModels;
	if(!readSceneModels(lModels))
		return false;
 
	// extract componants, and add extra items to list
	if ( !this->processSceneFileSection(IMPORTSHIP_COMPONANT, pVfs, lModels, progress) )

Rev 217	Rev 218
Line 332...	Line 332...
332		332
333	`return name;`	333	`return name;`
334	`}`	334	`}`
335		335
336	`//TODO: split this up`	336	`//TODO: split this up`
337	`bool CXspFile::ConvertOld(const Utils::String &file)`	337	`bool CXspFile::convertOld(const Utils::WString &file)`
338	`{`	338	`{`
339	`// open the file`	339	`// open the file`
340	`FILE *id = fopen(file.c_str(), "rb");`	340	`FILE *id = _wfopen(file.c_str(), L"rb");`
341	`if ( !id )`	341	`if ( !id )`
342	`return false;`	342	`return false;`
343		343
344	`// read to memory`	344	`// read to memory`
345	`fseek(id, 0, SEEK_END);`	345	`fseek(id, 0, SEEK_END);`
Line 352...	Line 352...
352		352
353	`// uncompress the file`	353	`// uncompress the file`
354	`size_t len;`	354	`size_t len;`
355	`unsigned char *compr = LZMADecode_C ( data, size, &len, NULL );`	355	`unsigned char *compr = LZMADecode_C ( data, size, &len, NULL );`
356		356
357	`delete data;`	357	`delete[] data;`
358		358
359	`if ( !compr )`	359	`if ( !compr )`
360	`return false;`	360	`return false;`
361		361
362	`this->Delete();`	362	`this->Delete();`
Line 369...	Line 369...
369	`while ( pos < len )`	369	`while ( pos < len )`
370	`{`	370	`{`
371	`while ( compr[pos++] != '\n' && pos < len );`	371	`while ( compr[pos++] != '\n' && pos < len );`
372		372
373	`compr[pos - 1] = '\0';`	373	`compr[pos - 1] = '\0';`
374	`Utils::String line = (char *)(compr + start);`	374	`Utils::WString line = Utils::WString::FromString((char *)(compr + start));`
375	`start = pos;`	375	`start = pos;`
376	`if ( line.empty() )`	376	`if ( line.empty() )`
377	`continue;`	377	`continue;`
378	`Utils::String first = line.token(":", 1);`	378	`Utils::WString first = line.token(L":", 1);`
379	`Utils::String rest = line.tokens(":", 2);`	379	`Utils::WString rest = line.tokens(L":", 2);`
380	`rest = rest.removeFirstSpace();`	380	`rest = rest.removeFirstSpace();`
381		381
382	`// now check each line`	382	`// now check each line`
383	`if ( first.Compare("Packager") )`	383	`if ( first.Compare(L"Packager") )`
384	`packageVersion = rest;`	384	`packageVersion = rest;`
385	`else if ( first.Compare("Shipyard") )`	385	`else if ( first.Compare(L"Shipyard") )`
386	`{`	386	`{`
387	`int max;`	-
388	`Utils::String *strs = rest.tokenise(";", &max);`	387	`std::vector<Utils::WString> strs;`
389	`if ( strs &;& max )`	388	`if(rest.tokenise(L";", strs))`
390	`{`	389	`{`
391	`int cur = 1;`	390	`int cur = 1;`
392	`for ( int i = 0; i < max; i++, cur *= 2 )`	391	`for (size_t i = 0; i < strs.size(); i++, cur *= 2 )`
393	`{`	392	`{`
394	`if ( strs[i] == "1" )`	393	`if ( strs[i] == L"1" )`
395	`this->AddShipyard(cur);`	394	`this->AddShipyard(cur);`
396	`}`	395	`}`
397	`}`	396	`}`
398	`CLEANSPLIT(strs, max)`	-
399	`}`	397	`}`
400	`else if ( first.Compare("ScreenShot") )`	398	`else if ( first.Compare("ScreenShot") )`
401	`{`	399	`{`
402	`int size = rest.token(" ", 1);`	400	`int size = rest.token(L" ", 1);`
403	`Utils::WString ext = rest.token(" ", 2);`	401	`Utils::WString ext = rest.token(L" ", 2);`
404		402
405	`C_File *newFile = this->addFile(m_sID + L"_" + (long)(this->countFiles(FILETYPE_SCREEN) + 1) + L"." + ext, L"", FILETYPE_SCREEN);`	403	`C_File *newFile = this->addFile(m_sID + L"_" + (long)(this->countFiles(FILETYPE_SCREEN) + 1) + L"." + ext, L"", FILETYPE_SCREEN);`
406	`newFile->ReadFromData((char *)(compr + pos), size);`	404	`newFile->ReadFromData((char *)(compr + pos), size);`
407		405
408	`start += (size + 1);`	406	`start += (size + 1);`
409	`}`	407	`}`
410	`else if ( first.Compare("SceneFile") )`	408	`else if ( first.Compare(L"SceneFile") )`
411	`{`	409	`{`
412	`Utils::WString file = rest.tokens(" ", 3);`	410	`Utils::WString file = rest.tokens(L" ", 3);`
413	`m_pSceneFile = this->addFile(CFileIO(file).filename(), CFileIO(file).dir(), FILETYPE_SHIPSCENE);`	411	`m_pSceneFile = this->addFile(CFileIO(file).filename(), CFileIO(file).dir(), FILETYPE_SHIPSCENE);`
414	`m_pSceneFile->SetCreationTime((long)rest.token(" ", 1));`	412	`m_pSceneFile->SetCreationTime((long)rest.token(L" ", 1));`
415	`m_pSceneFile->ReadFromData((char *)(compr + pos), rest.token(" ", 2));`	413	`m_pSceneFile->ReadFromData((char *)(compr + pos), rest.token(L" ", 2));`
416		414
417	`start += m_pSceneFile->GetDataSize();`	415	`start += m_pSceneFile->GetDataSize();`
418	`}`	416	`}`
419	`else if ( first.Compare("CockpitFile") )`	417	`else if ( first.Compare(L"CockpitFile") )`
420	`{`	418	`{`
421	`Utils::WString file = rest.tokens(" ", 3);`	419	`Utils::WString file = rest.tokens(L" ", 3);`
422	`m_pCockpitFile = this->addFile(CFileIO(file).filename(), CFileIO(file).dir(), FILETYPE_COCKPITSCENE);`	420	`m_pCockpitFile = this->addFile(CFileIO(file).filename(), CFileIO(file).dir(), FILETYPE_COCKPITSCENE);`
423	`m_pCockpitFile->SetCreationTime((long)rest.token(" ", 1));`	421	`m_pCockpitFile->SetCreationTime((long)rest.token(L" ", 1));`
424	`m_pCockpitFile->ReadFromData((char *)(compr + pos), rest.token(" ", 2));`	422	`m_pCockpitFile->ReadFromData((char *)(compr + pos), rest.token(L" ", 2));`
425		423
426	`start += m_pCockpitFile->GetDataSize();`	424	`start += m_pCockpitFile->GetDataSize();`
427	`}`	425	`}`
428	`else if ( first.Compare("Model") )`	426	`else if ( first.Compare(L"Model") )`
429	`{`	427	`{`
430	`Utils::WString file = rest.tokens(" ", 3);`	428	`Utils::WString file = rest.tokens(L" ", 3);`
431	`C_File *newFile= this->addFile(CFileIO(file).filename(), CFileIO(file).dir(), FILETYPE_SHIPMODEL);`	429	`C_File *newFile= this->addFile(CFileIO(file).filename(), CFileIO(file).dir(), FILETYPE_SHIPMODEL);`
432	`newFile->SetCreationTime((long)rest.token(" ", 1));`	430	`newFile->SetCreationTime((long)rest.token(L" ", 1));`
433	`newFile->ReadFromData((char *)(compr + pos), rest.token(" ", 2));`	431	`newFile->ReadFromData((char *)(compr + pos), rest.token(L" ", 2));`
434		432
435	`start += (newFile->GetDataSize() + 1);`	433	`start += (newFile->GetDataSize() + 1);`
436	`}`	434	`}`
437	`else if ( first.Compare("Files") )`	435	`else if ( first.Compare(L"Files") )`
438	`{`	436	`{`
439	`Utils::WString file = rest.tokens(" ", 3);`	437	`Utils::WString file = rest.tokens(L" ", 3);`
440		438
441	`C_File *newFile = NULL;`	439	`C_File *newFile = NULL;`
442	`int special = 0;`	440	`int special = 0;`
443	`if ( file.Compare(L"types/CutData.txt") \|\| file.Compare(L"types/CutData.pck") )`	441	`if ( file.Compare(L"types/CutData.txt") \|\| file.Compare(L"types/CutData.pck") )`
444	`{`	442	`{`
Line 456...	Line 454...
456	`special = 3;`	454	`special = 3;`
457	`}`	455	`}`
458	`else`	456	`else`
459	`{`	457	`{`
460	`newFile = this->addFile(CFileIO(file).filename(), CFileIO(file).dir(), FILETYPE_SHIPOTHER);`	458	`newFile = this->addFile(CFileIO(file).filename(), CFileIO(file).dir(), FILETYPE_SHIPOTHER);`
461	`newFile->SetCreationTime((long)rest.token(" ", 1));`	459	`newFile->SetCreationTime((long)rest.token(L" ", 1));`
462	`}`	460	`}`
463	`newFile->ReadFromData((char *)(compr + pos), rest.token(" ", 2));`	461	`newFile->ReadFromData((char *)(compr + pos), rest.token(L" ", 2));`
464	`start += (newFile->GetDataSize() + 1);`	462	`start += (newFile->GetDataSize() + 1);`
465		463
466	`if ( special )`	464	`if ( special )`
467	`{`	465	`{`
468	`if (newFile->checkFileExt(L"pck"))`	466	`if (newFile->checkFileExt(L"pck"))`
469	`newFile->UnPCKFile();`	467	`newFile->UnPCKFile();`
470		468
471	`// read data into lines`	469	`// read data into lines`
472	`Utils::String data((const char *)newFile->GetData());`	470	`Utils::WString data = Utils::WString::FromString((const char *)newFile->GetData());`
473	`data.removeChar('\r');`	471	`data.removeChar('\r');`
474	`int iLines;`	472
475	`Utils::String *sLines = data.tokenise("\n", &iLines);`	473	`std::vector<Utils::WString> sLines;`
476		-
477	`if ( sLines && iLines )`	474	`if(data.tokenise(L"\n", sLines))`
478	`{`	475	`{`
479	`// cut data`	476	`// cut data`
480	`size_t entries = -1;`	477	`size_t entries = -1;`
481	`if ( special == 1 )`	478	`if ( special == 1 )`
482	`{`	479	`{`
483	`Utils::CStringList newLines;`	480	`Utils::WStringList newLines;`
484	`for ( int i = 0; i <; iLines; i++ )`	481	`for (size_t i = 0; i <; sLines.size(); i++)`
485	`{`	482	`{`
486	`Utils::String line = sLines[i];`	483	`Utils::WString line = sLines[i];`
487	`line.removeChar(' ');`	484	`line.removeChar(' ');`
488	`line.removeChar(9);`	485	`line.removeChar(9);`
489	`if ( line.empty() \|\| line[0] == '/' )`	486	`if ( line.empty() \|\| line[0] == '/' )`
490	`continue;`	487	`continue;`
491	`if ( entries == -1 )`	488	`if ( entries == -1 )`
492	`{`	489	`{`
493	`entries = line.token(";", 1).toInt() - 36;`	490	`entries = line.token(L";", 1).toInt() - 36;`
494	`if ( entries <= 0 )`	491	`if ( entries <= 0 )`
495	`break;`	492	`break;`
496	`}`	493	`}`
497	`else`	494	`else`
498	`{`	495	`{`
499	`int id = line.token(";", 1).toInt();`	496	`int id = line.token(L";", 1).toInt();`
500	`if ( id >= 9000 && id <= 9017 )`	497	`if ( id >= 9000 && id <= 9017 )`
501	`continue;`	498	`continue;`
502		499
503	`switch (id)`	500	`switch (id)`
504	`{`	501	`{`
Line 535...	Line 532...
535	`}`	532	`}`
536	`// bodies`	533	`// bodies`
537	`else if ( special == 2 )`	534	`else if ( special == 2 )`
538	`{`	535	`{`
539	`entries = 0;`	536	`entries = 0;`
540	`Utils::String section;`	537	`Utils::WString section;`
541	`for ( int i = 0; i < iLines; i++ )`	538	`for (size_t i = 0; i < sLines.size(); i++ )`
542	`{`	539	`{`
543	`Utils::String line = sLines[i];`	540	`Utils::WString line = sLines[i];`
544	`line.removeChar(' ');`	541	`line.removeChar(' ');`
545	`line.removeChar(9);`	542	`line.removeChar(9);`
546	`if ( line.empty() \|\| line[0] == '/' )`	543	`if ( line.empty() \|\| line[0] == '/' )`
547	`continue;`	544	`continue;`
548	`if ( entries <= 0)`	545	`if ( entries <= 0)`
549	`{`	546	`{`
550	`section = line.token(";", 1);`	547	`section = line.token(L";", 1);`
551	`entries = line.token(";", 2).toInt();`	548	`entries = line.token(L";", 2).toInt();`
552	`}`	549	`}`
553	`else`	550	`else`
554	`{`	551	`{`
555	`if ( !line.isin(";") )`	552	`if ( !line.isin(L";") )`
556	`continue;`	553	`continue;`
557	`if ( line.countToken(";") <= 2 )`	554	`if ( line.countToken(L";") <= 2 )`
558	`{`	555	`{`
559	`this->addBodies(section + ";" + line.token(";", 1) + ";");`	556	`this->addBodies(section + ";" + line.token(L";", 1) + L";");`
560	`--entries;`	557	`--entries;`
561	`}`	558	`}`
562	`else`	559	`else`
563	`{`	560	`{`
564	`bool done = false;`	561	`bool done = false;`
565	`while (!done)`	562	`while (!done)`
566	`{`	563	`{`
567	`int num;`	-
568	`Utils::String *strs = line.tokenise(";", &num);`	564	`std::vector<Utils::WString> strs;`
569	`done = true;`	565	`done = true;`
-		566	`line.tokenise(L";", strs);`
570	`for ( int j = 0; j <; num; j++ )`	567	`for (size_t j = 0; j <; strs.size(); j++)`
571	`{`	568	`{`
572	`if ( !entries )`	569	`if ( !entries )`
573	`{`	570	`{`
574	`line = line.tokens(";", j + 1);`	571	`line = line.tokens(L";", j + 1);`
575	`if ( !line.empty() )`	572	`if ( !line.empty() )`
576	`done = false;`	573	`done = false;`
577	`break;`	574	`break;`
578	`}`	575	`}`
579		576
580	`if ( strs[j].empty() )`	577	`if ( strs[j].empty() )`
581	`continue;`	578	`continue;`
582		579
583	`this->addBodies(section + ";" + strs[j] + ";");`	580	`this->addBodies(section + L";" + strs[j] + L";");`
584	`--entries;`	581	`--entries;`
585	`}`	582	`}`
586	`//we must be at another section`	583	`//we must be at another section`
587	`if ( !done )`	584	`if ( !done )`
588	`{`	585	`{`
589	`section = line.token(";", 1);`	586	`section = line.token(L";", 1);`
590	`entries = line.token(";", 2).toInt();`	587	`entries = line.token(L";", 2).toInt();`
591	`line = line.remToken(";", 1);`	588	`line = line.remToken(L";", 1);`
592	`line = line.remToken(";", 1);`	589	`line = line.remToken(L";", 1);`
593		590
594	`if (line.empty())`	591	`if (line.empty())`
595	`done = true;`	592	`done = true;`
596	`}`	593	`}`
597		-
598	`CLEANSPLIT(strs, num)`	-
599	`}`	594	`}`
600	`}`	595	`}`
601	`}`	596	`}`
602	`}`	597	`}`
603	`}`	598	`}`
604	`// animations`	599	`// animations`
605	`else if ( special == 3 )`	600	`else if ( special == 3 )`
606	`{`	601	`{`
607	`Utils::CStringList in;`	602	`Utils::WStringList in;`
608	`for ( int i = 0; i <; iLines; i++ )`	603	`for (size_t i = 0; i <; sLines.size(); i++)`
609	`in.pushBack(sLines[i]);`	604	`in.pushBack(sLines[i]);`
610		605
611	`Utils::CStringList out;`	606	`Utils::WStringList out;`
612	`if ( CXspFile::ReadAnimations(in, out, 87) )`	607	`if ( CXspFile::ReadAnimations(in, out, 87) )`
613	`this->addAnimation(out);`	608	`this->addAnimation(out);`
614	`}`	609	`}`
615	`}`	610	`}`
616	`CLEANSPLIT(sLines, iLines)`	-
617	`delete newFile;`	611	`delete newFile;`
618	`}`	612	`}`
619	`}`	613	`}`
620	`else if ( first.Compare("Script") )`	614	`else if ( first.Compare(L"Script") )`
621	`{`	615	`{`
622	`Utils::String file = rest.words(3);`	616	`Utils::WString file = rest.words(3);`
623	`C_File *newFile= this->addFile(file, Utils::String::Null(), FILETYPE_SCRIPT);`	617	`C_File *newFile= this->addFile(file, Utils::WString::Null(), FILETYPE_SCRIPT);`
624	`newFile->SetCreationTime((long)rest.word(1));`	618	`newFile->SetCreationTime((long)rest.word(1));`
625	`newFile->ReadFromData((char *)(compr + pos), rest.word(2));`	619	`newFile->ReadFromData((char *)(compr + pos), rest.word(2));`
626		620
627	`start += (newFile->GetDataSize() + 1);`	621	`start += (newFile->GetDataSize() + 1);`
628	`}`	622	`}`
629	`else if ( first.Compare("Text") )`	623	`else if ( first.Compare(L"Text") )`
630	`this->addText(rest.token(":", 1), rest.token(":", 2), rest.tokens(":", 3));`	624	`this->addText(rest.token(L":", 1), rest.token(L":", 2), rest.tokens(L":", 3));`
631	`else if ( first.Compare("Component") )`	625	`else if ( first.Compare(L"Component") )`
632	`this->addComponent(rest.token(";", 1), rest.token(";", 2), rest.tokens(";", 3));`	626	`this->addComponent(rest.token(L";", 1), rest.token(L";", 2), rest.tokens(L";", 3));`
633	`else if ( first.Compare("Dummy") )`	627	`else if ( first.Compare(L"Dummy") )`
634	`{`	628	`{`
635	`SDummy *d = new SDummy;`	629	`SDummy *d = new SDummy;`
636	`d->sData = rest.tokens(";", 2).toWString();`	630	`d->sData = rest.tokens(L";", 2);`
637	`d->sSection = rest.token(";", 1).toWString();`	631	`d->sSection = rest.token(L";", 1);`
638	`m_lDummy.push_back ( d );`	632	`m_lDummy.push_back ( d );`
639	`}`	633	`}`
640	`else if ( !this->parseValueLine(line) )`	634	`else if ( !this->parseValueLine(line) )`
641	`{`	635	`{`
642	`// printf ( "Command: %s, Rest: %s\n", first.c_str(), rest.c_str());`	636	`// printf ( "Command: %s, Rest: %s\n", first.c_str(), rest.c_str());`
Line 648...	Line 642...
648	`// assume all old ones are for X3`	642	`// assume all old ones are for X3`
649	`if ( !m_sData.empty() )`	643	`if ( !m_sData.empty() )`
650	`{`	644	`{`
651	`this->AddWeaponMask(GAME_X3 - 1, m_sData.token(L";", 19));`	645	`this->AddWeaponMask(GAME_X3 - 1, m_sData.token(L";", 19));`
652	`this->AddMissileMask(GAME_X3 - 1, m_sData.token(L";", 25));`	646	`this->AddMissileMask(GAME_X3 - 1, m_sData.token(L";", 25));`
653	`}`	647	`}`
654		648
655	`return true;`	649	`return true;`
656	`}`	650	`}`
657		651
658		652
659	`int GetMaxShipyards() { return (int)SHIPYARD_MAX; }`	653	`int GetMaxShipyards() { return (int)SHIPYARD_MAX; }`
Line 696...	Line 690...
696	`return true;`	690	`return true;`
697	`return false;`	691	`return false;`
698	`}`	692	`}`
699		693
700	`void CXspFile::SetLaserMask(int game, int mask)`	694	`void CXspFile::SetLaserMask(int game, int mask)`
701	`{`	695	`{`
702	`for ( CListNode<SWeaponMask> *node = m_lWeaponMasks.Front(); node; node = node->next() )`	696	`for ( CListNode<SWeaponMask> *node = m_lWeaponMasks.Front(); node; node = node->next() )`
703	`{`	697	`{`
704	`SWeaponMask *m = node->Data();`	698	`SWeaponMask *m = node->Data();`
705	`if ( m->iGame == game )`	699	`if ( m->iGame == game )`
706	`{`	700	`{`
707	`m->iMask = mask;`	701	`m->iMask = mask;`
708	`return;`	702	`return;`
709	`}`	703	`}`
710	`}`	704	`}`
711		705
712	`// no found, need to add it`	706	`// no found, need to add it`
713	`this->AddWeaponMask(game, mask);`	707	`this->AddWeaponMask(game, mask);`
714	`}`	708	`}`
715		709
716	`void CXspFile::SetMissileMask(int game, int mask)`	710	`void CXspFile::SetMissileMask(int game, int mask)`
717	`{`	711	`{`
718	`for ( CListNode<SWeaponMask> *node = m_lMissileMasks.Front(); node; node = node->next() )`	712	`for ( CListNode<SWeaponMask> *node = m_lMissileMasks.Front(); node; node = node->next() )`
719	`{`	713	`{`
720	`SWeaponMask *m = node->Data();`	714	`SWeaponMask *m = node->Data();`
Line 730...	Line 724...
730	`}`	724	`}`
731	`int CXspFile::GetLaserMask(int game, bool getOnly)`	725	`int CXspFile::GetLaserMask(int game, bool getOnly)`
732	`{`	726	`{`
733	`int mask = -1;`	727	`int mask = -1;`
734	`for ( CListNode<SWeaponMask> *node = m_lWeaponMasks.Front(); node; node = node->next() )`	728	`for ( CListNode<SWeaponMask> *node = m_lWeaponMasks.Front(); node; node = node->next() )`
735	`{`	729	`{`
736	`SWeaponMask *m = node->Data();`	730	`SWeaponMask *m = node->Data();`
737	`if ( m->iGame == game )`	731	`if ( m->iGame == game )`
738	`return m->iMask;`	732	`return m->iMask;`
739		733
740	`if ( !mask && !getOnly )`	734	`if ( !mask && !getOnly )`
741	`mask = m->iMask;`	735	`mask = m->iMask;`
742	`}`	736	`}`
743		737
744	`return mask;`	738	`return mask;`
745	`}`	739	`}`
746		740
747	`int CXspFile::GetMissileMask(int game, bool getOnly)`	741	`int CXspFile::GetMissileMask(int game, bool getOnly)`
748	`{`	742	`{`
749	`int mask = -1;`	743	`int mask = -1;`
750	`for ( CListNode<SWeaponMask> *node = m_lMissileMasks.Front(); node; node = node->next() )`	744	`for ( CListNode<SWeaponMask> *node = m_lMissileMasks.Front(); node; node = node->next() )`
751	`{`	745	`{`
752	`SWeaponMask *m = node->Data();`	746	`SWeaponMask *m = node->Data();`
753	`if ( m->iGame == game )`	747	`if ( m->iGame == game )`
754	`return m->iMask;`	748	`return m->iMask;`
755		749
756	`if ( !mask && !getOnly )`	750	`if ( !mask && !getOnly )`
757	`mask = m->iMask;`	751	`mask = m->iMask;`
758	`}`	752	`}`
759		753
760	`return mask;`	754	`return mask;`
761	`}`	755	`}`
762		756
763	`void CXspFile::clearCutData()`	757	`void CXspFile::clearCutData()`
764	`{`	758	`{`
765	`_lCutData.clear();`	759	`_lCutData.clear();`
766	`}`	760	`}`
Line 829...	Line 823...
829		823
830	`if ( m_lText.size() ) {`	824	`if ( m_lText.size() ) {`
831	`list->pushBack(L"# Ship Texts, the name/description of the ship in each language: <LANGID> <NAME>\|<DESCRIPTION>");`	825	`list->pushBack(L"# Ship Texts, the name/description of the ship in each language: <LANGID> <NAME>\|<DESCRIPTION>");`
832	`for(CListNode<SText> *node = m_lText.Front(); node; node = node->next()) {`	826	`for(CListNode<SText> *node = m_lText.Front(); node; node = node->next()) {`
833	`list->pushBack(Utils::WString(L"ShipText: ") + (long)node->Data()->iId + L" " + node->Data()->sName + L"\|" + node->Data()->sDesc);`	827	`list->pushBack(Utils::WString(L"ShipText: ") + (long)node->Data()->iId + L" " + node->Data()->sName + L"\|" + node->Data()->sDesc);`
834	`}`	828	`}`
835		829
836	`list->pushBack(L"");`	830	`list->pushBack(L"");`
837	`}`	831	`}`
838		832
839	`if ( this->m_lWeaponMasks.size() ) {`	833	`if ( this->m_lWeaponMasks.size() ) {`
840	`list->pushBack(L"# Weapon Masks, the weapons for each game: <GAME> <MASK>");`	834	`list->pushBack(L"# Weapon Masks, the weapons for each game: <GAME> <MASK>");`
Line 876...	Line 870...
876	`list->pushBack(L"Cockpit: " + node->Data()->sCockpit.token(L";", 19) + L" " + node->Data()->sCockpit);`	870	`list->pushBack(L"Cockpit: " + node->Data()->sCockpit.token(L";", 19) + L" " + node->Data()->sCockpit);`
877	`for(SWeaponMask *mask = node->Data()->lWeaponMask.First(); mask; mask = node->Data()->lWeaponMask.Next()) {`	871	`for(SWeaponMask *mask = node->Data()->lWeaponMask.First(); mask; mask = node->Data()->lWeaponMask.Next()) {`
878	`list->pushBack(L"CockpitWeapon: " + node->Data()->sCockpit.token(L";", 19) + L" " + (long)mask->iGame + L" " + (long)mask->iMask);`	872	`list->pushBack(L"CockpitWeapon: " + node->Data()->sCockpit.token(L";", 19) + L" " + (long)mask->iGame + L" " + (long)mask->iMask);`
879	`}`	873	`}`
880	`}`	874	`}`
881		875
882	`list->pushBack(L"");`	876	`list->pushBack(L"");`
883	`}`	877	`}`
884		878
885	`if (!this->_lCutData.empty())`	879	`if (!this->_lCutData.empty())`
886	`{`	880	`{`
887	`list->pushBack(L"# Ship Cut Data");`	881	`list->pushBack(L"# Ship Cut Data");`
888	`for(auto itr = _lCutData.begin(); itr != _lCutData.end(); itr++)`	882	`for(auto itr = _lCutData.begin(); itr != _lCutData.end(); itr++)`
889	`list->pushBack(L"CutData: " + (*itr)->str);`	883	`list->pushBack(L"CutData: " + (*itr)->str);`
890	`list->pushBack(L"");`	884	`list->pushBack(L"");`
891	`}`	885	`}`
892		886
893	`if (!this->_lBodies.empty())`	887	`if (!this->_lBodies.empty())`
894	`{`	888	`{`
895	`list->pushBack(L"# Ship Bodies");`	889	`list->pushBack(L"# Ship Bodies");`
Line 902...	Line 896...
902	`{`	896	`{`
903	`list->pushBack(L"# Ship Animations");`	897	`list->pushBack(L"# Ship Animations");`
904	`for (auto itr = _lAnimations.begin(); itr != _lAnimations.end(); itr++)`	898	`for (auto itr = _lAnimations.begin(); itr != _lAnimations.end(); itr++)`
905	`list->pushBack(L"Animation: " + (*itr)->str);`	899	`list->pushBack(L"Animation: " + (*itr)->str);`
906	`list->pushBack(L"");`	900	`list->pushBack(L"");`
907	`}`	901	`}`
908		902
909	`if ( !datafile )`	903	`if ( !datafile )`
910	`{`	904	`{`
911	`if ( !CBaseFile::GeneratePackagerScriptFile(wildcard, list, game, gameAddons) )`	905	`if ( !CBaseFile::GeneratePackagerScriptFile(wildcard, list, game, gameAddons) )`
912	`return false;`	906	`return false;`
913	`}`	907	`}`
Line 949...	Line 943...
949	`}`	943	`}`
950		944
951	`void CXspFile::addDummiesToList(Utils::CList<STypesSection> &list)`	945	`void CXspFile::addDummiesToList(Utils::CList<STypesSection> &list)`
952	`{`	946	`{`
953	`ADDSECTIONLIST(SDummy, m_lDummy);`	947	`ADDSECTIONLIST(SDummy, m_lDummy);`
954	`}`	948	`}`
955		949
956	`void CXspFile::addComponentsToList(CLinkList<SComponentEntry> &componentList)`	950	`void CXspFile::addComponentsToList(CLinkList<SComponentEntry> &componentList)`
957	`{`	951	`{`
958	`for(CListNode<SComponent> *node = m_lComponent.Front(); node; node = node->next()) {`	952	`for(CListNode<SComponent> *node = m_lComponent.Front(); node; node = node->next()) {`
959	`SComponentEntry *currentSection = NULL;`	953	`SComponentEntry *currentSection = NULL;`
960	`for(CListNode<SComponentEntry> *cNode = componentList.Front(); cNode; cNode = cNode->next()) {`	954	`for(CListNode<SComponentEntry> *cNode = componentList.Front(); cNode; cNode = cNode->next()) {`
Line 1022...	Line 1016...
1022	`}`	1016	`}`
1023	`}`	1017	`}`
1024	`break;`	1018	`break;`
1025	`case 3:`	1019	`case 3:`
1026	`GENERATESECTION(L"Dummies", SDummy, this->m_lDummy);`	1020	`GENERATESECTION(L"Dummies", SDummy, this->m_lDummy);`
1027	`break;`	1021	`break;`
1028	`case 4:`	1022	`case 4:`
1029	`GENERATESTRINGSECTION(L"Bodies", this->_lBodies, true);`	1023	`GENERATESTRINGSECTION(L"Bodies", this->_lBodies, true);`
1030	`break;`	1024	`break;`
1031	`}`	1025	`}`
1032		1026
1033	`if ( type.empty() ) continue;`	1027	`if ( type.empty() ) continue;`
1034		1028
1035	`Utils::WString fname = L"GENERATED/types/" + type + L".txt";`	1029	`Utils::WString fname = L"GENERATED/types/" + type + L".txt";`
1036		1030
1037	`Utils::WString fileData = L"// Exported " + type + L" file, Generated by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2) + L"\r\n" + data;`	1031	`Utils::WString fileData = L"// Exported " + type + L" file, Generated by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2) + L"\r\n" + data;`
Line 1045...	Line 1039...
1045	`wsprintf(buf, L"%hs", fname.c_str());`	1039	`wsprintf(buf, L"%hs", fname.c_str());`
1046	`if ( tmpFile.startRead() ) {`	1040	`if ( tmpFile.startRead() ) {`
1047	`*/`	1041	`*/`
1048	`ZipAdd(hz, fname.c_str(), (void )fileData.c_str(), fileData.length() sizeof(wchar_t));`	1042	`ZipAdd(hz, fname.c_str(), (void )fileData.c_str(), fileData.length() sizeof(wchar_t));`
1049	`//}`	1043	`//}`
1050	`}`	1044	`}`
1051	`}`	1045	`}`
1052		1046
1053	`bool CXspFile::loadPackageData(const Utils::WString &sFirst, const Utils::WString &sRest, const Utils::WString &sMainGame, Utils::WStringList &otherGames, Utils::WStringList &gameAddons, CProgressInfo *progress)`	1047	`bool CXspFile::loadPackageData(const Utils::WString &sFirst, const Utils::WString &sRest, const Utils::WString &sMainGame, Utils::WStringList &otherGames, Utils::WStringList &gameAddons, CProgressInfo *progress)`
1054	`{`	1048	`{`
1055	`if ( sFirst.Compare(L"Shipyard") )`	1049	`if ( sFirst.Compare(L"Shipyard") )`
1056	`{`	1050	`{`
Line 1095...	Line 1089...
1095	`else if ( sFirst.Compare(L"Animation") )`	1089	`else if ( sFirst.Compare(L"Animation") )`
1096	`this->addAnimation(sRest);`	1090	`this->addAnimation(sRest);`
1097	`else if ( sFirst.Compare(L"Bodies") )`	1091	`else if ( sFirst.Compare(L"Bodies") )`
1098	`this->addBodies(sRest);`	1092	`this->addBodies(sRest);`
1099	`else if ( !CBaseFile::loadPackageData(sFirst, sRest, sMainGame, otherGames, gameAddons, progress) )`	1093	`else if ( !CBaseFile::loadPackageData(sFirst, sRest, sMainGame, otherGames, gameAddons, progress) )`
1100	`{`	1094	`{`
1101	`return false;`	1095	`return false;`
1102	`}`	1096	`}`
1103		1097
1104	`return true;`	1098	`return true;`
1105	`}`	1099	`}`
1106		1100
1107		1101
1108	`Utils::WString CXspFile::getX3ShipData() const`	1102	`Utils::WString CXspFile::getX3ShipData() const`
1109	`{`	1103	`{`
1110	`Utils::WString data = m_sData;`	1104	`Utils::WString data = m_sData;`
Line 1117...	Line 1111...
1117	`Utils::WString sClass = data.token(L";", TSHIPPOS_CLASS);`	1111	`Utils::WString sClass = data.token(L";", TSHIPPOS_CLASS);`
1118	`if ( !((long)sClass) && sClass != L"0" )`	1112	`if ( !((long)sClass) && sClass != L"0" )`
1119	`{`	1113	`{`
1120	`int num = 0;`	1114	`int num = 0;`
1121	`for ( int i = 0; i < OBJ_SHIP_MAX; i++ )`	1115	`for ( int i = 0; i < OBJ_SHIP_MAX; i++ )`
1122	`{`	1116	`{`
1123	`if ( sClass.Compare(CShipData::ConvertShipClass(CShipData::GetShipClassFromNum(i))) )`	1117	`if ( sClass.Compare(CShipData::ConvertShipClass(CShipData::GetShipClassFromNum(i))) )`
1124	`{`	1118	`{`
1125	`num = i;`	1119	`num = i;`
1126	`break;`	1120	`break;`
1127	`}`	1121	`}`
1128	`}`	1122	`}`
1129		1123
1130	`data = data.replaceToken(L";", TSHIPPOS_CLASS, (long)num);`	1124	`data = data.replaceToken(L";", TSHIPPOS_CLASS, (long)num);`
1131	`}`	1125	`}`
1132		1126
1133	`return data;`	1127	`return data;`
1134	`}`	1128	`}`
1135		1129
1136	`Utils::WString CXspFile::getTCShipData() const`	1130	`Utils::WString CXspFile::getTCShipData() const`
1137	`{`	1131	`{`
1138	`Utils::WString data = m_sData;`	1132	`Utils::WString data = m_sData;`
1139		1133
1140	`Utils::WString sSubType = data.token(L";", 6);`	1134	`Utils::WString sSubType = data.token(L";", 6);`
1141	`if ( ((long)sSubType) \|\| sSubType == L"0" )`	1135	`if ( ((long)sSubType) \|\| sSubType == L"0" )`
1142	`data = data.replaceToken(L";", 6, CShipData::ConvertShipSubType((long)sSubType));`	1136	`data = data.replaceToken(L";", 6, CShipData::ConvertShipSubType((long)sSubType));`
1143		1137
Line 1162...	Line 1156...
1162	`bool ret = false;`	1156	`bool ret = false;`
1163	`for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )`	1157	`for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )`
1164	`{`	1158	`{`
1165	`Utils::WString id = node->Data()->sCockpit.token(L";", 19);`	1159	`Utils::WString id = node->Data()->sCockpit.token(L";", 19);`
1166	`if ( id.Compare(cockpitid) )`	1160	`if ( id.Compare(cockpitid) )`
1167	`{`	1161	`{`
1168	`node->DeleteData();`	1162	`node->DeleteData();`
1169	`ret = true;`	1163	`ret = true;`
1170	`break;`	1164	`break;`
1171	`}`	1165	`}`
1172	`}`	1166	`}`
1173		1167
1174	`m_lCockpit.RemoveEmpty();`	1168	`m_lCockpit.RemoveEmpty();`
1175		1169
1176	`return ret;`	1170	`return ret;`
Line 1180...	Line 1174...
1180	`{`	1174	`{`
1181	`bool ret = false;`	1175	`bool ret = false;`
1182	`for ( CListNode<SComponent> *node = m_lComponent.Front(); node; node = node->next() )`	1176	`for ( CListNode<SComponent> *node = m_lComponent.Front(); node; node = node->next() )`
1183	`{`	1177	`{`
1184	`if ( node->Data()->sSection.Compare(section1) && node->Data()->sSection2.Compare(section2) && node->Data()->sData.Compare(data) )`	1178	`if ( node->Data()->sSection.Compare(section1) && node->Data()->sSection2.Compare(section2) && node->Data()->sData.Compare(data) )`
1185	`{`	1179	`{`
1186	`ret = true;`	1180	`ret = true;`

Subversion Repositories spk

(root)//libspk/src/XspFile.cpp – Rev 217 → 218