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



 
enum {READ_START, READ_GLOBAL, READ_SCRIPT, READ_SCRIPTFILE, READ_WARES};
enum { EXTRACT, TEST, PRINT, LIST };
 
typedef struct SDummyEntry {
	Utils::WString		sSection;
	Utils::WStringList	lEntries;
} SDummyEntry;
 
typedef struct SComponantEntry2 {
	Utils::WString		sSection;
	Utils::WStringList	lEntries;
} SComponantEntry2;
 
typedef struct SComponantEntry {
	Utils::WString		sSection;
	CLinkList<SComponantEntry2>	lEntries;
} SComponantEntry;
 
Utils::WString CPackages::m_sTempDir;
 

	{
		// read the dummies
		CFileIO File;
		if ( File.open((e == -1) ? L"Dummies.txt" : m_sTempDir + L"/Dummies.txt") )
		{
			std::vector<Utils::WString> lines;
			if(File.readLines(lines))
			{
				int insection = 0;
				SDummyEntry *currentSection = NULL;
				for ( int j = 0; j < (int)lines.size(); j++ )
				{
					Utils::WString line(lines.at(j));
					line.removeChar(9);
					line.removeChar('\r');
					line.removeFirstSpace();
					line.removeEndSpace();
					if ( line.empty() )

					// read the section, first entry is section, second is size
					while ( !line.empty() )
					{
						if ( !insection )
						{
							Utils::WString section = line.token(L";", 1);
							insection = line.token(L";", 2).toInt();
 
							// search for the sections
							currentSection = NULL;
							for ( CListNode<SDummyEntry> *node = dummyList.Front(); node; node = node->next() )
							{

								currentSection->sSection = section;
								dummyList.push_back(currentSection);
							}
 
							// we have some more ?
							line = line.remTokens(L";", 1, 2);
						}
						else
						{
							--insection;
							// check the last entry for number of states
							if ( currentSection->sSection.Compare(L"SDTYPE_GUN") )
							{
								int states = line.token(L";", 3).toInt();
								int parts = line.token(L";", 4 + (states * 2)).toInt();
								Utils::WString data = line.tokens(L";", 1, 4 + (states * 2) + (parts * 2)) + L";";
								currentSection->lEntries.pushBack(data);
 
								// remove done
								line = line.remTokens(L";", 1, 4 + (states * 2) + (parts * 2));
							}
							else
							{
								int states = line.token(L";", 3).toInt();
								Utils::WString data = line.tokens(L";", 1, 3 + (states * 2)) + L";";
								currentSection->lEntries.pushBack(data);
 
								// remove done
								line = line.remTokens(L";", 1, 3 + (states * 2));
							}
						}
					}
				}
			}

				else
				{
					bool f = false;
					for(auto itr = found->lEntries.begin(); itr != found->lEntries.end(); itr++)
					{
						if ((*itr)->str.token(L";", 1).Compare(dummy->sData.token(L";", 1)))
						{
							f = true;
							break;
						}
					}

				found->lEntries.pushBack(dummy->sData);
			}
		}
 
		// finally, write the file
		std::vector<Utils::WString> lines;
		lines.push_back(L"// Dummies file, created by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2));
		for ( SDummyEntry *dummy = dummyList.First(); dummy; dummy = dummyList.Next() )
		{
			lines.push_back(L"");
			lines.push_back(L"// Section: " + dummy->sSection + L" Entries: " + Utils::WString::Number((long)dummy->lEntries.size()));
			lines.push_back(dummy->sSection + L";" + Utils::WString::Number(dummy->lEntries.size()) + L";");
			for(auto itr = dummy->lEntries.begin(); itr != dummy->lEntries.end(); itr++)
			{
				Utils::WString strLine = (*itr)->str;
				strLine.removeChar(9);
				strLine.removeChar('\r');
				strLine.removeEndSpace();
				strLine.removeFirstSpace();
				strLine = strLine.findReplace(L"<::PiPe::>", L"|");
				if ( strLine.right(1) != L";" )
					strLine += L";";
				lines.push_back(strLine);
			}
		}
		lines.push_back(L"");
 
		// write the file to disk
		CFileIO WriteFile(m_sTempDir + L"/dummies.txt");
		if ( WriteFile.writeFile(lines) )
		{
			this->packFile(&WriteFile, L"types\\dummies.pck");
			WriteFile.remove();
		}
	}
}
 
