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> strs;
			if(rest.tokenise(L";", 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> sLines;
 
				if(data.tokenise(L"\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> 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());

	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;
							}

								--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> words;
			if(line.tokenise(L";", 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;

							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;
					}
				}
			}
 

{
	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> strs;
 
					int num = material.token(L";", 5);
					if(material.tokens(L";", 6).tokenise(L"; ", 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) )

	}
 
	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> strs;
					if(l.tokenise(L";", 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 1207...	Line 1201...
1207	`m_lDummy.RemoveEmpty();`	1201	`m_lDummy.RemoveEmpty();`
1208		1202
1209	`return ret;`	1203	`return ret;`
1210	`}`	1204	`}`
1211		1205
1212	`Utils::String CXspFile::GetCockpitData(const Utils::String &cid)`	1206	`Utils::WString CXspFile::getCockpitData(const Utils::WString &cid)`
1213	`{`	1207	`{`
1214	`for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )`	1208	`for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )`
1215	`{`	1209	`{`
1216	`Utils::WString id = node->Data()->sCockpit.token(L";", 19);`	1210	`Utils::WString id = node->Data()->sCockpit.token(L";", 19);`
1217	`if ( id.Compare(cid) )`	1211	`if ( id.Compare(cid) )`
1218	`return node->Data()->sCockpit.toString();`	1212	`return node->Data()->sCockpit;`
1219	`}`	1213	`}`
1220		1214
1221	`return "";`	1215	`return L"";`
1222	`}`	1216	`}`
1223		1217
1224	`SCockpit *CXspFile::FindCockpit(const Utils::String &cid)`	1218	`SCockpit *CXspFile::findCockpit(const Utils::WString &cid)`
1225	`{`	1219	`{`
1226	`for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )`	1220	`for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )`
1227	`{`	1221	`{`
1228	`Utils::WString id = node->Data()->sCockpit.token(L";", 19);`	1222	`Utils::WString id = node->Data()->sCockpit.token(L";", 19);`
1229	`if ( id.Compare(cid) )`	1223	`if ( id.Compare(cid) )`
1230	`return node->Data();`	1224	`return node->Data();`
1231	`}`	1225	`}`
1232		1226
1233	`return NULL;`	1227	`return nullptr;`
1234	`}`	1228	`}`
1235		1229
1236	`void CXspFile::EditCockpit(const Utils::String &cid, const Utils::String &cockpit)`	1230	`void CXspFile::editCockpit(const Utils::WString &cid, const Utils::WString &cockpit)`
1237	`{`	1231	`{`
1238	`for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )`	1232	`for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )`
1239	`{`	1233	`{`
1240	`Utils::WString id = node->Data()->sCockpit.token(L";", 19);`	1234	`Utils::WString id = node->Data()->sCockpit.token(L";", 19);`
1241	`if ( id.Compare(cid) )`	1235	`if ( id.Compare(cid) )`
1242	`{`	1236	`{`
1243	`node->Data()->sCockpit = cockpit.toWString();`	1237	`node->Data()->sCockpit = cockpit;`
1244	`break;`	1238	`break;`
1245	`}`	1239	`}`
1246	`}`	1240	`}`
1247	`}`	1241	`}`
1248		1242
1249	`void CXspFile::EditCockpit(const Utils::String &cid, const Utils::String &scene, int mask)`	1243	`void CXspFile::editCockpit(const Utils::WString &cid, const Utils::WString &scene, int mask)`
1250	`{`	1244	`{`
1251	`for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )`	1245	`for ( CListNode<SCockpit> *node = m_lCockpit.Front(); node; node = node->next() )`
1252	`{`	1246	`{`
1253	`Utils::WString id = node->Data()->sCockpit.token(L";", 19);`	1247	`Utils::WString id = node->Data()->sCockpit.token(L";", 19);`
1254	`if ( id.Compare(cid) )`	1248	`if ( id.Compare(cid) )`
Line 1259...	Line 1253...
1259	`node->Data()->sCockpit = cockpit;`	1253	`node->Data()->sCockpit = cockpit;`
1260	`break;`	1254	`break;`
1261	`}`	1255	`}`
1262	`}`	1256	`}`
1263	`}`	1257	`}`
1264	`void CXspFile::NewCockpit(const Utils::String &id, const Utils::String &scene, int mask)`	1258	`void CXspFile::newCockpit(const Utils::WString &id, const Utils::WString &scene, int mask)`
1265	`{`	1259	`{`
1266	`Utils::WString cockpit = L"0;0;0;0;0;0;0;";`	1260	`Utils::WString cockpit = L"0;0;0;0;0;0;0;";`
1267	`cockpit += scene.toWString() + L";";`	1261	`cockpit += scene + L";";`
1268	`cockpit += (long)mask;`	1262	`cockpit += (long)mask;`
1269	`cockpit += L";0;0;0;0;0;0;-100000;0;0;";`	1263	`cockpit += L";0;0;0;0;0;0;-100000;0;0;";`
1270	`cockpit += id.toWString() + L";";`	1264	`cockpit += id + L";";`
1271	`this->addCockpit(cockpit, -1);`	1265	`this->addCockpit(cockpit, -1);`
1272	`}`	1266	`}`
1273		1267
1274	`bool CXspFile::removeCutData(const Utils::WString &cut)`	1268	`bool CXspFile::removeCutData(const Utils::WString &cut)`
1275	`{`	1269	`{`
Line 1408...	Line 1402...
1408	`_changed();`	1402	`_changed();`
1409	`}`	1403	`}`
1410	`}`	1404	`}`
1411		1405
1412		1406
1413	`int CXspFile::GetAnimationType(const Utils::String &type)`	1407	`int CXspFile::GetAnimationType(const Utils::WString &type)`
1414	`{`	1408	`{`
1415	`if ( type.Compare("TAT_TAGSINGLESTEP") )`	1409	`if ( type.Compare(L"TAT_TAGSINGLESTEP") )`
1416	`return TAT_SINGLE;`	1410	`return TAT_SINGLE;`
1417	`else if ( type.Compare("TAT_TAGONESHOT")`	1411	`else if ( type.Compare(L"TAT_TAGONESHOT")`
1418	`\|\| type.Compare("TAT_TAGONESHOT_REINIT")`	1412	`\|\| type.Compare(L"TAT_TAGONESHOT_REINIT")`
1419	`\|\| type.Compare("TAT_PINGPONG")`	1413	`\|\| type.Compare(L"TAT_PINGPONG")`
1420	`\|\| type.Compare("TAT_TAGLOOP") )`	1414	`\|\| type.Compare(L"TAT_TAGLOOP") )`
1421	`return TAT_3;`	1415	`return TAT_3;`
1422		1416
1423	`return TAT_NONE;`	1417	`return TAT_NONE;`
1424	`}`	1418	`}`
1425		1419
Line 1439...	Line 1433...
1439	`}`	1433	`}`
1440		1434
1441	`return data;`	1435	`return data;`
1442	`}`	1436	`}`
1443		1437
1444	`bool CXspFile::ReadAnimations(const Utils::WStringList& lIn, Utils::WStringList& lOut, int startRecord)`	1438	`bool CXspFile::ReadAnimations(const Utils::WStringList &lIn, Utils::WStringList &lOut, int startRecord)`
1445	`{`	1439	`{`
1446	`Utils::WString lastComment;`	1440	`Utils::WString lastComment;`
1447	`Utils::WString addEntry;`	1441	`Utils::WString addEntry;`
1448	`int remaining = 0;`	1442	`int remaining = 0;`
1449	`Utils::WString lastType;`	1443	`Utils::WString lastType;`
1450	`int newEntries = 0;`	1444	`int newEntries = 0;`
1451	`int entries = -1;`	1445	`int entries = -1;`
1452	`for (auto itr = lIn.begin(); itr != lIn.end(); itr++)`	1446	`for(auto itr = lIn.begin(); itr != lIn.end(); itr++)`
1453	`{`	1447	`{`
1454	`Utils::WString line = (*itr)->str;`	1448	`Utils::WString line = (*itr)->str;`
1455	`line.removeChar('\r');`	1449	`line.removeChar('\r');`
1456	`line.removeChar(9);`	1450	`line.removeChar(9);`
1457	`if (line.empty() \|\| line[0] == '/')`	1451	`if ( line.empty() \|\| line[0] == '/' )`
1458	`continue;`	1452	`continue;`
1459	`if (entries == -1)`	1453	`if ( entries == -1)`
1460	`{`	1454	`{`
1461	`entries = line.token(L";", 1);`	1455	`entries = line.token(L";", 1);`
1462	`newEntries = entries - startRecord;`	1456	`newEntries = entries - startRecord;`
1463	`}`	1457	`}`
1464	`else`	1458	`else`
1465	`{`	1459	`{`
1466	`// remove comments, endspaces and last ;`	1460	`// remove comments, endspaces and last ;`
1467	`Utils::WString sStriped = line;`	1461	`Utils::WString sStriped = line;`
1468	`if (sStriped.contains(L"//"))`	1462	`if ( sStriped.contains(L"//") )`
1469	`{`	1463	`{`
1470	`if (entries <= newEntries)`	1464	`if ( entries <= newEntries )`
1471	`lastComment = L"//" + sStriped.tokens(L"//", 2);`	1465	`lastComment = L"//" + sStriped.tokens(L"//", 2);`
1472	`sStriped = sStriped.token(L"//", 1);`	1466	`sStriped = sStriped.token(L"//", 1);`
1473	`}`	1467	`}`
1474	`sStriped.removeEndSpace();`	1468	`sStriped.removeEndSpace();`
1475	`if (sStriped.right(1) == L";")`	1469	`if ( sStriped.right(1) == L";" )`
1476	`sStriped.truncate(-1);`	1470	`sStriped.truncate(-1);`
1477		1471
1478	`Utils::WString sRemainingLeft;`	1472	`Utils::WString sRemainingLeft;`
1479	`if (remaining > 0)`	-
1480	`sRemainingLeft = sStriped;`	-
1481	`else`	-
1482	`{`	-
1483	`// each line should be a new entry, with some exceptions`	-
1484	`// potection for new lines`	-
1485	`lastType = sStriped.token(L";", 1);`	-
1486		-
1487	`switch (CXspFile::GetAnimationType(lastType.toString()))`	-
1488	`{`	-
1489	`case TAT_SINGLE:`	-
1490	`remaining = (long)sStriped.token(L";", 5) + 1;`	-
1491	`sRemainingLeft = sStriped.tokens(L";", 6);`	-
1492	`if (entries <= newEntries)`	-
1493	`addEntry = sStriped.tokens(L";", 1, 5) + L";";`	-
1494	`break;`	-
1495	`case TAT_3:`	-
1496	`remaining = (long)sStriped.token(L";", 5) + 1;`	-
1497	`sRemainingLeft = sStriped.tokens(L";", 6);`	-
1498	`if (entries <= newEntries)`	-
1499	`addEntry = sStriped.tokens(L";", 1, 5) + L";";`	-
1500	`break;`	-
1501		-
1502	`default:`	-
1503	`remaining = 0;`	-
1504	`if (entries <= newEntries)`	-
1505	`addEntry = sStriped;`	-
1506		-
1507	`}`	-
1508	`}`	-
1509		-
1510	`if (!sRemainingLeft.empty())`	-
1511	`{`	-
1512	`int tatType = CXspFile::GetAnimationType(lastType.toString());`	-
1513	`if (tatType == TAT_SINGLE)`	-
1514	`{`	-
1515	`if (sRemainingLeft.contains(L";"))`	-
1516	`remaining -= sRemainingLeft.countToken(L";");`	-
1517	`else if (!sRemainingLeft.empty())`	-
1518	`--remaining;`	-
1519		-
1520	`if (entries <= newEntries)`	-
1521	`addEntry += sRemainingLeft + L";";`	-
1522	`}`	-
1523	`else if (tatType == TAT_3)`	-
1524	`{`	-
1525	`// last entry`	-
1526	`if (remaining == 1)`	-
1527	`--remaining;`	-
1528	`else if (sRemainingLeft.contains(L";"))`	-
1529	`{`	-
1530	`if (!sRemainingLeft.contains(L"TATF_COORDS"))`	-
1531	`{`	-
1532	`int amt = sRemainingLeft.countToken(L";") / 3;`	-
1533	`remaining -= amt;`	-
1534	`if (remaining == 1 && (sRemainingLeft.countToken(L";") - (amt * 3)) == 1)`	-
1535	`--remaining;`	-
1536	`}`	-
1537	`else`	-
1538	`{`	-
1539	`int iRem = sRemainingLeft.countToken(L";");`	-
1540	`int iPos = 1;`	-
1541	`while (iPos < iRem)`	-
1542	`{`	-
1543	`Utils::WString first = sRemainingLeft.token(L";", iPos);`	-
1544	`if (first.contains(L"TATF_COORDS"))`	-
1545	`iPos += 5;`	-
1546	`else`	-
1547	`iPos += 3;`	-
1548	`--remaining;`	-
1549	`}`	-
1550		-
1551	`if (remaining == 1 && iPos == iRem)`	-
1552	`--remaining;`	-
1553	`}`	-
1554	`}`	-
1555		-
1556	`if (entries <= newEntries)`	-
1557	`addEntry += sRemainingLeft + L";";`	-
1558	`}`	-
1559	`}`	-
1560		-
1561	`if (remaining <= 0)`	-
1562	`{`	-
1563	`if (entries <= newEntries && !addEntry.empty())`	-
1564	`{`	-
1565	`if (addEntry[(int)addEntry.length() - 1] != ';')`	-
1566	`addEntry += L";";`	-
1567	`lOut.pushBack(addEntry + lastComment);`	-
1568	`}`	-
1569	`--entries;`	-
1570	`}`	-
1571	`}`	-
1572	`}`	-
1573		-
1574	`return !lOut.empty();`	-
1575	`}`	-
1576		-
1577		-
1578	`bool CXspFile::ReadAnimations(const Utils::CStringList &lIn, Utils::CStringList &lOut, int startRecord)`	-
1579	`{`	-
1580	`Utils::String lastComment;`	-
1581	`Utils::String addEntry;`	-
1582	`int remaining = 0;`	-
1583	`Utils::String lastType;`	-
1584	`int newEntries = 0;`	-
1585	`int entries = -1;`	-
1586	`for(auto itr = lIn.begin(); itr != lIn.end(); itr++)`	-
1587	`{`	-

Subversion Repositories spk

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