void CPackages::CreateCutData()
{
	// first check we have any ships
	if ( m_lGameShips.empty() || !this->countPackages(TYPE_XSP, true) )
		return;
 
	bool found = false;
	for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
	{
		SGameShip *s = node->Data();
		if ( s->iType != WARETYPE_ADDED || !s->pPackage )
			continue;
 
		// no dummies to add?
		if ( !s->pPackage->anyCutData() )
			continue;
		found = true;
		break;
	}
 
	if ( !found )
		return;
 
	std::vector<Utils::WString> cutList;
	int e = extractGameFile(L"types/CutData.pck", m_sTempDir + L"/CutData.txt");
	if ( e )
	{
		CFileIO File;
		if ( File.open((e == -1) ? L"CutData.txt" : m_sTempDir + L"/CutData.txt") )
		{
 
			std::vector<Utils::WString> lines;
			if(File.readLines(lines))
			{
				int entries = -1;
				for ( int j = 0; j < (int)lines.size(); j++ )
				{
					Utils::WString line(lines.at(j));
					line.removeChar(9);
					line.removeChar('\r');
					line.removeChar(' ');
					if ( line.empty() || line[0] == '/' )
						continue;
					if ( entries == -1 )
						entries = line.token(L";", 1).toInt();
					else
					{
						if ( line.right(1) != L";" )
							line += L";";
						cutList.push_back(line);
						if ( static_cast<int>(cutList.size()) == entries)
							break;
					}
				}
			}
 
			File.remove();
		}
	}
 
	for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
	{
		SGameShip *s = node->Data();
		if ( s->iType != WARETYPE_ADDED || !s->pPackage )
			continue;
 
		// no dummies to add?
		if ( !s->pPackage->anyCutData() )
			continue;
 
		// add each dummy to list
		auto& list = s->pPackage->getCutData();
		for(auto itr = list.begin(); itr != list.end(); itr++)
		{
			Utils::WString str = (*itr)->str;
			str.removeChar(' ');
			if ( str.right(1) != L";" )
				str += L";";
			if(std::find(cutList.begin(), cutList.end(), str) == cutList.end())
				cutList.push_back(str);
		}
	}
 
	cutList.insert(cutList.begin(), Utils::WString::Number(cutList.size()) + ";");
	cutList.insert(cutList.begin(), L"/cut id;filename (leave blank to use id)");
	cutList.insert(cutList.begin(), L"// Cut Data file, created by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2));
 
	// write the file to disk
	CFileIO WriteFile(m_sTempDir + L"/CutData.txt");
	if ( WriteFile.writeFile(cutList) )
	{
		this->packFile(&WriteFile, L"types\\CutData.pck");
		WriteFile.remove();
	}
}
 
void CPackages::CreateAnimations()
{
	// first check we have any ships
	if ( m_lGameShips.empty() || !this->countPackages(TYPE_XSP, true) )
		return;
 
	bool found = false;
	for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
	{
		SGameShip *s = node->Data();
		if ( s->iType != WARETYPE_ADDED || !s->pPackage )
			continue;
 
		// no dummies to add?
		if ( !s->pPackage->anyAnimations() )
			continue;
		found = true;
		break;
	}

 
	for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
	{
		SGameShip *s = node->Data();
		if ( s->iType != WARETYPE_ADDED || !s->pPackage )
			continue;
 
		// no dummies to add?
		if ( !s->pPackage->anyAnimations() )
			continue;
 
		// add each dummy to list
		for(auto itr = s->pPackage->getAnimations().begin(); itr != s->pPackage->getAnimations().end(); itr++)
			parsedAniList.pushBack((*itr)->str.toString());
	}
 
	// format the list with added spaces
	Utils::CStringList formatedAniList;
	int lineCount = -1;

		Utils::String line = (*itr)->str.token("//", 1);
 
		// split into seperate lines
		Utils::String first = line.token(";", 1);
		if ( first.Compare("TAT_TAGSINGLESTEP") )
		{
			formatedAniList.pushBack(line.tokens(";", 1, 5) + ";");
			int max;
			Utils::String *sLines = line.tokens(";", 6).tokenise(";", &max);
			if ( max && sLines )
			{
				if ( sLines[max - 1].empty() )
					--max; // remove the last ";"
 
				for ( int i = 0; i < max; i++ )
				{
					Utils::String l = "\t" + sLines[i] + ";";
					if ( i == (max - 1) )

		found = true;
		break;
	}
 
	if ( !found )
		return;
 
	// lets read our current bodies file
	CLinkList<SBodies> bodiesList;
	SBodies *currentSection = NULL;
	int e = extractGameFile(L"types/Bodies.pck", m_sTempDir + L"/Bodies.txt");

			continue;
 
		// add each dummy to list
		for(auto itr = s->pPackage->getBodies().begin(); itr != s->pPackage->getBodies().end(); itr++)
		{
			Utils::WString section = (*itr)->str.token(L";", 1);
			Utils::WString body = (*itr)->str.tokens(L";", 2).remove(' ');
			if ( body.right(1) != L";" )
				body += L";";
 
			// find the section to add into
			SBodies *foundSection = NULL;
			for ( CListNode<SBodies> *checkBody = bodiesList.Front(); checkBody; checkBody = checkBody->next() )
			{
				if ( checkBody->Data()->sSection.Compare(section))
				{
					foundSection = checkBody->Data();
					break;
				}
			}
 
			if ( !foundSection )
			{
				foundSection = new SBodies;
				foundSection->sSection = section;
				bodiesList.push_back(foundSection);
			}
			if(!foundSection->lEntries.contains(body))
				foundSection->lEntries.pushBack(body);
		}

		// only use custom starts
		if ( !p->IsCustomStart() )
			continue;
 
		// get the name of the start to use
		Utils::WString name = p->customStartName();
		if ( name.empty() )
			continue;
 
		// find if maps file exists
		Utils::WStringList createFiles;

 
void CPackages::addCreatedFile(const Utils::WString &sFile)
{
	Utils::WString file = sFile.findRemove(m_sCurrentDir);
	while ( file[0] == '/' )
		file.erase(0, 1);
	while ( file[0] == '\\' )
		file.erase(0, 1);
 
	if(!_lCreatedFiles.contains(file, true))
		_lCreatedFiles.pushBack(file);

	{
		// read the dummies
		CFileIO File;
		if ( File.open((e == -1) ? L"Components.txt" : m_sTempDir + L"/Components.txt") )
		{
			std::vector<Utils::WString> lines;
			if(File.readLines(lines))
			{
				int insection = 0;
				int insubsection = 0;
				SComponantEntry *currentSection = NULL;
				SComponantEntry2 *currentSubSection = NULL;
				for ( int j = 0; j < (int)lines.size(); j++ )
				{
					Utils::WString line(lines.at(j));
					if ( line[0] == '/' )
						continue;
					line.removeChar('\r');
					line = line.removeFirstSpace();
					line = line.removeEndSpace();

						if ( line.empty() )
							break;
 
						if ( !insection && !insubsection )
						{
							Utils::WString section = line.token(L";", 1);
							insection = line.token(L";", 2).toInt();
 
							// search for the sections
							currentSection = NULL;
							for ( CListNode<SComponantEntry> *node = dummyList.Front(); node; node = node->next() )
							{

								currentSection->sSection = section;
								dummyList.push_back(currentSection);
							}
 
							// we have some more ?
							line = line.remTokens(L";", 1, 2);
						}
						else if ( !insubsection )
						{
							--insection;
							Utils::WString section = line.token(L";", 1);
							insubsection = line.token(L";", 2).toInt();
 
							currentSubSection = new SComponantEntry2;
							currentSubSection->sSection = section;
							currentSection->lEntries.push_back(currentSubSection);
 
							line = line.remTokens(L";", 1, 2);
						}
						else
						{
							--insubsection;
							line = line.remove(' ');
							if(!currentSubSection->lEntries.contains(line))
								currentSubSection->lEntries.pushBack(line);
							line = L"";
						}
					}
				}
 
 
			}
 
			File.remove();
		}
 

				{
					if ( eNode->Data()->sSection.Compare(dummy->sSection) )
					{
						found = eNode->Data();
						break;
					}
				}
				if ( !found )
				{
					found = new SComponantEntry;
					found->sSection = dummy->sSection;
					dummyList.push_back(found);

						}
 
						if ( f )
							continue;
					}
				}
 
				found2->lEntries.pushBack(dummy->sData.remove(' '));
			}
		}
 
		// finally, write the file
		std::vector<Utils::WString> lines;
		lines.push_back(L"// Components file, created by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2));
		for ( SComponantEntry *dummy = dummyList.First(); dummy; dummy = dummyList.Next() )
		{
			lines.push_back(L"");
			lines.push_back(L"// Section: " + dummy->sSection + L" Entries: " + Utils::WString::Number((long)dummy->lEntries.size()));
			lines.push_back(dummy->sSection + L";" + Utils::WString::Number(dummy->lEntries.size()) + L";");
			for ( CListNode<SComponantEntry2> *comp = dummy->lEntries.Front(); comp; comp = comp->next() )
			{
				lines.push_back(comp->Data()->sSection + L";" + Utils::WString::Number((long)comp->Data()->lEntries.size()) + L";");
				for(auto itr = comp->Data()->lEntries.begin(); itr != comp->Data()->lEntries.end(); itr++)
				{
					Utils::WString cStr = (*itr)->str;
					cStr.removeEndSpace();
					cStr.removeChar(9);
					cStr.removeChar('\r');
					if ( cStr.right(1) != L";" )
						cStr += L";";
					lines.push_back(cStr);
				}
			}
		}
 
		// write the file to disk
		CFileIO WriteFile(m_sTempDir + L"/Components.txt");
		if ( WriteFile.writeFile(lines) )
		{
			this->packFile(&WriteFile, L"types\\Components.pck");
			WriteFile.remove();
		}
	}

 
	return true;
}
 
bool CPackages::readCommands(int iLang, CLinkList<SCommandSlot> &list)
{
	if ( iLang == 0 ) iLang = m_iLanguage;
 
	for(CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next()) {
		if ( !node->Data()->IsEnabled() ) continue;
		node->Data()->readCommands(iLang, list);
	}
 
	return true;
}
 
bool CPackages::readWingCommands(int iLang, CLinkList<SCommandSlot> &list)
{
	if ( iLang == 0 ) iLang = m_iLanguage;
 
	for(CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next()) {
		if ( !node->Data()->IsEnabled() ) continue;
		node->Data()->readWingCommands(iLang, list);
	}
 
	return true;
}
 
int CPackages::_warePriceOverride(enum WareTypes type, int pos, const Utils::WString &id)
{
	for(CListNode<SWarePriceOverride> *node = m_lWarePrices.Front(); node; node = node->next()) {
		if ( node->Data()->type == type ) {
			if ( node->Data()->type == Ware_Custom && id.Compare(node->Data()->id) ) return node->Data()->relval;

		}
	}
}
 
int CPackages::empOveridePrice(int id)
{
	return _warePriceOverride(Ware_EMP, id, Utils::WString::Null()); 
}
 
bool CPackages::empOverideNoto(int id, int *noto)
{

}
 
void CPackages::removeBuiltinWareOverride(int pos)
{
	_removeWareOverride(Ware_BuiltIn, pos, Utils::WString::Null());
}
 
void CPackages::removeCustomWareOverride(const Utils::WString &id)
{
	_removeWareOverride(Ware_Custom, 0, id);
}
 

	Utils::WStringList globals;
	if (readGlobals(globals))
	{
		// apply out settings
		for(auto itr = _lGlobals.begin(); itr != _lGlobals.end(); itr++)
			globals.changeData((*itr)->str, (*itr)->data);
 
		// now write it
		Utils::WStringList writeList;
		for(auto itr = globals.begin(); itr != globals.end(); itr++)
			writeList.pushBack((*itr)->str + L";" + (*itr)->data + L";");
		
		// finally, write the file
		writeList.pushFront(Utils::WString::Number(writeList.size()) + L"; /globals amount", L"");
		writeList.pushFront(L"// Globals file, created by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2), L"");
 
		CFileIO WriteFile(m_sTempDir + L"/Globals.txt");
		if ( WriteFile.writeFile(&writeList) )
		{
			this->packFile(&WriteFile, L"types/Globals.pck");
			WriteFile.remove();
		}
	}
}
 
void CPackages::CreateTShips()
{
	// no ships ?
	if ( m_lGameShips.empty() )
		return;
 
	// get the cockpit list to match with ships turrets
	Utils::WStringList Cockpits;
	Utils::WStringList cockpitList;
	if(_createCockpits(cockpitList))
	{
		for(auto itr = cockpitList.begin(); itr != cockpitList.end(); itr++)
		{
			Utils::WString id = (*itr)->str.token(L";", 19);
			Cockpits.pushBack(id);
		}
	}
 
	CLinkList<SGameShip> shipOverrides;

	// read the existing tships file
	int e = extractGameFile(L"types/TShips.pck", m_sTempDir + L"/TShips.txt");
	if ( e )
	{
		int fileType = 51;
		std::vector<Utils::WString> tshipsList;
 
		// if we have no buffer, lets create one
		CFileIO File;
		if ( File.open((e == -1) ? L"TShips.txt" : m_sTempDir + L"/TShips.txt") )
		{
			int shiptext = SHIPSTARTTEXT;
 
			std::vector<Utils::WString> lines;
			if(File.readLines(lines))
			{
				int count = -1;
				for ( int j = 0; j < (int)lines.size(); j++ )
				{
					Utils::WString line(lines.at(j));
					if ( line[0] == '/' )
						continue;
					line.removeChar('\r');
					line.removeChar(9);
					line = line.removeFirstSpace();

					if ( line.empty() )
						continue;
 
					if ( count == -1 )
					{
						fileType = line.token(L";", 1).toInt();
						count = line.token(L";", 2).toInt();
					}
					else
					{
						if ( line.right(1) != L";" )
							line += L";";
 
						// check for any ship overrides
						bool added = false;
						if ( !shipOverrides.empty() )
						{

							tshipsList.push_back(line);
						--count;
						if ( count < 0 )
							break;
					}
				}
 
 
 
			}
 
			File.remove();
 
			// assign the ship buffer
			if ( !m_iShipBuffer )
				m_iShipBuffer = tshipsList.size() + 15;
			// there seems to be too many additional entries, we have no choise but to change the buffer
			else if ( static_cast<size_t>(m_iShipBuffer) <= tshipsList.size() )
				m_iShipBuffer = tshipsList.size() + 15;
 
			Utils::WString bufferStart;
			if ( m_iGame == GAME_X3 )
				bufferStart = L"0;0;0;0;0;2;499999;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0.049988;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;4;1;0;0;0;0;0;0;2092;1;1;-1;0;0;1;1;0;1;1;1;0;0;0;;-1;0;0;0;0;0;0;0;0;0;";
			else
				bufferStart = L"0;0;0;0;0;SG_SH_M5;499999;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0.049988;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;4;1;0;0;0;0;0;0;OBJ_BEACON;1;1;-1;0;0;1;1;0;1;1;1;0;0;0;;-1;0;0;0;0;0;0;0;0;0;";
			// add the buffers now
			for ( int i = tshipsList.size(); i < m_iShipBuffer; i++ )
				tshipsList.push_back(bufferStart + L"SHIP_BUFFER;");
 
			// now lets add our tships line
			for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
			{
				SGameShip *s = node->Data();

						shiptext += 2;
 
					tshipsList.push_back(s->pPackage->formatShipData(Cockpits, &s->iText, m_iGame));
				}
				else if ( s->iType == WARETYPE_DELETED )
					tshipsList.push_back(bufferStart + L"SHIP_DELETED;");
				else if ( s->iType == WARETYPE_DISABLED )
					tshipsList.push_back(bufferStart + L"SHIP_DISABLED;");
				else
					tshipsList.push_back(bufferStart + L"SHIP_SPACER;");
			}
 
			// finally, write the file
			tshipsList.insert(tshipsList.begin(), Utils::WString::Number(fileType) + L";" + Utils::WString::Number(tshipsList.size()) + L";");
			tshipsList.insert(tshipsList.begin(), L"// TShips file, created by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2));
 
			CFileIO WriteFile(m_sTempDir + L"/TShips.txt");
			if ( WriteFile.writeFile(tshipsList) )
			{
				this->packFile(&WriteFile, L"types/TShips.pck");
				WriteFile.remove();
			}
		}
	}
 
}
 
bool CPackages::packFile(const Utils::WString &filename) const
{
	// compress the file

{
	// compress the file
	CFileIO File(filename);
	size_t fileSize;
	char *fileData = File.ReadToData(&fileSize);
 
	if ( fileData && fileSize)
	{
		size_t newFileSize;
		unsigned char *pckData = UnPCKData((unsigned char *)fileData, fileSize, &newFileSize, false);
		if ( !pckData )

				if ( pckFile.isOpened() )
					pckFile.close();
 
				if ( isxml )
					pckFile.Rename(pckFile.changeFileExtension(L"xml"));
			}
 
			return true;
		}
	}
 
	return false;
}
 
bool CPackages::packFile(CFileIO* File, const Utils::WString &sFilename) const
{
	Utils::WString filename = sFilename.findReplace(L"\\", L"/");

	}
 
	return false;
}
 
size_t CPackages::_createCockpits(Utils::WStringList &list)
{
	// first check we have any ships
	if ( m_lGameShips.empty() || !this->countPackages(TYPE_XSP, true) )
		return NULL;
 

	{
		// read the dummies
		CFileIO File;
		if ( File.open((e == -1) ? L"TCockpits.txt" : m_sTempDir + L"/TCockpits.txt") )
		{
			std::vector<Utils::WString> lines;
			if(File.readLines(lines))
			{
				int count = -1;
				for(auto itr = lines.begin(); itr != lines.end(); itr++)
				{
					Utils::WString line(*itr);
					line.removeChar('\r');
					line.removeChar(9);
					line = line.removeFirstSpace();
					line = line.removeEndSpace();
					if ( line.empty() )

					if ( line[0] == '/' )
						continue;
 
					if ( count == -1 )
					{
						fileType = line.token(L";", 1).toInt();
						count = line.token(L";", 2).toInt();
					}
					else
					{
						while ( !line.empty() )
						{
							Utils::WString data = line.tokens(L";", 1, 19);
							list.pushBack(data + L";");
							line = line.remTokens(L";", 1, 19);
 
							--count;
							if ( count < 1 )
								break;
						}

				continue;
 
			for ( CListNode<SCockpit> *cn = s->pPackage->GetCockpits()->Front(); cn; cn = cn->next() )
			{
				bool foundEntry = false;
				Utils::WString cockpitStr = cn->Data()->sCockpit;
				// search for matching game entry
				for ( CListNode<SWeaponMask> *wm = cn->Data()->lWeaponMask.Front(); wm; wm = wm->next() )
				{
					if ( wm->Data()->iGame == (m_iGame - 1) )
					{
						if ( wm->Data()->iMask != -1 )
							cockpitStr = cockpitStr.replaceToken(L";", 9, Utils::WString::Number(wm->Data()->iMask));
						foundEntry = true;
						break;
					}
				}
 
				bool found = false;
				for(auto itr = list.begin(); itr != list.end(); itr++)
				{
					if ((*itr)->str.token(L";", 19).Compare(cn->Data()->sCockpit.token(L";", 19)))
					{
						// only replace existing entry if we have sepeperate weapon masks set
						if ( foundEntry )
							(*itr)->str = cockpitStr;
						found = true;

					list.pushBack(cockpitStr);
			}
		}
 
		// finally, write the file
		list.pushFront(Utils::WString::Number(fileType) + L";" + Utils::WString::Number(list.size()) + L";");
		list.pushFront(L"// TCockpits file, created by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2));
 
		CFileIO WriteFile(m_sTempDir + L"/TCockpits.txt");
		if ( WriteFile.writeFile(&list) )
		{
			this->packFile(&WriteFile, L"types\\TCockpits.pck");

Rev 215	Rev 216
Line 14...	Line 14...
14		14
15	`enum {READ_START, READ_GLOBAL, READ_SCRIPT, READ_SCRIPTFILE, READ_WARES};`	15	`enum {READ_START, READ_GLOBAL, READ_SCRIPT, READ_SCRIPTFILE, READ_WARES};`
16	`enum { EXTRACT, TEST, PRINT, LIST };`	16	`enum { EXTRACT, TEST, PRINT, LIST };`
17		17
18	`typedef struct SDummyEntry {`	18	`typedef struct SDummyEntry {`
19	`Utils::String sSection;`	19	`Utils::WString sSection;`
20	`Utils::CStringList lEntries;`	20	`Utils::WStringList lEntries;`
21	`} SDummyEntry;`	21	`} SDummyEntry;`
22		22
23	`typedef struct SComponantEntry2 {`	23	`typedef struct SComponantEntry2 {`
24	`Utils::String sSection;`	24	`Utils::WString sSection;`
25	`Utils::CStringList lEntries;`	25	`Utils::WStringList lEntries;`
26	`} SComponantEntry2;`	26	`} SComponantEntry2;`
27		27
28	`typedef struct SComponantEntry {`	28	`typedef struct SComponantEntry {`
29	`Utils::String sSection;`	29	`Utils::WString sSection;`
30	`CLinkList<SComponantEntry2> lEntries;`	30	`CLinkList<SComponantEntry2> lEntries;`
31	`} SComponantEntry;`	31	`} SComponantEntry;`
32		32
33	`Utils::WString CPackages::m_sTempDir;`	33	`Utils::WString CPackages::m_sTempDir;`
34		34
Line 6190...	Line 6190...
6190	`{`	6190	`{`
6191	`// read the dummies`	6191	`// read the dummies`
6192	`CFileIO File;`	6192	`CFileIO File;`
6193	`if ( File.open((e == -1) ? L"Dummies.txt" : m_sTempDir + L"/Dummies.txt") )`	6193	`if ( File.open((e == -1) ? L"Dummies.txt" : m_sTempDir + L"/Dummies.txt") )`
6194	`{`	6194	`{`
6195	`std::vector<Utils::String> lines;`	6195	`std::vector<Utils::WString> lines;`
6196	`if(File.readLines(lines))`	6196	`if(File.readLines(lines))`
6197	`{`	6197	`{`
6198	`int insection = 0;`	6198	`int insection = 0;`
6199	`SDummyEntry *currentSection = NULL;`	6199	`SDummyEntry *currentSection = NULL;`
6200	`for ( int j = 0; j < (int)lines.size(); j++ )`	6200	`for ( int j = 0; j < (int)lines.size(); j++ )`
6201	`{`	6201	`{`
6202	`Utils::String line(lines.at(j));`	6202	`Utils::WString line(lines.at(j));`
6203	`line.removeChar(9);`	6203	`line.removeChar(9);`
6204	`line.removeChar('\r');`	6204	`line.removeChar('\r');`
6205	`line.removeFirstSpace();`	6205	`line.removeFirstSpace();`
6206	`line.removeEndSpace();`	6206	`line.removeEndSpace();`
6207	`if ( line.empty() )`	6207	`if ( line.empty() )`
Line 6212...	Line 6212...
6212	`// read the section, first entry is section, second is size`	6212	`// read the section, first entry is section, second is size`
6213	`while ( !line.empty() )`	6213	`while ( !line.empty() )`
6214	`{`	6214	`{`
6215	`if ( !insection )`	6215	`if ( !insection )`
6216	`{`	6216	`{`
6217	`Utils::String section = line.token(";", 1);`	6217	`Utils::WString section = line.token(L";", 1);`
6218	`insection = line.token(";", 2).toInt();`	6218	`insection = line.token(L";", 2).toInt();`
6219		6219
6220	`// search for the sections`	6220	`// search for the sections`
6221	`currentSection = NULL;`	6221	`currentSection = NULL;`
6222	`for ( CListNode<SDummyEntry> *node = dummyList.Front(); node; node = node->next() )`	6222	`for ( CListNode<SDummyEntry> *node = dummyList.Front(); node; node = node->next() )`
6223	`{`	6223	`{`
Line 6235...	Line 6235...
6235	`currentSection->sSection = section;`	6235	`currentSection->sSection = section;`
6236	`dummyList.push_back(currentSection);`	6236	`dummyList.push_back(currentSection);`
6237	`}`	6237	`}`
6238		6238
6239	`// we have some more ?`	6239	`// we have some more ?`
6240	`line = line.remTokens(";", 1, 2);`	6240	`line = line.remTokens(L";", 1, 2);`
6241	`}`	6241	`}`
6242	`else`	6242	`else`
6243	`{`	6243	`{`
6244	`--insection;`	6244	`--insection;`
6245	`// check the last entry for number of states`	6245	`// check the last entry for number of states`
6246	`if ( currentSection->sSection.Compare("SDTYPE_GUN") )`	6246	`if ( currentSection->sSection.Compare(L"SDTYPE_GUN") )`
6247	`{`	6247	`{`
6248	`int states = line.token(";", 3).toInt();`	6248	`int states = line.token(L";", 3).toInt();`
6249	`int parts = line.token(";", 4 + (states * 2)).toInt();`	6249	`int parts = line.token(L";", 4 + (states * 2)).toInt();`
6250	`Utils::String data = line.tokens(";", 1, 4 + (states * 2) + (parts * 2)) + ";";`	6250	`Utils::WString data = line.tokens(L";", 1, 4 + (states * 2) + (parts * 2)) + L";";`
6251	`currentSection->lEntries.pushBack(data);`	6251	`currentSection->lEntries.pushBack(data);`
6252		6252
6253	`// remove done`	6253	`// remove done`
6254	`line = line.remTokens(";", 1, 4 + (states * 2) + (parts * 2));`	6254	`line = line.remTokens(L";", 1, 4 + (states * 2) + (parts * 2));`
6255	`}`	6255	`}`
6256	`else`	6256	`else`
6257	`{`	6257	`{`
6258	`int states = line.token(";", 3).toInt();`	6258	`int states = line.token(L";", 3).toInt();`
6259	`Utils::String data = line.tokens(";", 1, 3 + (states * 2)) + ";";`	6259	`Utils::WString data = line.tokens(L";", 1, 3 + (states * 2)) + L";";`
6260	`currentSection->lEntries.pushBack(data);`	6260	`currentSection->lEntries.pushBack(data);`
6261		6261
6262	`// remove done`	6262	`// remove done`
6263	`line = line.remTokens(";", 1, 3 + (states * 2));`	6263	`line = line.remTokens(L";", 1, 3 + (states * 2));`
6264	`}`	6264	`}`
6265	`}`	6265	`}`
6266	`}`	6266	`}`
6267	`}`	6267	`}`
6268	`}`	6268	`}`
Line 6304...	Line 6304...
6304	`else`	6304	`else`
6305	`{`	6305	`{`
6306	`bool f = false;`	6306	`bool f = false;`
6307	`for(auto itr = found->lEntries.begin(); itr != found->lEntries.end(); itr++)`	6307	`for(auto itr = found->lEntries.begin(); itr != found->lEntries.end(); itr++)`
6308	`{`	6308	`{`
6309	`if ((*itr)->str.token(";", 1).Compare(dummy->sData.token(";", 1)))`	6309	`if ((*itr)->str.token(L";", 1).Compare(dummy->sData.token(L";", 1)))`
6310	`{`	6310	`{`
6311	`f = true;`	6311	`f = true;`
6312	`break;`	6312	`break;`
6313	`}`	6313	`}`
6314	`}`	6314	`}`
Line 6320...	Line 6320...
6320	`found->lEntries.pushBack(dummy->sData);`	6320	`found->lEntries.pushBack(dummy->sData);`
6321	`}`	6321	`}`
6322	`}`	6322	`}`
6323		6323
6324	`// finally, write the file`	6324	`// finally, write the file`
6325	`std::vector<Utils::String> lines;`	6325	`std::vector<Utils::WString> lines;`
6326	`lines.push_back("// Dummies file, created by SPK Libraries V" + Utils::String::FromFloat(GetLibraryVersion(), 2));`	6326	`lines.push_back(L"// Dummies file, created by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2));`
6327	`for ( SDummyEntry *dummy = dummyList.First(); dummy; dummy = dummyList.Next() )`	6327	`for ( SDummyEntry *dummy = dummyList.First(); dummy; dummy = dummyList.Next() )`
6328	`{`	6328	`{`
6329	`lines.push_back("");`	6329	`lines.push_back(L"");`
6330	`lines.push_back("// Section: " + dummy->sSection + " Entries: " + Utils::String::Number((long)dummy->lEntries.size()));`	6330	`lines.push_back(L"// Section: " + dummy->sSection + L" Entries: " + Utils::WString::Number((long)dummy->lEntries.size()));`
6331	`lines.push_back(dummy->sSection + ";" + Utils::String::Number(dummy->lEntries.size()) + ";");`	6331	`lines.push_back(dummy->sSection + L";" + Utils::WString::Number(dummy->lEntries.size()) + L";");`
6332	`for(auto itr = dummy->lEntries.begin(); itr != dummy->lEntries.end(); itr++)`	6332	`for(auto itr = dummy->lEntries.begin(); itr != dummy->lEntries.end(); itr++)`
6333	`{`	6333	`{`
6334	`Utils::String strLine = (*itr)->str;`	6334	`Utils::WString strLine = (*itr)->str;`
6335	`strLine.removeChar(9);`	6335	`strLine.removeChar(9);`
6336	`strLine.removeChar('\r');`	6336	`strLine.removeChar('\r');`
6337	`strLine.removeEndSpace();`	6337	`strLine.removeEndSpace();`
6338	`strLine.removeFirstSpace();`	6338	`strLine.removeFirstSpace();`
6339	`strLine = strLine.findReplace("<::PiPe::>", "\|");`	6339	`strLine = strLine.findReplace(L"<::PiPe::>", L"\|");`
6340	`if ( strLine.right(1) != ";" )`	6340	`if ( strLine.right(1) != L";" )`
6341	`strLine += ";";`	6341	`strLine += L";";`
6342	`lines.push_back(strLine);`	6342	`lines.push_back(strLine);`
6343	`}`	6343	`}`
6344	`}`	6344	`}`
6345	`lines.push_back("");`	6345	`lines.push_back(L"");`
6346		6346
6347	`// write the file to disk`	6347	`// write the file to disk`
6348	`CFileIO WriteFile(m_sTempDir + L"/dummies.txt");`	6348	`CFileIO WriteFile(m_sTempDir + L"/dummies.txt");`
6349	`if ( WriteFile.writeFile(&lines) )`	6349	`if ( WriteFile.writeFile(lines) )`
6350	`{`	6350	`{`
6351	`this->packFile(&WriteFile, L"types\\dummies.pck");`	6351	`this->packFile(&WriteFile, L"types\\dummies.pck");`
6352	`WriteFile.remove();`	6352	`WriteFile.remove();`
6353	`}`	6353	`}`
6354	`}`	6354	`}`
6355	`}`	6355	`}`
6356		6356
6357	`void CPackages::CreateCutData()`	6357	`void CPackages::CreateCutData()`
6358	`{`	6358	`{`
6359	`// first check we have any ships`	6359	`// first check we have any ships`
6360	`if ( m_lGameShips.empty() \|\| !this->countPackages(TYPE_XSP, true) )`	6360	`if ( m_lGameShips.empty() \|\| !this->countPackages(TYPE_XSP, true) )`
6361	`return;`	6361	`return;`
6362		6362
6363	`bool found = false;`	6363	`bool found = false;`
6364	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`	6364	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`
6365	`{`	6365	`{`
6366	`SGameShip *s = node->Data();`	6366	`SGameShip *s = node->Data();`
6367	`if ( s->iType != WARETYPE_ADDED \|\| !s->pPackage )`	6367	`if ( s->iType != WARETYPE_ADDED \|\| !s->pPackage )`
6368	`continue;`	6368	`continue;`
6369		6369
6370	`// no dummies to add?`	6370	`// no dummies to add?`
6371	`if ( !s->pPackage->anyCutData() )`	6371	`if ( !s->pPackage->anyCutData() )`
6372	`continue;`	6372	`continue;`
6373	`found = true;`	6373	`found = true;`
6374	`break;`	6374	`break;`
6375	`}`	6375	`}`
6376		6376
6377	`if ( !found )`	6377	`if ( !found )`
6378	`return;`	6378	`return;`
6379		6379
6380	`std::vector<Utils::String> cutList;`	6380	`std::vector<Utils::WString> cutList;`
6381	`int e = extractGameFile(L"types/CutData.pck", m_sTempDir + L"/CutData.txt");`	6381	`int e = extractGameFile(L"types/CutData.pck", m_sTempDir + L"/CutData.txt");`
6382	`if ( e )`	6382	`if ( e )`
6383	`{`	6383	`{`
6384	`CFileIO File;`	6384	`CFileIO File;`
6385	`if ( File.open((e == -1) ? L"CutData.txt" : m_sTempDir + L"/CutData.txt") )`	6385	`if ( File.open((e == -1) ? L"CutData.txt" : m_sTempDir + L"/CutData.txt") )`
6386	`{`	6386	`{`
6387		-
6388	`std::vector<Utils::String> lines;`	6387	`std::vector<Utils::WString> lines;`
6389	`if(File.readLines(lines))`	6388	`if(File.readLines(lines))`
6390	`{`	6389	`{`
6391	`int entries = -1;`	6390	`int entries = -1;`
6392	`for ( int j = 0; j < (int)lines.size(); j++ )`	6391	`for ( int j = 0; j < (int)lines.size(); j++ )`
6393	`{`	6392	`{`
6394	`Utils::String line(lines.at(j));`	6393	`Utils::WString line(lines.at(j));`
6395	`line.removeChar(9);`	6394	`line.removeChar(9);`
6396	`line.removeChar('\r');`	6395	`line.removeChar('\r');`
6397	`line.removeChar(' ');`	6396	`line.removeChar(' ');`
6398	`if ( line.empty() \|\| line[0] == '/' )`	6397	`if ( line.empty() \|\| line[0] == '/' )`
6399	`continue;`	6398	`continue;`
6400	`if ( entries == -1 )`	6399	`if ( entries == -1 )`
6401	`entries = line.token(";", 1).toInt();`	6400	`entries = line.token(L";", 1).toInt();`
6402	`else`	6401	`else`
6403	`{`	6402	`{`
6404	`if ( line.right(1) != ";" )`	6403	`if ( line.right(1) != L";" )`
6405	`line += ";";`	6404	`line += L";";`
6406	`cutList.push_back(line);`	6405	`cutList.push_back(line);`
6407	`if ( static_cast<int>(cutList.size()) == entries)`	6406	`if ( static_cast<int>(cutList.size()) == entries)`
6408	`break;`	6407	`break;`
6409	`}`	6408	`}`
6410	`}`	6409	`}`
6411	`}`	6410	`}`
6412		6411
6413	`File.remove();`	6412	`File.remove();`
6414	`}`	6413	`}`
6415	`}`	6414	`}`
6416		6415
6417	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`	6416	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`
6418	`{`	6417	`{`
6419	`SGameShip *s = node->Data();`	6418	`SGameShip *s = node->Data();`
6420	`if ( s->iType != WARETYPE_ADDED \|\| !s->pPackage )`	6419	`if ( s->iType != WARETYPE_ADDED \|\| !s->pPackage )`
6421	`continue;`	6420	`continue;`
6422		6421
6423	`// no dummies to add?`	6422	`// no dummies to add?`
6424	`if ( !s->pPackage->anyCutData() )`	6423	`if ( !s->pPackage->anyCutData() )`
6425	`continue;`	6424	`continue;`
6426		6425
6427	`// add each dummy to list`	6426	`// add each dummy to list`
6428	`auto& list = s->pPackage->getCutData();`	6427	`auto& list = s->pPackage->getCutData();`
6429	`for(auto itr = list.begin(); itr != list.end(); itr++)`	6428	`for(auto itr = list.begin(); itr != list.end(); itr++)`
6430	`{`	6429	`{`
6431	`Utils::String str = (*itr)->str;`	6430	`Utils::WString str = (*itr)->str;`
6432	`str.removeChar(' ');`	6431	`str.removeChar(' ');`
6433	`if ( str.right(1) != ";" )`	6432	`if ( str.right(1) != L";" )`
6434	`str += ";";`	6433	`str += L";";`
6435	`if(std::find(cutList.begin(), cutList.end(), str) == cutList.end())`	6434	`if(std::find(cutList.begin(), cutList.end(), str) == cutList.end())`
6436	`cutList.push_back(str);`	6435	`cutList.push_back(str);`
6437	`}`	6436	`}`
6438	`}`	6437	`}`
6439		6438
6440	`cutList.insert(cutList.begin(), Utils::String::Number(cutList.size()) + ";");`	6439	`cutList.insert(cutList.begin(), Utils::WString::Number(cutList.size()) + ";");`
6441	`cutList.insert(cutList.begin(), "/cut id;filename (leave blank to use id)");`	6440	`cutList.insert(cutList.begin(), L"/cut id;filename (leave blank to use id)");`
6442	`cutList.insert(cutList.begin(), "// Cut Data file, created by SPK Libraries V" + Utils::String::FromFloat(GetLibraryVersion(), 2));`	6441	`cutList.insert(cutList.begin(), L"// Cut Data file, created by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2));`
6443		6442
6444	`// write the file to disk`	6443	`// write the file to disk`
6445	`CFileIO WriteFile(m_sTempDir + L"/CutData.txt");`	6444	`CFileIO WriteFile(m_sTempDir + L"/CutData.txt");`
6446	`if ( WriteFile.writeFile(&cutList) )`	6445	`if ( WriteFile.writeFile(cutList) )`
6447	`{`	6446	`{`
6448	`this->packFile(&WriteFile, L"types\\CutData.pck");`	6447	`this->packFile(&WriteFile, L"types\\CutData.pck");`
6449	`WriteFile.remove();`	6448	`WriteFile.remove();`
6450	`}`	6449	`}`
6451	`}`	6450	`}`
6452		6451
6453	`void CPackages::CreateAnimations()`	6452	`void CPackages::CreateAnimations()`
6454	`{`	6453	`{`
6455	`// first check we have any ships`	6454	`// first check we have any ships`
6456	`if ( m_lGameShips.empty() \|\| !this->countPackages(TYPE_XSP, true) )`	6455	`if ( m_lGameShips.empty() \|\| !this->countPackages(TYPE_XSP, true) )`
6457	`return;`	6456	`return;`
6458		6457
6459	`bool found = false;`	6458	`bool found = false;`
6460	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`	6459	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`
6461	`{`	6460	`{`
6462	`SGameShip *s = node->Data();`	6461	`SGameShip *s = node->Data();`
6463	`if ( s->iType != WARETYPE_ADDED \|\| !s->pPackage )`	6462	`if ( s->iType != WARETYPE_ADDED \|\| !s->pPackage )`
6464	`continue;`	6463	`continue;`
6465		6464
6466	`// no dummies to add?`	6465	`// no dummies to add?`
6467	`if ( !s->pPackage->anyAnimations() )`	6466	`if ( !s->pPackage->anyAnimations() )`
6468	`continue;`	6467	`continue;`
6469	`found = true;`	6468	`found = true;`
6470	`break;`	6469	`break;`
6471	`}`	6470	`}`
Line 6499...	Line 6498...
6499		6498
6500	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`	6499	`for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )`
6501	`{`	6500	`{`
6502	`SGameShip *s = node->Data();`	6501	`SGameShip *s = node->Data();`
6503	`if ( s->iType != WARETYPE_ADDED \|\| !s->pPackage )`	6502	`if ( s->iType != WARETYPE_ADDED \|\| !s->pPackage )`
6504	`continue;`	6503	`continue;`
6505		6504
6506	`// no dummies to add?`	6505	`// no dummies to add?`
6507	`if ( !s->pPackage->anyAnimations() )`	6506	`if ( !s->pPackage->anyAnimations() )`
6508	`continue;`	6507	`continue;`
6509		6508
6510	`// add each dummy to list`	6509	`// add each dummy to list`
6511	`for(auto itr = s->pPackage->getAnimations().begin(); itr != s->pPackage->getAnimations().end(); itr++)`	6510	`for(auto itr = s->pPackage->getAnimations().begin(); itr != s->pPackage->getAnimations().end(); itr++)`
6512	`parsedAniList.pushBack((*itr)->str);`	6511	`parsedAniList.pushBack((*itr)->str.toString());`
6513	`}`	6512	`}`
6514		6513
6515	`// format the list with added spaces`	6514	`// format the list with added spaces`
6516	`Utils::CStringList formatedAniList;`	6515	`Utils::CStringList formatedAniList;`
6517	`int lineCount = -1;`	6516	`int lineCount = -1;`
Line 6533...	Line 6532...
6533	`Utils::String line = (*itr)->str.token("//", 1);`	6532	`Utils::String line = (*itr)->str.token("//", 1);`
6534		6533
6535	`// split into seperate lines`	6534	`// split into seperate lines`
6536	`Utils::String first = line.token(";", 1);`	6535	`Utils::String first = line.token(";", 1);`
6537	`if ( first.Compare("TAT_TAGSINGLESTEP") )`	6536	`if ( first.Compare("TAT_TAGSINGLESTEP") )`
6538	`{`	6537	`{`
6539	`formatedAniList.pushBack(line.tokens(";", 1, 5) + ";");`	6538	`formatedAniList.pushBack(line.tokens(";", 1, 5) + ";");`
6540	`int max;`	6539	`int max;`
6541	`Utils::String *sLines = line.tokens(";", 6).tokenise(";", &max);`	6540	`Utils::String *sLines = line.tokens(";", 6).tokenise(";", &max);`
6542	`if ( max && sLines )`	6541	`if ( max && sLines )`
6543	`{`	6542	`{`
6544	`if ( sLines[max - 1].empty() )`	6543	`if ( sLines[max - 1].empty() )`
6545	`--max; // remove the last ";"`	6544	`--max; // remove the last ";"`
6546		6545
6547	`for ( int i = 0; i < max; i++ )`	6546	`for ( int i = 0; i < max; i++ )`
6548	`{`	6547	`{`
6549	`Utils::String l = "\t" + sLines[i] + ";";`	6548	`Utils::String l = "\t" + sLines[i] + ";";`
6550	`if ( i == (max - 1) )`	6549	`if ( i == (max - 1) )`
Line 6618...	Line 6617...
6618	`found = true;`	6617	`found = true;`
6619	`break;`	6618	`break;`
6620	`}`	6619	`}`
6621		6620
6622	`if ( !found )`	6621	`if ( !found )`
6623	`return;`	6622	`return;`
6624		6623
6625	`// lets read our current bodies file`	6624	`// lets read our current bodies file`
6626	`CLinkList<SBodies> bodiesList;`	6625	`CLinkList<SBodies> bodiesList;`
6627	`SBodies *currentSection = NULL;`	6626	`SBodies *currentSection = NULL;`
6628	`int e = extractGameFile(L"types/Bodies.pck", m_sTempDir + L"/Bodies.txt");`	6627	`int e = extractGameFile(L"types/Bodies.pck", m_sTempDir + L"/Bodies.txt");`
Line 6686...	Line 6685...
6686	`continue;`	6685	`continue;`
6687		6686
6688	`// add each dummy to list`	6687	`// add each dummy to list`
6689	`for(auto itr = s->pPackage->getBodies().begin(); itr != s->pPackage->getBodies().end(); itr++)`	6688	`for(auto itr = s->pPackage->getBodies().begin(); itr != s->pPackage->getBodies().end(); itr++)`
6690	`{`	6689	`{`
6691	`Utils::String section = (*itr)->str.token(";", 1);`	6690	`Utils::WString section = (*itr)->str.token(L";", 1);`
6692	`Utils::String body = (*itr)->str.tokens(";", 2).remove(' ');`	6691	`Utils::WString body = (*itr)->str.tokens(L";", 2).remove(' ');`
6693	`if ( body.right(1) != ";" )`	6692	`if ( body.right(1) != L";" )`
6694	`body += ";";`	6693	`body += L";";`
6695		6694
6696	`// find the section to add into`	6695	`// find the section to add into`
6697	`SBodies *foundSection = NULL;`	6696	`SBodies *foundSection = NULL;`
6698	`for ( CListNode<SBodies> *checkBody = bodiesList.Front(); checkBody; checkBody = checkBody->next() )`	6697	`for ( CListNode<SBodies> *checkBody = bodiesList.Front(); checkBody; checkBody = checkBody->next() )`
6699	`{`	6698	`{`
6700	`if ( checkBody->Data()->sSection.Compare(section))`	6699	`if ( checkBody->Data()->sSection.Compare(section))`
6701	`{`	6700	`{`
6702	`foundSection = checkBody->Data();`	6701	`foundSection = checkBody->Data();`
6703	`break;`	6702	`break;`
6704	`}`	6703	`}`
6705	`}`	6704	`}`
6706		6705
6707	`if ( !foundSection )`	6706	`if ( !foundSection )`
6708	`{`	6707	`{`
6709	`foundSection = new SBodies;`	6708	`foundSection = new SBodies;`
6710	`foundSection->sSection = section.toWString();`	6709	`foundSection->sSection = section;`
6711	`bodiesList.push_back(foundSection);`	6710	`bodiesList.push_back(foundSection);`
6712	`}`	6711	`}`
6713	`if(!foundSection->lEntries.contains(body))`	6712	`if(!foundSection->lEntries.contains(body))`
6714	`foundSection->lEntries.pushBack(body);`	6713	`foundSection->lEntries.pushBack(body);`
6715	`}`	6714	`}`
Line 6761...	Line 6760...
6761	`// only use custom starts`	6760	`// only use custom starts`
6762	`if ( !p->IsCustomStart() )`	6761	`if ( !p->IsCustomStart() )`
6763	`continue;`	6762	`continue;`
6764		6763
6765	`// get the name of the start to use`	6764	`// get the name of the start to use`
6766	`Utils::String name = p->GetCustomStartName();`	6765	`Utils::WString name = p->customStartName();`
6767	`if ( name.empty() )`	6766	`if ( name.empty() )`
6768	`continue;`	6767	`continue;`
6769		6768
6770	`// find if maps file exists`	6769	`// find if maps file exists`
6771	`Utils::WStringList createFiles;`	6770	`Utils::WStringList createFiles;`
Line 6800...	Line 6799...
6800		6799
6801	`void CPackages::addCreatedFile(const Utils::WString &sFile)`	6800	`void CPackages::addCreatedFile(const Utils::WString &sFile)`
6802	`{`	6801	`{`
6803	`Utils::WString file = sFile.findRemove(m_sCurrentDir);`	6802	`Utils::WString file = sFile.findRemove(m_sCurrentDir);`
6804	`while ( file[0] == '/' )`	6803	`while ( file[0] == '/' )`
6805	`file.erase(0, 1);`	6804	`file.erase(0, 1);`
6806	`while ( file[0] == '\\' )`	6805	`while ( file[0] == '\\' )`
6807	`file.erase(0, 1);`	6806	`file.erase(0, 1);`
6808		6807
6809	`if(!_lCreatedFiles.contains(file, true))`	6808	`if(!_lCreatedFiles.contains(file, true))`
6810	`_lCreatedFiles.pushBack(file);`	6809	`_lCreatedFiles.pushBack(file);`
Line 6824...	Line 6823...
6824	`{`	6823	`{`
6825	`// read the dummies`	6824	`// read the dummies`
6826	`CFileIO File;`	6825	`CFileIO File;`
6827	`if ( File.open((e == -1) ? L"Components.txt" : m_sTempDir + L"/Components.txt") )`	6826	`if ( File.open((e == -1) ? L"Components.txt" : m_sTempDir + L"/Components.txt") )`
6828	`{`	6827	`{`
6829	`std::vector<Utils::String> *lines = File.readLines();`	6828	`std::vector<Utils::WString> lines;`
6830	`if ( lines )`	6829	`if(File.readLines(lines))`
6831	`{`	6830	`{`
6832	`int insection = 0;`	6831	`int insection = 0;`
6833	`int insubsection = 0;`	6832	`int insubsection = 0;`
6834	`SComponantEntry *currentSection = NULL;`	6833	`SComponantEntry *currentSection = NULL;`
6835	`SComponantEntry2 *currentSubSection = NULL;`	6834	`SComponantEntry2 *currentSubSection = NULL;`
6836	`for ( int j = 0; j < (int)lines->size(); j++ )`	6835	`for ( int j = 0; j < (int)lines.size(); j++ )`
6837	`{`	6836	`{`
6838	`Utils::String line(lines->at(j));`	6837	`Utils::WString line(lines.at(j));`
6839	`if ( line[0] == '/' )`	6838	`if ( line[0] == '/' )`
6840	`continue;`	6839	`continue;`
6841	`line.removeChar('\r');`	6840	`line.removeChar('\r');`
6842	`line = line.removeFirstSpace();`	6841	`line = line.removeFirstSpace();`
6843	`line = line.removeEndSpace();`	6842	`line = line.removeEndSpace();`
Line 6852...	Line 6851...
6852	`if ( line.empty() )`	6851	`if ( line.empty() )`
6853	`break;`	6852	`break;`
6854		6853
6855	`if ( !insection && !insubsection )`	6854	`if ( !insection && !insubsection )`
6856	`{`	6855	`{`
6857	`Utils::String section = line.token(";", 1);`	6856	`Utils::WString section = line.token(L";", 1);`
6858	`insection = line.token(";", 2).toInt();`	6857	`insection = line.token(L";", 2).toInt();`
6859		6858
6860	`// search for the sections`	6859	`// search for the sections`
6861	`currentSection = NULL;`	6860	`currentSection = NULL;`
6862	`for ( CListNode<SComponantEntry> *node = dummyList.Front(); node; node = node->next() )`	6861	`for ( CListNode<SComponantEntry> *node = dummyList.Front(); node; node = node->next() )`
6863	`{`	6862	`{`
Line 6875...	Line 6874...
6875	`currentSection->sSection = section;`	6874	`currentSection->sSection = section;`
6876	`dummyList.push_back(currentSection);`	6875	`dummyList.push_back(currentSection);`
6877	`}`	6876	`}`
6878		6877
6879	`// we have some more ?`	6878	`// we have some more ?`
6880	`line = line.remTokens(";", 1, 2);`	6879	`line = line.remTokens(L";", 1, 2);`
6881	`}`	6880	`}`
6882	`else if ( !insubsection )`	6881	`else if ( !insubsection )`
6883	`{`	6882	`{`
6884	`--insection;`	6883	`--insection;`
6885	`Utils::String section = line.token(";", 1);`	6884	`Utils::WString section = line.token(L";", 1);`
6886	`insubsection = line.token(";", 2).toInt();`	6885	`insubsection = line.token(L";", 2).toInt();`
6887		6886
6888	`currentSubSection = new SComponantEntry2;`	6887	`currentSubSection = new SComponantEntry2;`
6889	`currentSubSection->sSection = section;`	6888	`currentSubSection->sSection = section;`
6890	`currentSection->lEntries.push_back(currentSubSection);`	6889	`currentSection->lEntries.push_back(currentSubSection);`
6891		6890
6892	`line = line.remTokens(";", 1, 2);`	6891	`line = line.remTokens(L";", 1, 2);`
6893	`}`	6892	`}`
6894	`else`	6893	`else`
6895	`{`	6894	`{`
6896	`--insubsection;`	6895	`--insubsection;`
6897	`line = line.remove(' ');`	6896	`line = line.remove(' ');`
6898	`if(!currentSubSection->lEntries.contains(line))`	6897	`if(!currentSubSection->lEntries.contains(line))`
6899	`currentSubSection->lEntries.pushBack(line);`	6898	`currentSubSection->lEntries.pushBack(line);`
6900	`line = "";`	6899	`line = L"";`
6901	`}`	6900	`}`
6902	`}`	6901	`}`
6903	`}`	6902	`}`
6904		-
6905	`delete lines;`	-
6906	`}`	6903	`}`
6907		6904
6908	`File.remove();`	6905	`File.remove();`
6909	`}`	6906	`}`
6910		6907
Line 6929...	Line 6926...
6929	`{`	6926	`{`
6930	`if ( eNode->Data()->sSection.Compare(dummy->sSection) )`	6927	`if ( eNode->Data()->sSection.Compare(dummy->sSection) )`
6931	`{`	6928	`{`
6932	`found = eNode->Data();`	6929	`found = eNode->Data();`
6933	`break;`	6930	`break;`
6934	`}`	6931	`}`
6935	`}`	6932	`}`
6936	`if ( !found )`	6933	`if ( !found )`
6937	`{`	6934	`{`
6938	`found = new SComponantEntry;`	6935	`found = new SComponantEntry;`
6939	`found->sSection = dummy->sSection;`	6936	`found->sSection = dummy->sSection;`
6940	`dummyList.push_back(found);`	6937	`dummyList.push_back(found);`
Line 6973...	Line 6970...
6973	`}`	6970	`}`
6974		6971
6975	`if ( f )`	6972	`if ( f )`
6976	`continue;`	6973	`continue;`
6977	`}`	6974	`}`
6978	`}`	6975	`}`
6979		6976
6980	`found2->lEntries.pushBack(dummy->sData.remove(' '));`	6977	`found2->lEntries.pushBack(dummy->sData.remove(' '));`
6981	`}`	6978	`}`
6982	`}`	6979	`}`
6983		6980
6984	`// finally, write the file`	6981	`// finally, write the file`
6985	`std::vector<Utils::String> lines;`	6982	`std::vector<Utils::WString> lines;`
6986	`lines.push_back("// Components file, created by SPK Libraries V" + Utils::String::FromFloat(GetLibraryVersion(), 2));`	6983	`lines.push_back(L"// Components file, created by SPK Libraries V" + Utils::WString::FromFloat(GetLibraryVersion(), 2));`
6987	`for ( SComponantEntry *dummy = dummyList.First(); dummy; dummy = dummyList.Next() )`	6984	`for ( SComponantEntry *dummy = dummyList.First(); dummy; dummy = dummyList.Next() )`
6988	`{`	6985	`{`
6989	`lines.push_back("");`	6986	`lines.push_back(L"");`
6990	`lines.push_back("// Section: " + dummy->sSection + " Entries: " + Utils::String::Number((long)dummy->lEntries.size()));`	6987	`lines.push_back(L"// Section: " + dummy->sSection + L" Entries: " + Utils::WString::Number((long)dummy->lEntries.size()));`
6991	`lines.push_back(dummy->sSection + ";" + Utils::String::Number(dummy->lEntries.size()) + ";");`	6988	`lines.push_back(dummy->sSection + L";" + Utils::WString::Number(dummy->lEntries.size()) + L";");`
6992	`for ( CListNode<SComponantEntry2> *comp = dummy->lEntries.Front(); comp; comp = comp->next() )`	6989	`for ( CListNode<SComponantEntry2> *comp = dummy->lEntries.Front(); comp; comp = comp->next() )`
6993	`{`	6990	`{`
6994	`lines.push_back(comp->Data()->sSection + ";" + Utils::String::Number((long)comp->Data()->lEntries.size()) + ";");`	6991	`lines.push_back(comp->Data()->sSection + L";" + Utils::WString::Number((long)comp->Data()->lEntries.size()) + L";");`
6995	`for(auto itr = comp->Data()->lEntries.begin(); itr != comp->Data()->lEntries.end(); itr++)`	6992	`for(auto itr = comp->Data()->lEntries.begin(); itr != comp->Data()->lEntries.end(); itr++)`
6996	`{`	6993	`{`
6997	`Utils::String cStr = (*itr)->str;`	6994	`Utils::WString cStr = (*itr)->str;`
6998	`cStr.removeEndSpace();`	6995	`cStr.removeEndSpace();`
6999	`cStr.removeChar(9);`	6996	`cStr.removeChar(9);`
7000	`cStr.removeChar('\r');`	6997	`cStr.removeChar('\r');`
7001	`if ( cStr.right(1) != ";" )`	6998	`if ( cStr.right(1) != L";" )`
7002	`cStr += ";";`	6999	`cStr += L";";`
7003	`lines.push_back(cStr);`	7000	`lines.push_back(cStr);`
7004	`}`	7001	`}`
7005	`}`	7002	`}`
7006	`}`	7003	`}`
7007		7004
7008	`// write the file to disk`	7005	`// write the file to disk`
7009	`CFileIO WriteFile(m_sTempDir + L"/Components.txt");`	7006	`CFileIO WriteFile(m_sTempDir + L"/Components.txt");`
7010	`if ( WriteFile.writeFile(&lines) )`	7007	`if ( WriteFile.writeFile(lines) )`
7011	`{`	7008	`{`
7012	`this->packFile(&WriteFile, L"types\\Components.pck");`	7009	`this->packFile(&WriteFile, L"types\\Components.pck");`
7013	`WriteFile.remove();`	7010	`WriteFile.remove();`
7014	`}`	7011	`}`
7015	`}`	7012	`}`
Line 7028...	Line 7025...
7028		7025
7029	`return true;`	7026	`return true;`
7030	`}`	7027	`}`
7031		7028
7032	`bool CPackages::readCommands(int iLang, CLinkList<SCommandSlot> &list)`	7029	`bool CPackages::readCommands(int iLang, CLinkList<SCommandSlot> &list)`
7033	`{`	7030	`{`
7034	`if ( iLang == 0 ) iLang = m_iLanguage;`	7031	`if ( iLang == 0 ) iLang = m_iLanguage;`
7035		7032
7036	`for(CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next()) {`	7033	`for(CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next()) {`
7037	`if ( !node->Data()->IsEnabled() ) continue;`	7034	`if ( !node->Data()->IsEnabled() ) continue;`
7038	`node->Data()->readCommands(iLang, list);`	7035	`node->Data()->readCommands(iLang, list);`

Subversion Repositories spk

(root)/libspk/src/Packages.cpp – Rev 215 → 216