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

 #include <time.h>
 #include <vector>
 #include "OriginalFiles.h"
 #include "spkdef.h"
+#include <set>
 #ifdef _RAR
 #include <unrar.h>
 #endif
 		for ( CListNode<CBaseFile> *pNode = m_lPackages.Front(); pNode; pNode = pNode->next() ) {
 			pNode->Data()->SetModifiedEnabled(pNode->Data()->IsEnabled());
+		}
+	}
 	m_bVanilla = b;
+}
+void CPackages::setMod(const Utils::String &mod)
+{
+	if (mod != "PluginManager")
+		m_sSetMod = mod;
+}
 void CPackages::setSaveGameManager(bool managed)
+{
 	m_iSaveGameManager = managed ? 1 : 0;
+		{
 			int id = 1;
 			while (dir.exists(Utils::String::PadNumber(id, 4)))
 				++id;
 			Utils::String d = Utils::String::PadNumber(id, 4);
-			dir.Create(d);
+			dir.create(d);
 			_sSaveDir = d;
 			CDirIO destDir1(dir.dir(d));
-			destDir1.Create("Vanilla");
+			destDir1.create("Vanilla");
 			destDir1.cd("Vanilla");
 			CDirIO destDir2(dir.dir(d));
-			destDir2.Create("Modified");
+			destDir2.create("Modified");
 			destDir2.cd("Modified");
 			Utils::CStringList files;
 			if (dir.dirList(files, Utils::String::Null(), "*.sav"))
+			{
 	m_lAvailablePackages.MemoryClear();
 	m_lInstallList.MemoryClear();
 	m_lEnableList.MemoryClear();
 	m_lDisableList.MemoryClear();
-	m_lCreatedFiles.Clear();
+	m_lCreatedFiles.clear();
-	m_lNonRemovedFiles.Clear();
+	m_lNonRemovedFiles.clear();
-	m_lGlobals.Clear();
+	m_lGlobals.clear();
-	m_lFakePatchOrder.Clear();
+	m_lFakePatchOrder.clear();
 	if (_pCurrentDir)
 		delete _pCurrentDir;
 	_pCurrentDir = NULL;
+}
 			m_pGameVFS.LoadFilesystem(m_sCurrentDir, 0);
+	}
 	else
 		m_pGameVFS.LoadFilesystem(m_sCurrentDir, 0);
+}
 bool CPackages::isOldDir(const Utils::String &dir)
+{
 	bool oldPlugin = false;
 	CFileIO datFile(dir + "/PluginManager/pluginmanager.dat");
 			for ( int i = 0; i < (int)readFile->size(); i++ )
+			{
 				Utils::String line(readFile->at(i));
 				Utils::String cmd = line.token(":", 1);
 				if ( cmd.Compare("<script>") || cmd.Compare("</scripts>") )
 					break;
 				else if ( cmd.Compare("spkinstaller") || cmd.Compare("globalfiles") )
 					break;
 				else if ( cmd.Compare("pluginmanager") )
+				{
 					oldPlugin = true;
 					break;
+				}
+{
 	m_sCurrentDir = dir;
 	m_sCurrentDir = m_sCurrentDir.findReplace("\\", "/");
 	this->setCurrentDir(dir);
 	m_bOldPlugin = false;
-	m_lCreatedFiles.Clear();
+	m_lCreatedFiles.clear();
 	m_bRemoveDir = false;
 	m_bSurpressProtectedWarning = false;
 	m_iSaveGame = -1;
 	m_iSaveGameManager = -1;
-	m_lNonRemovedFiles.Clear();
+	m_lNonRemovedFiles.clear();
-	m_lGlobals.Clear();
+	m_lGlobals.clear();
-	m_lFakePatchOrder.Clear();
+	m_lFakePatchOrder.clear();
 	if ( _pOriginalFiles ) delete _pOriginalFiles;
 	_pOriginalFiles = new COriginalFiles(m_sCurrentDir);
 	m_bVanilla = true;
 						else
 							m_iWareBuffer[i] = rest.token(" ", i + 1).toLong();
+					}
+				}
 				else if ( cmd == "createdfile" )
-					m_lCreatedFiles.PushBack(CyString(rest));
+					m_lCreatedFiles.pushBack(rest);
 				else if ( cmd == "wares" )
+				{
 					iWare = rest.token(" ", 1).toLong();
 					iCount = rest.token(" ", 2).toLong();
+				}
 				else if ( cmd == "betaversion" )
 					fBeta = rest.toFloat();
 				else if ( cmd == "uninstall" )
+				{
 					C_File *uf = new C_File();
-					uf->SetFileType(FILETYPE_SCRIPT);
+					uf->setFileType(FILETYPE_SCRIPT);
 					uf->SetCreationTime(rest.token(" ", 1).toLong());
 					uf->SetFilename(m_sCurrentDir + "/Scripts/" + rest.tokens(" ", 2));
 					m_lUninstallFiles.push_back(uf);
+				}
 				else if ( cmd == "nonremovedfile" )
+				{
 					if ( !CFileIO::Remove(rest) )
-						m_lNonRemovedFiles.PushBack(CyString(rest));
+						m_lNonRemovedFiles.pushBack(rest);
+				}
 				else if ( cmd == "original" )
 					_pOriginalFiles->parse(rest);
 				else if ( cmd.Compare("GlobalSetting") )
-					m_lGlobals.PushBack(CyString(rest.token(":", 1)), CyString(rest.tokens(":", 2)));
+					m_lGlobals.pushBack(rest.token(":", 1), rest.tokens(":", 2));
 				else if ( cmd.Compare("FakePatchOrder") )
-					m_lFakePatchOrder.PushBack(CyString(rest.token(":", 1)), CyString(rest.tokens(":", 2)));
+					m_lFakePatchOrder.pushBack(rest.token(":", 1), rest.tokens(":", 2));
 				else if ( cmd.Compare("EMPPriceOverride") )
 					this->addEMPPriceOverride(rest.token(" ", 1).toLong(), rest.token(" ", 2).toLong());
 				else if ( cmd.Compare("EMPNotoOverride") )
 					this->addEMPNotoOverride(rest.token(" ", 1).toLong(), rest.token(" ", 2).toLong());
 				else if ( cmd.Compare("BuiltInWarePriceOverride") )
 			for ( CListNode<SWares> *wNode = p->GetWaresList()->Front(); wNode; wNode = wNode->next() )
+			{
 				SWares *w = wNode->Data();
 				for ( CListNode<SGameWare> *gNode = m_lGameWares[CPackages::ConvertWareType(w->cType)].Front(); gNode; gNode = gNode->next() )
+				{
-					if ( w->sID == gNode->Data()->sWareName.ToString() )
+					if ( w->sID == gNode->Data()->sWareName )
+					{
 						gNode->Data()->pWare = w;
 						break;
+					}
+				}
 		else if ( node->Data()->GetType() == TYPE_XSP )
+		{
 			CXspFile *p = (CXspFile *)node->Data();
 			for ( CListNode<SGameShip> *gNode = m_lGameShips.Front(); gNode; gNode = gNode->next() )
+			{
-				if ( p->GetShipID().Compare(gNode->Data()->sShipID.ToString()) )
+				if ( p->GetShipID().Compare(gNode->Data()->sShipID) )
+				{
 					gNode->Data()->pPackage = p;
 					break;
 				}
+			}
+		}
+	}
 	// check the purged time
 	return true;
+}
 void CPackages::RemoveCreatedFiles()
+{
-	for ( SStringList *node = m_lCreatedFiles.Head(); node; node = node->;next )
+	for(auto itr = m_lCreatedFiles.begin(); itr != m_lCreatedFiles.end(); itr++)
+	{
-		if ( CFileIO(node->str).ExistsOld() )
+		if ( CFileIO::Exists((*itr)->str) )
-			CFileIO::Remove(node->str.ToString());
+			CFileIO::Remove((*itr)->str);
-		else if ( CFileIO(m_sCurrentDir + "/" + node->str.ToString()).ExistsOld() )
+		else if ( CFileIO::Exists(m_sCurrentDir + "/" + (*itr)->str) )
-			CFileIO::Remove(m_sCurrentDir + "/" + node->str.ToString());
+			CFileIO::Remove(m_sCurrentDir + "/" + (*itr)->str);
+	}
-	m_lCreatedFiles.Clear();
+	m_lCreatedFiles.clear();
+}
 void CPackages::PurgeGameObjects()
+{
 	// check for the log file
 	Utils::String logDir = logDirectory();
 	CFileIO LogFile(logDir + "/log0" + Utils::String::PadNumber(PMTEXTFILE, 4) + ".txt");
 	if ( LogFile.exists() )
+	{
 		// read the log file to memory
-		std::vector<CyString> *lines = LogFile.ReadLines();
+		std::vector<Utils::String> *lines = LogFile.readLines();
 		if ( lines )
+		{
 			for ( int i = 0; i < (int)lines->size(); i++ )
+			{
-				CyString line(lines->at(i));
+				Utils::String line(lines->at(i));
-				CyString start = line.GetToken(":", 1, 1).ToLower();
+				Utils::String start = line.token(":", 1).toLower();
-				CyString rest = line.GetToken(":", 2, 2).RemoveFirstSpace();
+				Utils::String rest = line.token(":", 2).removeFirstSpace();
 				if ( start.Compare("purged") )
+				{
-					long time = rest.ToLong();
+					long time = rest.toLong();
 					if ( time == m_iLastUpdated )
+					{
 						this->PurgeWares();
 						this->PurgeShips();
 						this->RemoveUninstallScripts();
+		{
 			if ( !f->GetDir().Compare("director") )
 				continue;
 			if ( f->CheckFileExt("xml") || f->CheckFileExt("pck") )
+			{
-				f->SetDir("");
+				f->setDir("");
-				f->SetFileType(FILETYPE_MISSION);
+				f->setFileType(FILETYPE_MISSION);
+			}
+		}
+	}
+}
 	return check;
+}
 CMultiSpkFile *CPackages::OpenMultiPackage(CyString file, int *error, CProgressInfo *progress)
 {
 	int check = CheckOpenPackage(file, error);
 	if ( *error == -1 )
 		return false;
 	if ( check != SPKFILE_MULTI )
 	{
 		*error = INSTALLERR_NOMULTI;
 		return false;
+	}
 	*error = INSTALLERR_NONE;
 	CMultiSpkFile *package = new CMultiSpkFile;
 		case SPKFILE_MULTI:
 			*error = INSTALLERR_NOMULTI;
 			return NULL;
 		case SPKFILE_SINGLESHIP:
 			installFile = new CXspFile();
-			if ( !((CXspFile *)installFile)->ReadFile(file, readtype, progress) )
+			if ( !((CXspFile *)installFile)->readFile(file.ToString(), readtype, progress))
+			{
 				delete installFile;
 				return NULL;
+			}
 			break;
 	_pOriginalFiles->installed(package);
 	// if we're installing an addon, lets use the fake patch method for object files
 	if ( m_iGameFlags & EXEFLAG_ADDON ) this->_addToFakePatch(package);
-	bool shuffle = false;
+	bool shuffle = package->anyFakePatchOrder();
 	// merge the update into the old package
 	bool dontAdd = false;
 	if ( package->GetType() == TYPE_SPK )
+	{
 			delete package;
 			package = oldPackage;
 			oldPackage = false;
 			dontAdd = true;
-			CDirIO(m_sCurrentDir).RemoveDir("temp");
+			CDirIO(m_sCurrentDir).removeDir("temp");
-			CDirIO(m_sCurrentDir).RemoveDir("Mods/temp");
+			CDirIO(m_sCurrentDir).removeDir("Mods/temp");
+		}
+	}
 	// if theres an icon, write it
 	if ( package->GetIcon() )
+		{
 			CDirIO Dir(m_sCurrentDir);
 			bool ready = true;
 			if ( !Dir.exists("PluginManager") )
+			{
-				if ( !Dir.Create("PluginManager") )
+				if ( !Dir.create("PluginManager") )
 					ready = false;
+			}
 			if ( ready && !Dir.exists("PluginManager/Icons") )
+			{
-				if ( !Dir.Create("PluginManager/Icons") )
+				if ( !Dir.create("PluginManager/Icons") )
 					ready = false;
+			}
 			if ( ready )
+			{
 		while ( fnode )
+		{
 			C_File *f = fnode->Data();
 			// no longer used
-			if ( !f->GetUsed() )
+			if ( !f->getUsed() )
+			{
 				// remove from file list
 				m_lFiles.remove(f, false);
 				// if its a readme file, then check if its in the new package
 			continue;
+		}
 		// only delete files that are not used
 		// if its a shared file, we skip it
-		if ( f->GetUsed() || f->IsShared() )
+		if ( f->getUsed() || f->IsShared() )
 			continue;
 		if ( f->GetFileType() == FILETYPE_README )
 			readme = true;
 		else if ( f->GetFileType() == FILETYPE_UNINSTALL || f->GetFileType() == FILETYPE_MAP || f->GetFileType() == FILETYPE_SOUND || f->GetFileType() == FILETYPE_EXTRA || f->GetFileType() == FILETYPE_SHIPSCENE || f->GetFileType() == FILETYPE_COCKPITSCENE || f->GetFileType() == FILETYPE_SHIPOTHER || f->GetFileType() == FILETYPE_SHIPMODEL || f->GetFileType() == FILETYPE_ADVERT )
 		if ( RemoveFile(f, errors) )
+		{
 			original = _pOriginalFiles->restoreFile(f, errors);
+		}
 		else // problem removeing (try when the program closes)
-			m_lNonRemovedFiles.PushBack(f->GetFilePointer());
+			m_lNonRemovedFiles.pushBack(f->filePointer());
 		// check for fake patchs
 		if ( f->IsFakePatch() )
 			shuffle = true;
 		else if ( f->isAutoTextFile() )
 		// make sure the scripts directory is created, even thou it should always be there anyways
 		CDirIO scriptDir(m_sCurrentDir);
 		if ( !scriptDir.exists("scripts") )
+		{
-			if ( scriptDir.Create("Scripts") )
+			if ( scriptDir.create("Scripts") )
 				this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY, "Scripts", errors);
 			else
 				this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, "Scripts", errors);
+		}
 		for ( C_File *uf = uninstallFiles.First(); uf; uf = uninstallFiles.Next() )
+		{
 			C_File *newFile = new C_File();
-			newFile->SetFileType(FILETYPE_SCRIPT);
+			newFile->setFileType(FILETYPE_SCRIPT);
 			newFile->setFilename(uf->filename());
 			newFile->SetCreationTime(uf->GetCreationTime());
 			// other installed packages use this file as well, copy it
 			Utils::String newFilename = m_sCurrentDir + "/" + newFile->getNameDirectory(NULL);
 			CFileIO file(uf->filePointer());
-			if ( uf->GetUsed() )
+			if ( uf->getUsed() )
+			{
 				if ( file.copy(newFilename) )
 					this->AddLogEntry(SPKINSTALL_UNINSTALL_COPY, newFile->getNameDirectory(NULL), errors);
 				else
+				{
+{
 	if ( m_sCurrentDir.empty() )
 		return true;
 	if ( !m_bLoaded )
 		return true;
+	Utils::CStringList lErrors;
 	CLog::log(CLog::Log_Directory, 1, "closing directory: " + m_sCurrentDir);
 	if ( m_bRenameText ) {
 		CLog::log(CLog::Log_Directory, 2, "Creating other language files for game");
-		CreateLanguageTextFiles(errors);
+		CreateLanguageTextFiles(&lErrors);
+	}
 	CLog::log(CLog::Log_Directory, 2, "Backing up save game files");
-	if ( CFileIO(m_sCurrentDir + "/mods/PluginManager.dat").ExistsOld() ) {
+	if ( CFileIO::Exists(m_sCurrentDir + "/mods/PluginManager.dat") ) {
 		CLog::log(CLog::Log_IO, 3, "Removing old PluginManager.dat file");
 		CFileIO::Remove(m_sCurrentDir + "/mods/PluginManager.dat");
+	}
-	if ( CFileIO(m_sCurrentDir + "/mods/PluginManager.cat").ExistsOld() ) {
+	if ( CFileIO::Exists(m_sCurrentDir + "/mods/PluginManager.cat") ) {
 		CLog::log(CLog::Log_IO, 3, "Removing old PluginManager.cat file");
 		CFileIO::Remove(m_sCurrentDir + "/mods/PluginManager.cat");
+	}
 	if ( !m_bVanilla )
 				while ( fCat && !fCat->IsFakePatch() && !fCat->CheckFileExt("cat") && !fCat->GetBaseName().Compare(fDat->GetBaseName()) )
 					fCat = m_pEnabledMod->GetNextFile(fCat);
 				if ( fCat )
+				{
-					CFileIO(fDat->GetFilePointer()).copy(m_sCurrentDir + "/mods/PluginManager.dat");
+					CFileIO(fDat->filePointer()).copy(m_sCurrentDir + "/mods/PluginManager.dat");
-					CFileIO(fCat->GetFilePointer()).copy(m_sCurrentDir + "/mods/PluginManager.cat");
+					CFileIO(fCat->filePointer()).copy(m_sCurrentDir + "/mods/PluginManager.cat");
+				}
+			}
+		}
-		else if ( m_iGame == GAME_X3 && !m_sSetMod.Empty() && CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod.ToString() + ".cat").ExistsOld() && CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod.ToString() + ".dat").ExistsOld())
+		else if ( m_iGame == GAME_X3 && !m_sSetMod.empty() && CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod + ".cat").ExistsOld() && CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod + ".dat").ExistsOld())
+		{
-			CLog::log(CLog::Log_Directory, 2, "Copying mod file: " + m_sSetMod.ToString() + ", to PluginManager.cat");
+			CLog::log(CLog::Log_Directory, 2, "Copying mod file: " + m_sSetMod + ", to PluginManager.cat");
-			CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod.ToString() + ".dat").copy(m_sCurrentDir + "/mods/PluginManager.dat");
+			CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod + ".dat").copy(m_sCurrentDir + "/mods/PluginManager.dat");
-			CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod.ToString() + ".cat").copy(m_sCurrentDir + "/mods/PluginManager.cat");
+			CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod + ".cat").copy(m_sCurrentDir + "/mods/PluginManager.cat");
+		}
 		if ( !CDirIO(m_sCurrentDir).exists("mods") )
-			CDirIO(m_sCurrentDir).Create("mods");
+			CDirIO(m_sCurrentDir).create("mods");
 		SetupWares();
 		SetupShips();
 		CreateEMPFile();
 		CreateWareFiles();
 	WriteData();
 	if ( removedir && m_bRemoveDir )
+	{
 		m_bRemoveDir = false;
-		CyStringList removeDirs;
+		Utils::CStringList removeDirs;
-		removeDirs.PushBack(".");
+		removeDirs.pushBack(".");
-		RemoveUnusedDirectories(removeDirs, errors);
+		removeUnusedDirectories(removeDirs, &lErrors);
+	}
 	this->setCurrentDir("");
+	//TEMP: switch to errors
+	if (errors)
+	{
+		for (auto itr = lErrors.begin(); itr != lErrors.end(); itr++)
+			errors->PushBack(CyString((*itr)->str), CyString((*itr)->data));
+	}
 	m_bLoaded = false;
 	return true;
 }
 CyString CPackages::GetModKey()
+{
 	return m_gameExe.GetModKey(m_iGame - 1);
 }
-CyString CPackages::GetSelectedModName()
+Utils::String CPackages::selectedModName() const
 {
 	if ( !m_pEnabledMod )
+	{
-		if ( m_sSetMod.Empty() && m_iGame == GAME_X3 )
+		if ( m_sSetMod.empty() && m_iGame == GAME_X3 )
 			return "PluginManager";
 		return m_sSetMod;
+	}
 	if ( !m_pEnabledMod->IsEnabled() )
 		return m_sSetMod;
 	C_File *f = m_pEnabledMod->GetFirstFile(FILETYPE_MOD);
 	if ( !f )
 		return m_sSetMod;
-	CyString name = f->filename();
+	Utils::String name = f->filename();
-	name = name.Left(-4);
+	name = name.left(-4);
 	return name;
+}
 bool CPackages::RestoreFakePatch()
+{
 	CLog::log(CLog::Log_Directory, 1, "Restoring PluginManager fake patch into game");
  	m_iFakePatch = -1;
 	CFileIO catFile(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat");
 	CFileIO datFile(m_sCurrentDir + "/PluginManager/PlugMan_Fake.dat");
 	// if only 1 exists, remove it
 	if ( catFile.exists() && !datFile.exists() ) {
 		if ( !file.Empty() )
 			file += "/";
 		file += "pluginmanagerfake.txt";
 		file = file.FindReplace("\\", "/");
 		CFileIO fakeFile(file);
-		std::vector<CyString> lines;
+		std::vector<Utils::String> lines;
 		lines.push_back("//pluginmanager fake patch");
 		CLog::log(CLog::Log_Directory, 3, "Writing pluginmanagerfake.txt file to add to Fake Patch");
-		if ( !fakeFile.WriteFile(&lines) ) {
+		if ( !fakeFile.writeFile(&lines) ) {
 			CLog::log(CLog::Log_Directory, 3, "Writing pluginmanagerfake.txt failed!!");
 		}
 		else {
 /*
 			CLog::log(CLog::Log_Directory, 2, "Adding TFake.pck file into FakePatch");
 			CCatFile fakePatch;
 			if ( fakePatch.Open(m_sCurrentDir + "/PluginManager/PlugMan_Fake.cat", this->GetAddonDir(), CATREAD_DAT, false) == CATERR_NONE )
+			{
 		// backup existing mod files incase something happens to them
 		if ( !datFile.exists() || !catFile.exists() ) {
 			CLog::log(CLog::Log_Directory, 2, Utils::String("ERROR: ") + (!catFile.exists() ? "cat" : "dat") + " file appears to be missing");
+		}
 		else {
-			catFile.GetDirIO().Create("Backup");
+			catFile.GetDirIO().create("Backup");
 			catFile.copy(catFile.dir() + "/Backup/" + catFile.filename());
 			datFile.copy(datFile.dir() + "/Backup/" + datFile.filename());
 		}
 		// find next available fake patch
 		m_iFakePatch = this->FindNextFakePatch();
 		CLog::log(CLog::Log_Directory, 2, "Finding next available fake patch number: " + (long)m_iFakePatch);
 		Utils::String filename = Utils::String::PadNumber(m_iFakePatch, 2);
 	if ( m_sCurrentDir.empty() )
 		return;
 	CLog::log(CLog::Log_Directory, 1, "Writing data file for current directory: " + m_sCurrentDir);
-	CyStringList lines;
+	Utils::CStringList lines;
-	CyString version;
-	version.FromFloat(GetLibraryVersion(), 2);
+	Utils::String version = "SpkInstaller: " + Utils::String::FromFloat(GetLibraryVersion(), 2);
-	version.Prepend("SpkInstaller: ");
-	lines.PushBack(version);
+	lines.pushBack(version);
-	lines.PushBack(CyString("UpdateTime: ") + (long)m_iLastUpdated);
+	lines.pushBack(Utils::String("UpdateTime: ") + (long)m_iLastUpdated);
 	if ( m_iFakePatch != -1 )
-		lines.PushBack(CyString("FakePatch: ") + (long)m_iFakePatch);
+		lines.pushBack(Utils::String("FakePatch: ") + (long)m_iFakePatch);
 	if ( m_iSaveGame != -1 )
-		lines.PushBack(CyString("SaveGame: ") + (long)m_iSaveGame);
+		lines.pushBack(Utils::String("SaveGame: ") + (long)m_iSaveGame);
-	lines.PushBack(CyString("SaveGameManager: ") + (long)m_iSaveGameManager);
+	lines.pushBack(Utils::String("SaveGameManager: ") + (long)m_iSaveGameManager);
 	if ( !m_bVanilla )
-		lines.PushBack("Modified");
+		lines.pushBack("Modified");
 	if ( m_bUsedWare )
-		lines.PushBack("UsedWare");
+		lines.pushBack("UsedWare");
 	if ( m_bSurpressProtectedWarning )
-		lines.PushBack("SurpressProtectedWarning");
+		lines.pushBack("SurpressProtectedWarning");
-	if ( !m_sSetMod.Empty() )
+	if ( !m_sSetMod.empty() )
-		lines.PushBack(CyString("SetMod: ") + m_sSetMod);
+		lines.pushBack("SetMod: " + m_sSetMod);
 	if (!_sSaveDir.empty())
-		lines.PushBack(CyString("SaveDir: ") + _sSaveDir);
+		lines.pushBack("SaveDir: " + _sSaveDir);
-	lines.PushBack(CyString("ShipBuffer: ") + (long)m_iShipBuffer);
+	lines.pushBack(Utils::String("ShipBuffer: ") + (long)m_iShipBuffer);
-	CyString wareBuffer = "WareBuffers:";
+	Utils::String wareBuffer = "WareBuffers:";
 	for ( int i = 0; i < WAREBUFFERS; i++ )
-		wareBuffer += CyString(" ") + (long)m_iWareBuffer[i];
+		wareBuffer += Utils::String(" ") + (long)m_iWareBuffer[i];
-	lines.PushBack(wareBuffer);
+	lines.pushBack(wareBuffer);
 	for ( int i = 0; i < WAREBUFFERS; i++ )
+	{
 		if ( !m_lGameWares[i].size() )
 			continue;
-		lines.PushBack(CyString("Wares: ") + (long)i + " " + (long)m_lGameWares[i].size());
+		lines.pushBack(Utils::String("Wares: ") + (long)i + " " + (long)m_lGameWares[i].size());
 		for ( CListNode<SGameWare> *node = m_lGameWares[i].Front(); node; node = node->next() )
+		{
 			SGameWare *gm = node->Data();
-			lines.PushBack(CyString((long)gm->iPos) + " " + (long)gm->iType + " " + CyString((char)gm->cType) + " " + gm->sWareName);
+			lines.pushBack(Utils::String((long)gm->iPos) + " " + (long)gm->iType + " " + Utils::String((char)gm->cType) + " " + gm->sWareName);
+		}
+	}
-	for ( SStringList *str = m_lNonRemovedFiles.Head(); str; str = str->;next )
+	for(auto itr = m_lNonRemovedFiles.begin(); itr != m_lNonRemovedFiles.end(); itr++)
-		lines.PushBack(CyString("NonRemovedFile: ") + str->str);
+		lines.pushBack("NonRemovedFile: " + (*itr)->str);
 	if ( m_lGameShips.size() )
+	{
-		lines.PushBack(CyString("Ships: ") + (long)m_lGameShips.size());
+		lines.pushBack(Utils::String("Ships: ") + (long)m_lGameShips.size());
 		for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
+		{
 			SGameShip *gm = node->Data();
-			lines.PushBack(CyString((long)gm->iType) + " $#C:" + gm->sShipClass + " " + gm->sShipID);
+			lines.pushBack(Utils::String((long)gm->iType) + " $#C:" + gm->sShipClass + " " + gm->sShipID);
+		}
+	}
 	// write created Files
-	if ( !m_lCreatedFiles.Empty() )
+	if ( !m_lCreatedFiles.empty() )
+	{
-		for ( SStringList *node = m_lCreatedFiles.Head(); node; node = node->;next )
+		for(auto itr = m_lCreatedFiles.begin(); itr != m_lCreatedFiles.end(); itr++)
-			lines.PushBack(CyString("CreatedFile: ") + node->str.Remove(m_sCurrentDir));
+			lines.pushBack("CreatedFile: " + (*itr)->str.findRemove(m_sCurrentDir));
+	}
 	// write uninstall files
 	if ( !m_lUninstallFiles.empty() )
+	{
 		for ( CListNode<C_File> *node = m_lUninstallFiles.Front(); node; node = node->next() )
+		{
 			C_File *uf = node->Data();
-			CyString uString = "Uninstall: ";
+			Utils::String uString = "Uninstall: ";
-			uString += CyString::Number((long)uf->GetCreationTime()) + " ";
+			uString += Utils::String::Number((long)uf->GetCreationTime()) + " ";
 			uString += uf->filename();
-			lines.PushBack(uString);
+			lines.pushBack(uString);
+		}
+	}
 	// write the original file data
-	_pOriginalFiles->writeData(&lines);
+	_pOriginalFiles->writeData(lines);
 	// write the global changes
-	if ( !m_lGlobals.Empty() )
+	if ( !m_lGlobals.empty() )
+	{
-		for ( SStringList *str = m_lGlobals.Head(); str; str = str->;next )
+		for(auto itr = m_lGlobals.begin(); itr != m_lGlobals.end(); itr++)
-			lines.PushBack(CyString("GlobalSetting: ") + str->str + ":" + str->data.Remove(";"));
+			lines.pushBack("GlobalSetting: " + (*itr)->str + ":" + (*itr)->data.findRemove(";"));
+	}
 	// write the fake patch ordering
-	if ( !m_lFakePatchOrder.Empty() )
+	if ( !m_lFakePatchOrder.empty() )
 	{
-		for ( SStringList *str = m_lFakePatchOrder.Head(); str; str = str->;next )
+		for(auto itr = m_lFakePatchOrder.begin(); itr != m_lFakePatchOrder.end(); itr++)
-			lines.PushBack(CyString("FakePatchOrder: ") + str->str + ":" + str->data);
+			lines.pushBack("FakePatchOrder: " + (*itr)->str + ":" + (*itr)->data);
 	}
 	for(CListNode<SWarePriceOverride> *node = m_lWarePrices.Front(); node; node = node->next()) {
 		SWarePriceOverride *ware = node->Data();
 		switch(ware->type) {
 			case Ware_EMP:
-				lines.PushBack(CyString(Utils::String(";EMPPriceOverride:") + (long)ware->pos + "; " + (long)ware->relval));
+				lines.pushBack(Utils::String(";EMPPriceOverride:") + (long)ware->pos + "; " + (long)ware->relval);
 				if ( ware->bNotority )
-					lines.PushBack(CyString(Utils::String(";EMPNotoOverride:") + (long)ware->pos + "; " + (long)ware->notority));
+					lines.pushBack(Utils::String(";EMPNotoOverride:") + (long)ware->pos + "; " + (long)ware->notority);
 				break;
 			case Ware_Custom:
-				lines.PushBack(CyString(Utils::String(";CustomWarePriceOverride:") + ware->id + &quot;;&quot; + (long)ware->relval));
+				lines.pushBack(Utils::String(";CustomWarePriceOverride:") + ware->id + &quot;;&quot; + (long)ware->relval);
 				if ( ware->bNotority )
-					lines.PushBack(CyString(Utils::String(";CustomWareNotoOverride:") + ware->id + &quot;;&quot; + (long)ware->notority));
+					lines.pushBack(Utils::String(";CustomWareNotoOverride:") + ware->id + &quot;;&quot; + (long)ware->notority);
 				break;
 			case Ware_BuiltIn:
-				lines.PushBack(CyString(Utils::String(";BuiltInWarePriceOverride:") + (long)ware->pos + "; " + (long)ware->relval));
+				lines.pushBack(Utils::String(";BuiltInWarePriceOverride:") + (long)ware->pos + "; " + (long)ware->relval);
 				if ( ware->bNotority )
-					lines.PushBack(CyString(Utils::String(";BuiltInWareNotoOverride:") + (long)ware->pos + "; " + (long)ware->notority));
+					lines.pushBack(Utils::String(";BuiltInWareNotoOverride:") + (long)ware->pos + "; " + (long)ware->notority);
 				break;
+		}
+	}
 	// write the global file list
-	lines.PushBack("GlobalFiles:");
+	lines.pushBack("GlobalFiles:");
 	int num = 0;
 	for ( CListNode<C_File> *fn = m_lFiles.Front(); fn; fn = fn->next() )
+	{
 		C_File *f = fn->Data();
 		f->SetPos(num++);
-		CyString line = CyString::Number(f-&gt;GetFileType()) + ":" + CyString::Number((long)f->GetCreationTime()) + ":" + f->GetDir() + ":";
+		Utils::String line = Utils::String::Number(f-&gt;GetFileType()) + ":" + Utils::String::Number((long)f->GetCreationTime()) + ":" + f->dir() + ":";
 		if ( f->IsShared() && !f->IsFakePatch() )
 			line += "1:";
 		else
 			line += "0:";
-		CyString filename = f->GetFilePointer();
+		Utils::String filename = f->filePointer().findRemove(m_sCurrentDir);
-		filename.Remove(m_sCurrentDir);
 		if ( f->IsDisabled() )
 			line += "D#";
 		line += "G#";
 		line += (long)f->GetGame();
 		line += "#";
 		line += filename;
-		if ( !f->GetOriginalName().Empty() )
+		if ( !f->originalName().empty() )
+		{
 			line += "O#";
-			line += f->GetOriginalName();
+			line += f->originalName();
+		}
-		lines.PushBack(line);
+		lines.pushBack(line);
+	}
 	// write the package list
 	for ( CListNode<CBaseFile> *pn = m_lPackages.Front(); pn; pn = pn->next() )
+	{
 		CBaseFile *package = pn->Data();
 		if ( package->GetType() == TYPE_SPK )
-			lines.PushBack("<script>");
+			lines.pushBack("<script>");
 		else if ( package->GetType() == TYPE_XSP )
-			lines.PushBack("<ship>");
+			lines.pushBack("<ship>");
 		else if ( package->GetType() == TYPE_ARCHIVE )
-			lines.PushBack("<archive>");
+			lines.pushBack("<archive>");
 		else if ( package->GetType() == TYPE_BASE )
-			lines.PushBack("<base>");
+			lines.pushBack("<base>");
 		else
 			continue;
 		if ( !package->filename().empty() )
-			lines.PushBack(CyString("Installspk: ") + package->filename());
+			lines.pushBack("Installspk: " + package->filename());
-		CyString valuesline = package->CreateValuesLine();
+		Utils::String valuesline = package->CreateValuesLine();
-		if ( valuesline.Right(1) == '\n' )
+		if ( valuesline.back() == '\n')
-			valuesline.Truncate((int)valuesline.Length() - 1);
+			valuesline.truncate((int)valuesline.length() - 1);
-		lines.PushBack(valuesline);
+		lines.pushBack(valuesline);
 		if ( !package->IsEnabled() )
-			lines.PushBack("Disabled");
+			lines.pushBack("Disabled");
 		if ( !package->IsModifiedEnabled() )
-			lines.PushBack("ModifiedDisabled");
+			lines.pushBack("ModifiedDisabled");
 		if ( package->GetIcon() )
-			lines.PushBack(CyString("Icon: ") + package->iconExt() + " " + package->GetIcon()->filePointer() );
+			lines.pushBack("Icon: " + package->iconExt() + " " + package->GetIcon()->filePointer() );
-		CyString fileline("Files:");
+		Utils::String fileline("Files:");
 		for ( CListNode<C_File> *fn = package->GetFileList()->Front(); fn; fn = fn->next() )
+		{
 			C_File *f = fn->Data();
 			fileline += " ";
-			fileline += CyString::Number(f->GetPos());
+			fileline += Utils::String::Number(f->GetPos());
+		}
-		lines.PushBack(fileline);
+		lines.pushBack(fileline);
+	}
-	lines.PushBack("</scripts>");
+	lines.pushBack("</scripts>");
 	CFileIO datFile(m_sCurrentDir + "/PluginManager/PluginManager.new");
 	CDirIO Dir(m_sCurrentDir);
 	if ( !Dir.exists("PluginManager") ) {
 		CLog::log(CLog::Log_IO, 2, "Creating PluginManager directory");
- 		Dir.Create("PluginManager");
+ 		Dir.create("PluginManager");
+	}
 	CLog::log(CLog::Log_IO, 2, "Writing data file: " + m_sCurrentDir + "/PluginManager/PluginManager.new");
-	if ( !datFile.WriteFile(&lines) )
+	if ( !datFile.writeFile(&lines) )
+	{
 		CLog::log(CLog::Log_IO, 1, "ERROR: Failed to write data file");
+	}
 	else {
 		CLog::log(CLog::Log_IO, 2, "Removing old data file: " + m_sCurrentDir + "/PluginManager/PluginManager.dat");
 /**
  * Add Log
+ *
  * Adds a log entry to displayed at end
  */
-void CPackages::AddLogEntry(int type, CyString args, CyStringList *errors)
+void CPackages::AddLogEntry(int type, CyString args, CyStringList* errors)
+{
-	if ( !errors )
+	if (!errors)
 		return;
 	errors->PushBack(args, ERRORLOG_OLD(type));
+}
+void CPackages::addLogEntry(int type, const Utils::String &args, Utils::CStringList *errors)
+{
+	if (!errors)
+		return;
+	errors->pushBack(args, ERRORLOG(type));
+}
 /**
  * Enable a package
+ *
 		// fake patches are in the root, no need for directory
 		if ( !f->IsFakePatch() )
+		{
 			if ( !Dir.exists(f->getDirectory(package)) )
+			{
-				if ( !Dir.Create(f->getDirectory(package)) )
+				if ( !Dir.create(f->getDirectory(package)) )
+				{
 					this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, f->GetDirectory(package), errors);
 					continue;
+				}
 				this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY, f->GetDirectory(package), errors);
 			progress->UpdateProgress(++fileCount, maxFiles);
 			progress->UpdateFile(f);
+		}
 		// only delete files that are not used by any other enabled packages, counter from UpdateUsedFiles()
-		if ( f->GetUsed() || (f->IsShared() && !m_bDisableVanilla) )
+		if ( f->getUsed() || (f->IsShared() && !m_bDisableVanilla) )
 			continue;
 		// file is already disabled, no need to disable again
 		if ( f->IsDisabled() )
 			continue;
 				continue;
+		}
 		if ( f->GetFileType() == FILETYPE_MOD && !f->IsFakePatch() && f->CheckFileExt("cat") )
+		{
-			if ( f->GetBaseName().Compare(m_sSetMod) )
+			if ( f->baseName().Compare(m_sSetMod) )
-				m_sSetMod = NullString;
+				m_sSetMod = Utils::String::Null();
+		}
 		// file is not being used by any enabled package
 		// set disabled and move to disabled directory
 		CDirIO Dir(m_sCurrentDir);
 		// make sure the directory exists so we can move the file
 		if ( !Dir.exists(newFilename) )
+		{
 			// we couldn't create the directory for some reason, this is not good
-			if ( !Dir.Create(newFilename) )
+			if ( !Dir.create(newFilename) )
+			{
 				this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, newFilename, errors);
 				continue;
+			}
 			this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY, newFilename, errors);
+ *
  * Finds a matching package so we can find if one is already installed
+ *
  * Uses seperate functions for each package type, ie for SPK and XSP packages
  */
-CBaseFile *CPackages::FindPackage(CBaseFile *package)
+CBaseFile* CPackages::FindPackage(CBaseFile* package)
+{
 	// no point checking if we've been sent a null pointer
 	if ( !package )
 		return 0;
 	// nothing found
 	return 0;
+}
-CBaseFile *CPackages::FindPackage(CyString name, CyString author)
+CBaseFile* CPackages::findPackage(const Utils::String &name, const Utils::String &author) const
+{
 	// interate through all packages
-	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
+	for (CListNode<CBaseFile>* node = m_lPackages.Front(); node; node = node->next())
+	{
-		CBaseFile *file = node->Data();
+		CBaseFile* file = node->Data();
 		// now compare the name and author, "Compare" is a non case senseative check, opposed to ==.
-		if ( file->name().Compare(name.ToString()) &amp;&amp; file->author().Compare(author.ToString()) )
+		if (file->name().Compare(name) &amp;&amp; file->author().Compare(author))
 			return file;
 	}
 	// nothing found
 	return 0;
+}
+CBaseFile* CPackages::FindPackage(CyString name, CyString author)
+{
+	return findPackage(name.ToString(), author.ToString());
 }
 /**
  * Find a XSP Package
+ *
  * This searching all installed packages for a XSP Package matching the object id
  */
 CBaseFile *CPackages::FindXspPackage(CyString id)
 			return file;
+	}
 	// nothing found
 	return 0;
 }
 /**
  * Update the used files count
+ *
  * counts how many packages are currently using the file
  */
 void CPackages::UpdateUsedFiles(CLinkList<CBaseFile> *ignoreList, bool includedisabled)
+{
 	// clear amounts for all files
 	CListNode<C_File> *fnode = m_lFiles.Front();
 	while ( fnode )
+	{
-		fnode->Data()->ClearUsed();
+		fnode->Data()->clearUsed();
 		fnode = fnode->next();
 	}
 	// update for all packages
 	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node= node->next() )
+	{
 		CBaseFile *file = node->Data();
 		if ( (ignoreList) && (ignoreList->FindData(file)) )
 			continue;
 		// now mark all files
 		CListNode<C_File> *fnode = file->GetFileList()->Front();
 		while ( fnode )
+		{
-			fnode->Data()->IncUsed();
+			fnode->Data()->incUsed();
 			fnode = fnode->next();
+		}
+	}
+}
 /**
  * Removes all empty directories that might have been created
  */
-void CPackages::RemoveUnusedDirectories(CyStringList &dirs, CyStringList *errors)
+void CPackages::RemoveUnusedDirectories(CyStringList& dirs, CyStringList* errors)
+{
 	CDirIO Dir(m_sCurrentDir);
-	for ( SStringList *str = dirs.Head(); str; str = str->next )
+	for (SStringList* str = dirs.Head(); str; str = str->next)
+	{
 		CyString dir = str->str;
 		CyStringList removedDir;
-		if ( Dir.RemoveDir(dir, false, true, &removedDir) || !removedDir.Empty() )
+		if (Dir.RemoveDir(dir, false, true, &removedDir) || !removedDir.Empty())
 		{
-			for ( SStringList *node = removedDir.Head(); node; node = node->next )
+			for (SStringList* node = removedDir.Head(); node; node = node->next)
 			{
 				CyString displayName = node->str;
 				displayName = displayName.Remove(m_sCurrentDir);
 				this->AddLogEntry(SPKINSTALL_REMOVEDIR, displayName, errors);
+			}
+		}
+	}
+}
+void CPackages::removeUnusedDirectories(const Utils::CStringList& dirs, Utils::CStringList* errors)
+{
+	CDirIO Dir(m_sCurrentDir);
+	for(auto itr = dirs.begin(); itr != dirs.end(); itr++)
+	{
+		Utils::String dir = (*itr)->str;
+		Utils::CStringList removedDir;
+		if (Dir.removeDir(dir, false, true, &removedDir) || !removedDir.empty())
+		{
+			for(auto rItr = removedDir.begin(); rItr != removedDir.end(); rItr++)
+			{
+				Utils::String displayName = (*rItr)->str;
+				displayName = displayName.findRemove(m_sCurrentDir);
+				this->addLogEntry(SPKINSTALL_REMOVEDIR, displayName, errors);
+			}
+		}
+	}
+}
 	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
+	{
 		CBaseFile *p = node->Data();
 		if ( p->GetType() != TYPE_SPK )
 			continue;
 		((CSpkFile *)p)->UpdateSigned(false);
+	}
+}
 /**
 						break;
+					}
+				}
 				if ( !found )
 					return false;
 			}
 		}
 	}
 	return true;
+}
 bool CPackages::CheckEnabledDependacy(CBaseFile *p)
+		}
+	}
 	// check any dependacies
 	if ( p->AnyDependacies() )
 	{
 		for ( CListNode<SNeededLibrary> *dNode = p->GetNeededLibraries()->Front(); dNode; dNode = dNode->next() )
+		{
 			if ( dNode->Data()->sName.Compare("<package>") )
 				continue;
 			if ( !this->CheckInstalledDependacy(dNode->Data()->sName, dNode->Data()->sAuthor, dNode->Data()->sMinVersion, true, true) )
+					{
 						CBaseFile *checkP = pNode->Data();
 						if ( p->author().Compare(checkP->author()) && p->name().Compare(checkP->name()) )
+						{
 							found = true;
 							break;
 						}
 					}
 				}
 				else
 					found = false;
+			}
 			if ( !found )
+			{
 				if ( list )
 					list->pushBack(spk->GetOtherName(), spk->GetOtherAuthor());
 				++count;
 			}
 		}
 	}
 	return count;
+}
 int CPackages::CheckPreparedInstallRequired(CLinkList<CBaseFile> *list)
+{
 	// loop through all packages
+	}
 	m_lInstallList.RemoveEmpty();
 	return count;
 }
 /**
  * Remove uninstall file
+ *
  * Removes a single uninstall file
  */
 bool CPackages::RemoveUninstallFile(C_File *file, CyStringList *errors)
 		for ( CListNode<C_File> *fNode = m_lFiles.Front(); fNode; fNode = fNode->next() )
+		{
 			C_File *checkFile = fNode->Data();
 			if ( checkFile->GetFileType() != FILETYPE_SCRIPT )
 				continue;
 			if ( checkFile->filename().Compare(file->filename()) )
+			{
 				found = true;
 				break;
+			}
 		// not found a matching file, we can safetly remove it
 		if ( !found )
+		{
 			if ( RemoveUninstallFile(file) )
 				node->DeleteData();
 		}
+	}
 	m_lUninstallFiles.RemoveEmpty();
 	return files;
 	for ( CListNode<C_File> *node = m_lFiles.Back(); node; node = node->prev() )
+	{
 		if ( progress )
 			progress->UpdateProgress(files, m_lFiles.size());
 		files++;
 		C_File *file = node->Data();
 		// only do marked shared files
 		if ( !file->IsShared() )
 			continue;
 		// only do ones that are no longer needed
-		if ( file->GetUsed() )
+		if ( file->getUsed() )
 			continue;
 		if ( RemoveSharedFile(file, errors) )
 			++done;
 		node->ChangeData(NULL);
+	{
 		C_File *file = node->Data();
 		// only do marked shared files
 		if ( !file->IsShared() )
 			continue;
 		// only do ones that are no longer needed
-		if ( file->GetUsed() )
+		if ( file->getUsed() )
 			continue;
 		return true;
 	}
 	return false;
 }
 void CPackages::ShuffleTextFiles(CyStringList *errors)
+{
 	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
+	{
 		C_File *f = node->Data();
 			continue;
 		// we need to rename it
 		int current = findNextTextFile();
 		if ( current < f->GetTextFileID() )
 		{
 			CFileIO moveFile(f->filePointer());
 			Utils::String newName = SPK::FormatTextName(current, m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT)) + "." + moveFile.extension();
 			if ( moveFile.Rename(m_sCurrentDir + "/t/" + newName) )
+			{
 	// lets make sure our order is correct
 	// find Lowest Fake Patch Installed
 	CLinkList<C_File> doneList;
 	int lowest = FindLowestFakePatchInstalled();
 	if ( check < lowest ) lowest = check; // gap at the beginning, lets use that
+	// find all packages that need to go before or after other packages
+	std::set<CBaseFile*> packagesBefore;
+	std::map<CBaseFile*, std::set<CBaseFile*>> packagesAfter;
+	for (CListNode<CBaseFile>* pNode = m_lPackages.Front(); pNode; pNode = pNode->next())
+	{
+		CBaseFile* p = pNode->Data();
+		// search for any fake patches in package
+		if (!p->IsEnabled()) continue;
+		if (!p->AnyFileType(FILETYPE_MOD)) continue;
+		if (p->AnyDependacies())
+		{
+			for (SNeededLibrary* nl = p->GetNeededLibraries()->First(); nl; nl = p->GetNeededLibraries()->Next())
+			{
+				auto package = FindPackage(nl->sName, nl->sAuthor);
+				if (package)
+				{
+					packagesBefore.insert(package);
+					packagesAfter[p].insert(package);
+				}
+			}
+		}
+		CSpkFile* spk = dynamic_cast<CSpkFile*>(p);
+		if (spk)
+		{
+			if (spk->IsAnotherMod())
+			{
+				auto package = FindPackage(spk->otherName(), spk->otherAuthor());
+				if (package)
+				{
+					packagesBefore.insert(package);
+					packagesAfter[p].insert(package);
+				}
+			}
+		}
+		if (!p->getFakePatchBeforeOrder().empty())
+		{
+			packagesBefore.insert(p);
+			auto& list = p->getFakePatchBeforeOrder();
+			for (auto itr = list.begin(); itr != list.end(); itr++)
+			{
+				auto package = FindPackage((*itr)->str, (*itr)->data);
+				if (package)
+					packagesAfter[package].insert(p);
+			}
+		}
+		if (!p->getFakePatchAfterOrder().empty())
+		{
+			auto& list = p->getFakePatchAfterOrder();
+			for (auto itr = list.begin(); itr != list.end(); itr++)
+			{
+				auto package = FindPackage((*itr)->str, (*itr)->data);
+				if (package)
+				{
+					packagesBefore.insert(package);
+					packagesAfter[p].insert(package);
+				}
+			}
+		}
+	}
+	auto addOrderedList = [](const std::vector<CBaseFile*>& addList, const Utils::CStringList& orderList, std::vector<CBaseFile*>& addTo, const CPackages *packages)
+	{
+		// add all the items in the ordered list first
+		for (auto itr = orderList.begin(); itr != orderList.end(); itr++)
+		{
+			auto p = packages->findPackage((*itr)->str, (*itr)->data);
+			if (p)
+			{
+				auto findItr = std::find(addList.begin(), addList.end(), p);
+				if (findItr != addList.end())
+				{
+					auto checkItr = std::find(addTo.begin(), addTo.end(), p);
+					if(checkItr == addTo.end())
+						addTo.push_back(p);
+				}
+			}
+		}
+		// now add all the others
+		for (auto itr = addList.begin(); itr != addList.end(); itr++)
+		{
+			auto checkItr = std::find(addTo.begin(), addTo.end(), *itr);
+			if (checkItr == addTo.end())
+				addTo.push_back(*itr);
+		}
+	};
+	auto removeList = [](const std::vector<CBaseFile*>& removeList, std::set<CBaseFile*>& list)
+	{
+		for (auto itr = removeList.begin(); itr != removeList.end(); itr++)
+		{
+			auto findItr = std::find(list.begin(), list.end(), *itr);
+			if (findItr != list.end())
+				list.erase(findItr);
+		}
+	};
+	std::vector<CBaseFile*> order;
+	while (!packagesBefore.empty())
+	{
+		std::vector<CBaseFile*> packagesOrder;
+		// all packages that go before, but not after should go first
+		for (auto itr = packagesBefore.begin(); itr != packagesBefore.end(); itr++)
+		{
+			CBaseFile* p = *itr;
+			auto findItr = packagesAfter.find(p);
+			if (findItr == packagesAfter.end())
+				packagesOrder.push_back(p);
+			else
+			{
+				// check if any packages that we go after have been added
+				bool notAdded = false;
+				for (auto checkItr = findItr->second.begin(); checkItr != findItr->second.end(); checkItr++)
+				{
+					auto findItr2 = std::find(order.begin(), order.end(), *checkItr);
+					if (findItr2 == order.end())
+					{
+						notAdded = true;
+						break;
+					}
+				}
+				if (!notAdded)
+					packagesOrder.push_back(p);
+			}
+		}
+		// no valid packages left ? lets just add the rest
+		if (packagesOrder.empty())
+		{
+			for (auto itr = packagesBefore.begin(); itr != packagesBefore.end(); itr++)
+				packagesOrder.push_back(*itr);
+		}
+		addOrderedList(packagesOrder, m_lFakePatchOrder, order, this);
+		removeList(packagesOrder, packagesBefore);
+	}
+	// now add the remaining list ordered list
+	for (auto itr = m_lFakePatchOrder.begin(); itr != m_lFakePatchOrder.end(); itr++)
+	{
+		auto p = findPackage((*itr)->str, (*itr)->data);
+		if (p)
+		{
+			auto findItr = std::find(order.begin(), order.end(), p);
+			if (findItr == order.end())
+				order.push_back(p);
+		}
+	}
+	/*
 	// lets define the order
-	CyStringList fakePatchOrder;
-	for ( SStringList *str = m_lFakePatchOrder.Head(); str; str = str->next )
-		fakePatchOrder.PushBack(str->str, str->data);
 	// add any other packages that need to be ordered
 	// we need to work out the correct order
 	CLinkList<CBaseFile> packages;
 	for ( CListNode<CBaseFile> *pNode = m_lPackages.Front(); pNode; pNode = pNode->next() )
 		CBaseFile *p = pNode->Data();
 		// search for any fake patches in package
 		if ( !p->IsEnabled() ) continue;
 		if ( !p->AnyFileType(FILETYPE_MOD) ) continue;
+		int existingPos = fakePatchOrder.findStringAndData(p->name(), p->author());
-		// must have an order define
+		if (p->AnyDependacies())
+		{
+			for (SNeededLibrary* nl = p->GetNeededLibraries()->First(); nl; nl = p->GetNeededLibraries()->Next())
+			{
+				int findPos = fakePatchOrder.findStringAndData(nl->sName, nl->sAuthor);
+				if (existingPos == -1)
+					fakePatchOrder.pushBack(nl->sName, nl->sAuthor);
+				else if (findPos == -1)
+					fakePatchOrder.insertAt(existingPos, nl->sName, nl->sAuthor);
+				else if (findPos > existingPos)
+				{
-		if ( !p->AnyFakePatchOrder() ) continue;
+					fakePatchOrder.removeAt(findPos);
+					fakePatchOrder.insertAt(existingPos, nl->sName, nl->sAuthor);
+				}
+			}
+		}
-		// check if theres any already ordered (manual)
+		CSpkFile* spk = dynamic_cast<CSpkFile*>(p);
-		bool added = false;
+		if (spk)
-		for ( SStringList *sCheck = fakePatchOrder.Head(); sCheck; sCheck = sCheck->next )
+		{
-			if ( sCheck->str.Compare(CyString(p->name())) && sCheck->data.Compare(CyString(p->author())) )
+			if (spk->IsAnotherMod())
+			{
+				int findPos = fakePatchOrder.findStringAndData(spk->otherName(), spk->otherAuthor());
+				if (existingPos == -1)
+					fakePatchOrder.pushBack(spk->otherName(), spk->otherAuthor());
-				added = true;
+				else if (findPos == -1)
+					fakePatchOrder.insertAt(existingPos, spk->otherName(), spk->otherAuthor());
+				else if (findPos > existingPos)
+				{
+					fakePatchOrder.removeAt(findPos);
+					fakePatchOrder.insertAt(existingPos, spk->otherName(), spk->otherAuthor());
-				break;
+				}
+			}
+		}
+		// must have an order define
+		if (!p->anyFakePatchOrder())
+			continue;
+		if (fakePatchOrder.findStringAndData(p->name(), p->author()) != -1)
-		if ( added ) continue;
+			continue;
 		bool anyFound = false;
 		for ( C_File *file = p->GetFirstFile(FILETYPE_MOD); file; file = p->GetNextFile(file) )
+		{
 			if ( !file->IsFakePatch() ) continue;
 		// first add all the packages that dont need to be installed after
 		for ( CListNode<CBaseFile> *pNode = packages.Front(); pNode; pNode = pNode->next() )
+		{
 			CBaseFile *p = pNode->Data();
 			// we have a before and not after
-			if ( !p->GetFakePatchBeforeOrder().Empty() && p->GetFakePatchAfterOrder().Empty() )
+			if ( !p->getFakePatchBeforeOrder().empty() && p->getFakePatchAfterOrder().empty() )
+			{
 				// if we have to install before, check if any on the list
 				int earliestPos = -1;
 				bool notAdded = true;
-				for ( SStringList *str = p->GetFakePatchBeforeOrder().Head(); str; str = str->next )
+				auto& list = p->getFakePatchBeforeOrder();
+				for(auto itr = list.begin(); itr != list.end(); itr++)
+				{
 					int pos = 0;
 					for ( CListNode<CBaseFile> *sNode = sortedPackages.Front(); sNode; sNode = sNode->next() )
+					{
-						if ( str->str.Compare(CyString(sNode->Data()-&gt;name())) &;&; str->data.Compare(CyString(sNode->Data()->author())) )
+						if ((*itr)->str.Compare(sNode->Data()->name()) &amp;&; (*itr)->data.Compare(sNode->Data()->author()) )
+						{
 							if ( earliestPos == -1 || pos < earliestPos )
 								earliestPos = pos;
 							break;
+						}
 		// now do the packages that have both before and after
 		packages.RemoveEmpty();
 		for ( CListNode<CBaseFile> *pNode = packages.Front(); pNode; pNode = pNode->next() )
+		{
 			CBaseFile *p = pNode->Data();
-			if ( !p->GetFakePatchBeforeOrder().Empty() && !p->GetFakePatchAfterOrder().Empty() )
+			if ( !p->getFakePatchBeforeOrder().empty() && !p->getFakePatchAfterOrder().empty() )
+			{
+			}
+		}
 		// add them onto the list
 		for ( CListNode<CBaseFile> *pNode = sortedPackages.Front(); pNode; pNode = pNode->next() )
-			fakePatchOrder.PushBack(CyString(pNode->Data()->name()), CyString(pNode-&gt;Data()->author()));
+			fakePatchOrder.pushBack(pNode->Data()->name(), pNode-&gt;Data()->author());
+	}
 	// now add to do list
 	for ( CListNode<CBaseFile> *pNode = packages.Front(); pNode; pNode = pNode->next() )
-		fakePatchOrder.PushBack(CyString(pNode->Data()->name()), CyString(pNode-&gt;Data()->author()));
+		fakePatchOrder.pushBack(pNode->Data()->name(), pNode-&gt;Data()->author());
+		*/
-	for ( SStringList *str = fakePatchOrder.Head(); str; str = str->;next )
+	for(auto itr = order.begin(); itr != order.end(); itr++)
+	{
-		CBaseFile *package = FindPackage(str->str, str->data);
+		CBaseFile *package = *itr;
 		if ( package )
+		{
 			// might have more than 1 fake patch for the file, so we'll need the lowest
 			while ( true )
+			{
 						ShufflePatchTo(moveFile, FindLastFakePatch(), errors);
+					}
 					// space should be free, now lets shuffle it
 					ShufflePatchTo(lowestFile, lowest, errors);
 				}
 				doneList.push_back(lowestFile); // we've done this file now
 				lowest++; // move up the lowest ready for the next patch
+			}
+		}
+	}
 		if ( !f->IsFakePatch() )
 			continue;
 		// we only want cat and dat files, all fake patchs should be, but incase theres an error in the package somewhere we can check
 		if ( !f->CheckFileExt("cat") )
 			continue;
 		// now lets check if its greater than our gap
 		int check = FindNextFakePatch();
 		int patchNum = f->filename().token(".", 1).toInt();
 		if ( patchNum <= check )
 	else
 		this->AddLogEntry(SPKINSTALL_FAKEPATCH_FAIL, file->name() + "~" + newName, errors);
+}
 int CPackages::FindLowestFakePatchInstalled()
 {
 	int lowest = 99;
 	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
+	{
 		CBaseFile *p = node->Data();
 		if ( !p->IsEnabled() ) continue;
+{
 	CDirIO Dir((dir.Empty()) ? m_sCurrentDir : dir);
 	int check = start;
 	while ( check > 0 )
 	{
 		Utils::String checkStr = Utils::String::PadNumber(check, 2);
 		// check if a cat file exists
 		if ( !Dir.exists(checkStr + ".cat") )
+		{
 			// it doen't, check if theres a dat file (incase of package error)
 			if ( !Dir.exists(checkStr + ".dat") )
 				break;
+		}
 		--check;
 	}
 	return check;
+}
 /**
  * Find next fake patch
+ *
  * Searching for the next gap in patches, starting with 01.cat to 99.cat
  */
 int CPackages::FindNextFakePatch(int start, CyString dir)
 {
 	CDirIO Dir((dir.Empty()) ? m_sCurrentDir : dir);
 	int check = start;
 	while ( check < 99 )
+	{
 		++check;
 		Utils::String checkStr = Utils::String::PadNumber(check, 2);
 		// check if a cat file exists
 		if ( !Dir.exists(checkStr + ".cat") )
+		{
 			// it doen't, check if theres a dat file (incase of package error)
 			if ( !Dir.exists(checkStr + ".dat") )
 				break;
 		}
 	}
 	return check;
+}
 /**
  * Searching for the next gap in automatic text files, start with 0004-LXXX or XX0004
  */
 unsigned int CPackages::findNextTextFile(unsigned int start) const
+{
 	return findNextTextFile(Utils::String::Null(), start);
 }
 unsigned int CPackages::findNextTextFile(const Utils::String &dir, unsigned int start) const
+{
 	int check = start;
 	if ( check < 2 ) check = 2;
 	while ( check < 9999 )
 		++check;
 		Utils::String newFilename = SPK::FormatTextName(check, m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT));
 		// check the vfs
 		if ( m_pGameVFS.isFileAvailable("t/" + newFilename + ".pck") ) continue;
 		if ( m_pGameVFS.isFileAvailable("t/" + newFilename + ".xml") ) continue;
 		break;
+	}
 	return check;
+}
 		if ( !Dir.exists(newFilename + ".pck") )
+		{
 			// it doen't, check if theres an unpacked file
 			if ( !Dir.exists(newFilename + ".xml") )
 				break;
 		}
 	}
 	return check;
+}
 /**
  * Read game language
+ *
  * Reads the lang.dat file from the game directory for the language id
  */
 void CPackages::ReadGameLanguage(bool force)
+{
 	// check if lauguage is already set
 	if ( !force && m_iLanguage )
 		return;
 	CDirIO Dir(m_sCurrentDir);
 	// check for lang.dat file
 	if ( Dir.exists("lang.dat") )
 	{
-		CFileIO File(Dir.File("lang.dat"));
+		CFileIO File(Dir.file("lang.dat"));
 		size_t size;
 		char *data = File.ReadToData(&size);
 		if ( data )
 		{
-			CyString str(data);
+			Utils::String str(data);
-			m_iLanguage = str.GetToken("\n", 1, 1).GetToken(" ", 1, 1).ToInt();
+			m_iLanguage = str.token("\n", 1).token(" ", 1).toInt();
 		}
 	}
 }
 /**
  * Create Language Text File
+ *
  * Creates text files for all packages into the correct language
  */
-void CPackages::CreateLanguageTextFiles(CyStringList *errors)
+void CPackages::CreateLanguageTextFiles(Utils::CStringList *errors)
+{
 	// no need to create them if theres no language to use
 	if ( !m_iLanguage )
 		return;
 	// find all text files
-	CyStringList ids;
+	Utils::CStringList ids;
 	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
+	{
 		C_File *f = node->Data();
 		// only do text fiels
 		if ( f->GetFileType() != FILETYPE_TEXT )
 			continue;
-		CyString id, lang;
+		Utils::String id, lang;
 		if ( m_iGameFlags & EXEFLAG_TCTEXT )
 		{
-			id = f->GetBaseName().GetToken("-", 1, 1);
+			id = f->baseName().token("-", 1);
-			lang = f->GetBaseName().GetToken("-", 2, 2);
+			lang = f->baseName().token("-", 2);
-			if ( lang.Empty() )
+			if ( lang.empty() )
 				lang = "NULL";
 			else
-				lang = lang.Erase(0, 1);  // remove the "L"
+				lang = lang.erase(0, 1);  // remove the "L"
 		}
 		else
 		{
-			lang = f->GetBaseName().Left((int)f->GetBaseName().Length() - 4).PadNumber(3);
+			lang = Utils::String::PadNumber(f->baseName().left((int)f->baseName().length() - 4), 3);
-			id = f->GetBaseName().Mid(((int)f->GetBaseName().Length() - 4) + 1, 4);
+			id = f->baseName().mid(((int)f->baseName().length() - 4) + 1, 4);
 		}
-		SStringList *strList = ids.FindString(id);
 		// not added, add a new one
-		if ( !strList )
+		if (!ids.contains(id))
-			strList = ids.PushBack(id, lang);
+			ids.pushBack(id, lang);
 		else
+		{
+			Utils::String data = ids.findString(id);
-			if ( strList->data.Empty() )
+			if (data.empty())
-				strList->data = lang;
+				data = lang;
 			else
+			{
-				strList->data += ":";
+				data += ":";
-				strList->data += lang;
+				data += lang;
+			}
+			ids.changeData(id, data);
+		}
+	}
 	// we should now have a list of all text files, we need to remove those that have a matching language
-	for ( SStringList *sNode = ids.Head(); sNode; sNode = sNode->;next )
+	for(auto itr = ids.begin(); itr != ids.end(); itr++)
 	{
 		int size = 0;
-		CyString *data = sNode->data.SplitToken(&apos;:&apos;, &size);
+		Utils::String *data = (*itr)->data.tokenise(&quot;:&quot;, &size);
 		// huh ? we shouldn't have this
 		if ( !size )
 			continue;
+		{
 			if ( data[i] == "NULL" )
 				useId = -1;
 			else
+			{
-				int num = data[i].ToInt();
+				int num = data[i].toInt();
 				if ( num == m_iLanguage )
+				{
 					found = true;
 					useId = m_iLanguage;
 					break;
 				else if ( !useId )
 					useId = num;
+			}
+		}
-		if ( found )
+		if (found)
+		{
+			CLEANSPLIT(data, size);
 			continue;
+		}
 		if ( !useId )
-			useId = data[0].ToInt();
+			useId = data[0].toInt();
 		if ( !useId )
 			useId = -1;
 		CLEANSPLIT(data, size);
-		RenameTextFile(sNode->str, useId, errors);
+		RenameTextFile((*itr)->str, useId, errors);
+	}
+}
 /**
  * Rename a text file
+ *
- * Creates a new text file and copies an existing one
+ * Creates a new text file for the selected langage by copying an existing one
  */
-bool CPackages::RenameTextFile(CyString textid, int languageid, CyStringList *errors)
+bool CPackages::RenameTextFile(const Utils::String &textid, int languageid, Utils::CStringList *errors)
+{
 	// lets check if the file already exists
-	Utils::String newFilename = SPK::FormatTextName(textid.ToInt(), m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT));
+	Utils::String newFilename = SPK::FormatTextName(textid.toInt(), m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT));
 	C_File *addFile = FindFile(FILETYPE_TEXT, newFilename + ".xml");
 	if ( !addFile )
 		addFile = FindFile(FILETYPE_TEXT, newFilename + ".pck");
 	// we have found the file, lets just add it to our scripts
+	}
 	// first we need to find our text file
 	Utils::String filename;
 	if ( languageid != -1 )
-		filename = SPK::FormatTextName(textid.ToInt(), languageid, (m_iGameFlags & EXEFLAG_TCTEXT));
+		filename = SPK::FormatTextName(textid.toInt(), languageid, (m_iGameFlags & EXEFLAG_TCTEXT));
 	else
-		filename = textid.ToString();
+		filename = textid;
 	C_File *textFile = FindFile(FILETYPE_TEXT, filename + ".xml");
 	if ( !textFile )
 	{
 		textFile = FindFile(FILETYPE_TEXT, filename + ".pck");
 		if ( !textFile )
 			return false;
+	}
 	// now lets create out new text file
-	CFileIO readFile(textFile->GetFilePointer());
+	CFileIO readFile(textFile->filePointer());
-	std::vector<CyString> *lines = readFile.ReadLines();
+	std::vector<Utils::String> *lines = readFile.readLines();
 	// find the language id in the lines
-	std::vector<CyString> frontLines;
+	std::vector<Utils::String> frontLines;
-	for(std::vector<CyString>::iterator it = lines->begin(); it != lines->end(); ++it)
+	for(std::vector<Utils::String>::iterator it = lines->begin(); it != lines->end(); ++it)
+	{
-		CyString line = *it;
+		Utils::String line = *it;
-		int pos = line.FindPos("<language id");
+		int pos = line.findPos("<language id");
 		if ( pos != -1)
+		{
-			CyString newLine = "<language id=\"";
+			Utils::String newLine = "<language id=\"";
-			newLine += CyString::Number(m_iLanguage);
+			newLine += Utils::String::Number(m_iLanguage);
 			newLine += "\">";
-			newLine += line.GetToken(">", 2);
+			newLine += line.tokens(">", 2);
 			frontLines.insert(frontLines.begin(), newLine);
 			lines->erase(lines->begin(), ++it);
 			break;
+		}
 		frontLines.insert(frontLines.begin(), line);
+	}
-	for(std::vector<CyString>::iterator it = frontLines.begin(); it != frontLines.end(); ++it)
+	for(std::vector<Utils::String>::iterator it = frontLines.begin(); it != frontLines.end(); ++it)
 		lines->insert(lines->begin(), *it);
 	addFile = new C_File(newFilename + ".xml");
-	addFile->SetFileType(FILETYPE_TEXT);
+	addFile->setFileType(FILETYPE_TEXT);
 	CFileIO writeFile(m_sCurrentDir + "/" + addFile->getNameDirectory(NULL));
-	if ( writeFile.WriteFile(lines) )
+	if ( writeFile.writeFile(lines) )
+	{
-		this->AddLogEntry(SPKINSTALL_WRITEFILE, addFile->getNameDirectory(NULL), errors);
+		this->addLogEntry(SPKINSTALL_WRITEFILE, addFile->getNameDirectory(NULL), errors);
 		addFile->SetFilename(m_sCurrentDir + "/" + addFile->getNameDirectory(NULL));
 		// now we have the file wrriten, we need to add it to all scripts that need it
 		// first we add it to the global list
 		m_lFiles.push_back(addFile);
 		// now add it to the scripts
 		AddTextFileToScripts(addFile, textid);
+	}
 	else
+	{
-		this->AddLogEntry(SPKINSTALL_WRITEFILE_FAIL, addFile->getNameDirectory(NULL), errors);
+		this->addLogEntry(SPKINSTALL_WRITEFILE_FAIL, addFile->getNameDirectory(NULL), errors);
 		if ( lines )
 			delete lines;
 		return false;
+	}
 	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
 		node->Data()->SetNum(num++);
+}
 Utils::String CPackages::findDataDir(const Utils::String &dir, const Utils::String &file)
 {
 	CDirIO Dir(dir);
 	// data files could be in 4 places depending on what program is used, check for all of these
 	if (Dir.exists(file))
 		return Dir.file(file);
 	else if (Dir.exists("Data/" + file))
 		return Dir.file("Data/" + file);
 		return Dir.file("../" + file);
 	else if (Dir.exists("../Data/" + file))
 		return Dir.file("../Data/" + file);
 	return Utils::String::Null();
 }
 void CPackages::startup(const Utils::String &dir, const Utils::String &tempDir, const Utils::String &myDoc)
+{
 	this->setTempDirectory(tempDir);
 	this->setMyDocuments(myDoc);
+}
 void CPackages::startup(const Utils::String &dir, const Utils::String &tempDir, const Utils::String &myDoc, const Utils::String &mod)
+{
 	startup(dir, tempDir, myDoc);
 	m_sSetMod = mod;
 }
 /*
 void CPackages::Startup(CyString dir, CyString tempDir, CyString myDoc, CyString mod)
+{
 	startup(dir.ToString(), tempDir.ToString(), myDoc.ToString(), mod.ToString());
 }*/
+	{
 		CFileIO File(Dir.file("lang.dat"));
 		size_t size;
 		char *data = File.ReadToData(&size);
 		if ( data )
+		{
 			Utils::String str(data);
 			return str.token("\n", 1).token(" ", 1).toLong();
+		}
 CyString CPackages::GetProperDir(CyString dir)
+{
 	return m_gameExe.GetProperDir((dir.Empty()) ? m_sCurrentDir : dir.ToString());
+}
 CyString CPackages::GetAddonDir(CyString dir)
 {
 	return m_gameExe.GetAddonDir((dir.Empty()) ? m_sCurrentDir : dir.ToString());
+}
 Utils::String CPackages::getProperDir() const
+{
 	return getProperDir(m_sCurrentDir);
+{
 	return m_gameExe.GetGameAddons(m_sCurrentDir, exes);
+}
 Utils::String CPackages::getGameTypesString(CBaseFile *package, bool includeVersion)
 {
 	if ( !package->AnyGameCompatability() )
 		return "";
 	Utils::String sGames;
 	for ( CListNode<SGameCompat> *gNode = package->GetGameCompatabilityList()->Front(); gNode; gNode = gNode->next() ) {
+{
 	for ( CListNode<SGameCompat> *gNode = package->GetGameCompatabilityList()->Front(); gNode; gNode = gNode->next() ) {
 		if ( gNode->Data()->iGame == m_iGame ) {
 			return m_gameExe.GetGameVersionFromType(m_iGame - 1, gNode->Data()->iVersion - 1, gNode->Data()->sVersion);
+		}
 	}
 	return NullString;
+}
 CyString CPackages::GetGameVersionFromType(int game, int version, CyString sVersion)
+{
 	if ( addonDir.Empty() ) addonDir = this->GetAddonDir(dir);
 	if ( m_pEnabledMod && m_pEnabledMod->AnyFileType(FILETYPE_MOD) )
+	{
 		for ( C_File *file = m_pEnabledMod->GetFirstFile(FILETYPE_MOD); file; file = m_pEnabledMod->GetNextFile(file) )
 		{
 			if ( !file->CheckFileExt("cat") )
 				continue;
 			CCatFile catFile;
 			if ( catFile.open(file->filePointer(), addonDir.ToString(), CATREAD_CATDECRYPT, false) == CATERR_NONE )
 			{
 				if ( catFile.ExtractFile(aFilename, aTo) )
 					return 1;
 				if ( catFile.error() == CATERR_INVALIDDEST || catFile.error() == CATERR_CANTCREATEDIR )
 				{
 					if ( catFile.ExtractFile(aFilename) )
 						return -1;
 				}
+			}
+		}
+	}
-	else if ( !m_sSetMod.Empty() )
+	else if ( !m_sSetMod.empty() )
+	{
-		if ( CFileIO::Exists(m_sCurrentDir + "/mods/" + m_sSetMod.ToString() + ".cat"))
+		if ( CFileIO::Exists(m_sCurrentDir + "/mods/" + m_sSetMod + ".cat"))
+		{
 			CCatFile catFile;
-			if (catFile.open(m_sCurrentDir + "/mods/" + m_sSetMod.ToString() + ".cat", addonDir.ToString(), CATREAD_CATDECRYPT, false) == CATERR_NONE)
+			if (catFile.open(m_sCurrentDir + "/mods/" + m_sSetMod + ".cat", addonDir.ToString(), CATREAD_CATDECRYPT, false) == CATERR_NONE)
+			{
 				if ( catFile.ExtractFile(aFilename, aTo) )
 					return 1;
 				if ( catFile.error() == CATERR_INVALIDDEST || catFile.error() == CATERR_CANTCREATEDIR )
+				{
 	for ( int i = 0; i < WAREBUFFERS; i++ )
+	{
 		// its empty, no need to create ware files
 		if ( !m_lGameWares[i].size() )
 			continue;
 		// lets extract the ware file
 		char wareType = CPackages::ConvertWareTypeBack(i);
 		Utils::String wareFile = "TWare";
 		wareFile += (char)UPPER(wareType);
+		}
 		if ( !openFile.Empty() )
+		{
 			// read the file into memory
-			CyStringList wareLines;
+			Utils::CStringList wareLines;
-			int oldSize = -1;
+			size_t oldSize = -1;
 			int version = -1;
 			// read first number
 			CFileIO readFile(m_sTempDir + "/" + wareFile + ".txt");
-			CyStringList *lines = readFile.ReadLinesStr();
+			Utils::CStringList *lines = readFile.readLinesStr();
 			if ( lines )
+			{
-				for ( SStringList *str = lines->;Head(); str; str = str->next )
+				for(auto itr = lines->;begin(); itr != lines->end(); itr++)
+				{
-					CyString line(str->str);
+					Utils::String line((*itr)->str);
-					line.RemoveFirstSpace();
+					line.removeFirstSpace();
-					line.RemoveChar(9);
+					line.removeChar(9);
-					line.RemoveChar('\r');
+					line.removeChar('\r');
-					if ( line.Empty() )
+					if ( line.empty() )
 						continue;
 					if ( line[0] == '/' )
 						continue;
 					if ( oldSize == -1 )
 					{
-						version = line.GetToken(";", 1, 1).ToInt();
+						version = line.token(";", 1).toInt();
-						oldSize = line.GetToken(";", 2, 2).ToInt();
+						oldSize = line.token(";", 2).toInt();
+					}
 					else
+					{
-						line.RemoveEndSpace();
+						line.removeEndSpace();
-						if ( line.Right(1) != ';' )
+						if ( line.back() != ';')
 							line += ";";
-						wareLines.PushBack(line);
+						wareLines.pushBack(line);
-						if ( wareLines.Count() >= oldSize )
+						if ( wareLines.size() >= oldSize )
 							break;
+					}
+				}
 				delete lines;
 				// apply the buffer
 				if ( m_iWareBuffer[i] <= 0 )
-					m_iWareBuffer[i] = wareLines.Count() + 10;
+					m_iWareBuffer[i] = wareLines.size() + 10;
 				// last resort, readjust the buffer
-				else if ( wareLines.Count() > m_iWareBuffer[i] )
+				else if ( wareLines.size() > static_cast<size_t>(m_iWareBuffer[i]) )
-					m_iWareBuffer[i] = wareLines.Count();
+					m_iWareBuffer[i] = wareLines.size();
 				// add the buffers
-				while ( wareLines.Count() < m_iWareBuffer[i] )
+				while ( wareLines.size() < static_cast<size_t>(m_iWareBuffer[i]) )
-					wareLines.PushBack("27;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;SS_WARE_FILLER;");
+					wareLines.pushBack("27;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;SS_WARE_FILLER;");
 				// add the ware lines
 				bool create = false;
 				for ( CListNode<SGameWare> *node = m_lGameWares[i].Front(); node; node = node->next() )
+				{
 					if ( w->iType == WARETYPE_NONE )
 						continue;
 					else if ( w->iType == WARETYPE_DISABLED )
+					{
 						create = true;
-						wareLines.PushBack(CyString("27;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;") + w->sWareName + "_DISABLED;");
+						wareLines.pushBack("27;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;" + w->sWareName + "_DISABLED;");
+					}
 					else if ( w->iType == WARETYPE_DELETED || !w->pWare )
+					{
 						create = true;
-						wareLines.PushBack("27;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;SS_WARE_DELETED;");
+						wareLines.pushBack("27;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;SS_WARE_DELETED;");
+					}
 					else if ( w->iType == WARETYPE_ADDED )
+					{
 						create = true;
 						w->pWare->iDescID = wareTextID;
 						w->iText = wareTextID;
 						wareTextID += 10;
-						w->iPos = wareLines.Count();
+						w->iPos = wareLines.size();
 						long price = this->customWareOveridePrice(w->pWare->sID);
 						int notority = w->pWare->iNotority;
 						if ( !this->customWareOverideNoto(w->pWare->sID, &notority) ) notority = w->pWare->iNotority;
 						if ( !price ) price = w->pWare->iPrice;
-						wareLines.PushBack(CyString("28;0;0;0;0;") + (long)wareLines.Count() + ";" + (long)(w->iText + 3) + ";" + (long)w->pWare->iVolumn + ";" + price + ";1;1;" + (long)w->pWare->iSize + ";" + price + ";" + (long)notority + ";0;0;" + w->sWareName.ToUpper() + ";");
+						wareLines.pushBack(Utils::String("28;0;0;0;0;") + (long)wareLines.size() + ";" + (long)(w->iText + 3) + ";" + (long)w->pWare->iVolumn + ";" + price + ";1;1;" + (long)w->pWare->iSize + ";" + price + ";" + (long)notority + ";0;0;" + w->sWareName.upper() + ";");
+					}
+				}
 				if ( create )
+				{
-					wareLines.PushFront(CyString::Number(version) + ";" + CyString::Number(wareLines.Count()) + ";", NullString);
+					wareLines.pushFront(Utils::String::Number(version) + ";" + Utils::String::Number(wareLines.size()) + ";", Utils::String::Null());
-					CyString strV;
+					Utils::String strV;
 					strV.FromFloat(GetLibraryVersion(), 2);
-					wareLines.PushFront(CyString("// Created by SPKInstaller Libraries V") + strV, NullString);
+					wareLines.pushFront("// Created by SPKInstaller Libraries V" + strV, Utils::String::Null());
-					if ( readFile.WriteFile(&wareLines) )
+					if ( readFile.writeFile(&wareLines) )
 						this->PackFile(&readFile, CyString("types\\") + wareFile + ".pck");
+				}
+			}
 			readFile.remove();
+		}
+	}
+}
-Utils::String CPackages::empWaresForGame(int *maxsize)
+Utils::String CPackages::empWaresForGame(size_t *maxsize)
+{
 	if ( maxsize ) (*maxsize) = 0;
 	if ( m_iGame == GAME_X3TC )
+	{
 void CPackages::CreateEMPFile(CyString progDir)
+{
 	// do emp wares
-	int maxsize = 0;
+	size_t maxsize = 0;
 	Utils::String empWares = empWaresForGame(&maxsize);
 	if ( maxsize )
+	{
 		int e = ExtractGameFile("types/TWareT.pck", m_sTempDir + "/TWareT.txt");
 		if ( e )
+		{
 			// read the file into memory
-			CyStringList wareLines;
+			Utils::CStringList wareLines;
-			int oldSize = -1;
+			size_t oldSize = -1;
 			int version = -1;
 			// read first number
 			CFileIO readFile((e == -1) ? "TWareT.txt" : m_sTempDir + "/TWareT.txt");
 			std::vector<Utils::String> *lines = readFile.readLines();
 							if ( this->empOverideNoto(i - 116, &noto) ) {
 								line = line.replaceToken(";", 14, Utils::String::Number(noto));
+							}
+						}
-						wareLines.PushBack(CyString(line));
+						wareLines.pushBack(line);
-						if ( wareLines.Count() >= oldSize )
+						if ( wareLines.size() >= oldSize )
 							break;
+					}
+				}
 				delete lines;
+			}
 			// now we too add/remove entries to match
 			// need filler entries
-			while ( wareLines.Count() < maxsize )
+			while ( wareLines.size() < maxsize )
-				wareLines.PushBack("27;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;SS_WARE_FILLER;");
+				wareLines.pushBack("27;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;SS_WARE_FILLER;");
 			int empEntries = 0;
 			Utils::String *empStr = empWares.tokenise("\n", &empEntries);
 			if ( empEntries && empStr )
+				}
 				// remove any empty end entries
 				while ( empStr[empEntries - 1].empty() )
 					--empEntries;
-				CyStringList addAfter;
+				Utils::CStringList addAfter;
-				if ( wareLines.Count() > maxsize )
+				if ( wareLines.size() > maxsize )
+				{
 					// force emp, remove entries to allow them to be added
 					if ( m_bForceEMP )
+					{
 						// more after emp
-						if ( wareLines.Count() > (maxsize + empEntries) )
+						if ( wareLines.size() > (maxsize + empEntries) )
+						{
-							SStringList *node = wareLines.GetAt(maxsize + empEntries);
+							for (size_t i = (maxsize + empEntries); i < wareLines.size(); i++)
-							while ( node )
+							{
-								addAfter.PushBack(node->str);
+								auto node = wareLines.get(i);
-								node = node->next;
+								addAfter.pushBack(node->str);
+							}
+						}
 						// no remove them all
-						wareLines.DeleteFrom(maxsize);
+						while (wareLines.size() > maxsize)
+							wareLines.removeAt(wareLines.size() - 1);
+					}
 					else if ( m_iGame == GAME_X3TC || m_iGame == GAME_X3AP || m_iGame == GAME_X3FL) // check if old emp is included, and convert it
+					{
-						if ( wareLines.Count() > 128 )
+						if ( wareLines.size() > 128 )
+						{
-							CyString test = wareLines.GetAt(128)->str;
+							Utils::String test = wareLines.get(128)->str;
-							if ( test.GetToken(";", -2).Compare("SS_WARE_SW_CUSTOM16_1;") )
+							if ( test.tokens(";", -2).Compare("SS_WARE_SW_CUSTOM16_1;") )
+							{
 								// if theres any at the end, remove the last emp entry
-								if ( wareLines.Count() > (maxsize + empEntries - 1) )
+								if ( wareLines.size() > (maxsize + empEntries - 1) )
+								{
-									SStringList *node = wareLines.GetAt(maxsize + empEntries - 2);
+									wareLines.removeAt(maxsize + empEntries - 2);
-									if ( node )
-										node->remove = true;
+								}
-								wareLines.Insert(128, "0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;128;");
+								wareLines.insertAt(128, "0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;128;");
-								wareLines.RemoveMarked();
+							}
+						}
+					}
+				}
 				// too many entries, need to remove the first set of EMP wares
 				int i = 0;
-				if ( wareLines.Count() > maxsize )
+				if ( wareLines.size() > maxsize )
-					i = wareLines.Count() - maxsize;
+					i = wareLines.size() - maxsize;
 				for ( ; i < empEntries; i++ )
+				{
-					CyString str = empStr[i];
+					Utils::String str = empStr[i];
-					str.RemoveEndSpace();
+					str.removeEndSpace();
-					str.RemoveChar(9);
+					str.removeChar(9);
-					str.RemoveChar('\r');
+					str.removeChar('\r');
-					if ( str.Empty() )
+					if ( str.empty() )
 						continue;
-					if ( str.Right(1) != ";" )
+					if ( str.right(1) != ";")
 						str += ";";
-					wareLines.PushBack(str);
+					wareLines.pushBack(str);
+				}
-				for ( SStringList *afterNode = addAfter.Head(); afterNode; afterNode = afterNode->;next )
+				for(auto afterItr = addAfter.begin(); afterItr != addAfter.end(); afterItr++)
-					wareLines.PushBack(afterNode->str);
+					wareLines.pushBack((*afterItr)->str);
 				// finally we write the whole file
-				wareLines.PushFront(CyString::Number(version) + ";" + CyString::Number(wareLines.Count()) + ";", NullString);
+				wareLines.pushFront(Utils::String::Number(version) + ";" + Utils::String::Number(wareLines.size()) + ";", Utils::String::Null());
-				CyString strV;
-				strV.FromFloat(GetLibraryVersion(), 2);
-				wareLines.PushFront(CyString(";// Created by SPKInstaller Libraries V") + strV, NullString);
+				wareLines.pushFront(";// Created by SPKInstaller Libraries V" + Utils::String::FromFloat(GetLibraryVersion(), 2), Utils::String::Null());
-				if ( readFile.WriteFile(&wareLines) )
+				if ( readFile.writeFile(&wareLines) )
 					this->PackFile(&readFile, "types\\TWareT.pck");
+			}
 			CLEANSPLIT(empStr, empEntries);
+		}
+	}
 	if ( !lang || lang < 0 )
 		lang = 44;
 	CDirIO Dir(m_sCurrentDir);
 	if ( !Dir.exists("t") )
-		Dir.Create("t");
+		Dir.create("t");
 	Utils::String filename = SPK::FormatTextName(PMTEXTFILE, lang, (m_iGameFlags & EXEFLAG_TCTEXT));
 	CFileIO textFile(m_sCurrentDir + "/t/" + filename + ".xml");
-	std::vector<CyString> writeData;
+	std::vector<Utils::String> writeData;
-	writeData.push_back(CyString("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>"));
+	writeData.push_back("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
-	writeData.push_back(CyString("<language id=\"") + CyString::Number(lang) + "\">");
+	writeData.push_back("<language id=\"" + Utils::String::Number(lang) + "\">");
 	if ( !gameNumber )
-		writeData.push_back(CyString("	<page id=\"") + CyString::Number(PMTEXTFILE) + "\" title=\"Plugin Manager Text File\" descr=\"Contains text used for the plugin manager, packages, settings, wares, ship, etc\">");
+		writeData.push_back("	<page id=\"" + Utils::String::Number(PMTEXTFILE) + "\" title=\"Plugin Manager Text File\" descr=\"Contains text used for the plugin manager, packages, settings, wares, ship, etc\">");
 	else
-		writeData.push_back(CyString(&quot;	&lt;page id=\"") + (long)gameNumber + CyString::Number(PMTEXTFILE).PadNumber(4) + "\" title=\"Plugin Manager Text File\" descr=\"Contains text used for the plugin manager, packages, settings, wares, ship, etc\">");
+		writeData.push_back(&quot;	&lt;page id=\"" + (long)gameNumber + Utils::String::PadNumber(PMTEXTFILE, 4) + "\" title=\"Plugin Manager Text File\" descr=\"Contains text used for the plugin manager, packages, settings, wares, ship, etc\">");
-	writeData.push_back(CyString("		<t id=\"99998\">[author]Plugin Manager[/author]It appears the plugin manager hasn't been closed properly.  Make sure its closed before running the game otherwise things may not work correctly</t>"));
+	writeData.push_back("		<t id=\"99998\">[author]Plugin Manager[/author]It appears the plugin manager hasn't been closed properly.  Make sure its closed before running the game otherwise things may not work correctly</t>");
-	writeData.push_back(CyString("		<t id=\"99999\">2</t>"));
+	writeData.push_back("		<t id=\"99999\">2</t>");
+	writeData.push_back("	</page>");
-	writeData.push_back(CyString("	</page>"));
-	writeData.push_back(CyString("</language>"));
+	writeData.push_back("</language>");
-	textFile.WriteFileUTF(&writeData);
+	textFile.writeFileUTF(&writeData);
 	size_t fileSize;
 	char *fileData = CFileIO(textFile.fullFilename()).ReadToData(&fileSize);
 	if ( fileData && fileSize)
 	if ( !lang || lang < 0 )
 		lang = 44;
 	CDirIO Dir(m_sCurrentDir);
 	if ( !Dir.exists("t") )
-		Dir.Create("t");
+		Dir.create("t");
 	m_iLastUpdated = (int)time(NULL);
 	Utils::String filename = SPK::FormatTextName(PMTEXTFILE, lang, (m_iGameFlags & EXEFLAG_TCTEXT));
 	CFileIO textFile(m_sCurrentDir + "/t/" + filename + ".xml");
-	std::vector<CyString> writeData;
+	std::vector<Utils::String> writeData;
 	CLinkList<SGameWare> lWares;
 	CLinkList<SGameShip> lShips;
 	for ( int i = 0; i < WAREBUFFERS; i++ )
+	{
 		if ( node->Data()->iType == WARETYPE_NONE )
 			continue;
 		lShips.push_back(node->Data());
+	}
-	writeData.push_back(CyString("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>"));
+	writeData.push_back("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
-	writeData.push_back(CyString("<language id=\"") + CyString::Number(lang) + "\">");
+	writeData.push_back("<language id=\"" + Utils::String::Number(lang) + "\">");
 	if ( !gameNumber )
-		writeData.push_back(CyString("	<page id=\"") + CyString::Number(PMTEXTFILE) + "\" title=\"Plugin Manager Text File\" descr=\"Contains text used for the plugin manager, packages, settings, wares, ship, etc\">");
+		writeData.push_back("	<page id=\"" + Utils::String::Number(PMTEXTFILE) + "\" title=\"Plugin Manager Text File\" descr=\"Contains text used for the plugin manager, packages, settings, wares, ship, etc\">");
 	else
-		writeData.push_back(CyString(&quot;	&lt;page id=\"") + (long)gameNumber + CyString::Number(PMTEXTFILE).PadNumber(4) + "\" title=\"Plugin Manager Text File\" descr=\"Contains text used for the plugin manager, packages, settings, wares, ship, etc\">");
+		writeData.push_back(&quot;	&lt;page id=\"" + (long)gameNumber + Utils::String::PadNumber(PMTEXTFILE, 4) + "\" title=\"Plugin Manager Text File\" descr=\"Contains text used for the plugin manager, packages, settings, wares, ship, etc\">");
 	// write the heading
 	int start = 10000;
-	writeData.push_back(CyString("		<t id=\"1\">") + CyString::Number(m_iLastUpdated) + "</t>");
+	writeData.push_back("		<t id=\"1\">" + Utils::String::Number(m_iLastUpdated) + "</t>");
-	writeData.push_back(CyString("		<t id=\"2\">") + CyString::Number(this->CountPackages(TYPE_SPK, true)) + "</t>");
+	writeData.push_back("		<t id=\"2\">" + Utils::String::Number(this->CountPackages(TYPE_SPK, true)) + "</t>");
-	writeData.push_back(CyString("		<t id=\"3\">") + CyString::Number(start) + "</t>");
+	writeData.push_back("		<t id=\"3\">" + Utils::String::Number(start) + "</t>");
-	writeData.push_back(CyString("		<t id=\"4\">") + CyString::Number(lWares.size()) + "</t>");
+	writeData.push_back("		<t id=\"4\">" + Utils::String::Number(lWares.size()) + "</t>");
-	writeData.push_back(CyString("		<t id=\"6\">") + CyString::Number(lShips.size()) + "</t>");
+	writeData.push_back("		<t id=\"6\">" + Utils::String::Number(lShips.size()) + "</t>");
 	// write some generic texts
-	writeData.push_back(CyString("		&lt;t id=\&quot;110\&quot;&gt;") + (long)m_iLanguage + "</t>");
+	writeData.push_back(&quot;		<;t id=\&quot;110\&quot;&gt;" + Utils::String::Number((long)m_iLanguage) + "</t>");
-	writeData.push_back(CyString("		<t id=\"109\">Plugin Manager: \\033GPoll Gui Data\\033X</t>"));
+	writeData.push_back("		<t id=\"109\">Plugin Manager: \\033GPoll Gui Data\\033X</t>");
-	writeData.push_back(CyString("		<t id=\"107\">Plugin Manager: \\033GExport Game Data\\033X </t>"));
+	writeData.push_back("		<t id=\"107\">Plugin Manager: \\033GExport Game Data\\033X </t>");
-	writeData.push_back(CyString("		<t id=\"100\">\\n</t>"));
+	writeData.push_back("		<t id=\"100\">\\n</t>");
-	writeData.push_back(CyString("		<t id=\"101\">\\033B</t>"));
+	writeData.push_back("		<t id=\"101\">\\033B</t>");
-	writeData.push_back(CyString("		<t id=\"102\">\\033G</t>"));
+	writeData.push_back("		<t id=\"102\">\\033G</t>");
-	writeData.push_back(CyString("		<t id=\"103\">\\033B</t>"));
+	writeData.push_back("		<t id = \"103\">\\033B</t>");
-	writeData.push_back(CyString("		<t id=\"104\">\\033X</t>"));
+	writeData.push_back("		<t id=\"104\">\\033X</t>");
-	writeData.push_back(CyString("		<t id=\"105\">\\033Y</t>"));
+	writeData.push_back("		<t id=\"105\">\\033Y</t>");
-	writeData.push_back(CyString("		<t id=\"106\">\\033C</t>"));
+	writeData.push_back("		<t id=\"106\">\\033C</t>");
-	writeData.push_back(CyString("		<t id=\"108\">\\033</t>"));
+	writeData.push_back("		<t id=\"108\">\\033</t>");
-	writeData.push_back(CyString("		<t id=\"99998\">[author]Plugin Manager[/author]It appears the plugin manager hasn't been closed properly.  Make sure its closed before running the game otherwise things may not work correctly</t>"));
+	writeData.push_back("		<t id=\"99998\">[author]Plugin Manager[/author]It appears the plugin manager hasn't been closed properly.  Make sure its closed before running the game otherwise things may not work correctly</t>");
-	writeData.push_back(CyString("		<t id=\"99999\">1</t>"));
+	writeData.push_back("		<t id=\"99999\">1</t>");
 	// now write each package
 	int settingStart = 100000;
 	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
+	{
 		CBaseFile *p = node->Data();
 			continue;
 		CSpkFile *spk = (CSpkFile *)p;
 		// count text files
-		CyString textEntries;
+		Utils::String textEntries;
 		int textCount = 0;
 		C_File *f = p->GetFirstFile(FILETYPE_TEXT);
 		while ( f )
+		{
-			CyString sLang;
+			Utils::String sLang;
-			CyString id;
+			Utils::String id;
 			if ( m_iGameFlags & EXEFLAG_TCTEXT )
+			{
-				id = f->GetBaseName().GetToken("-", 1, 1);
+				id = f->baseName().token("-", 1);
-				sLang = f->GetBaseName().GetToken("-", 2, 2);
+				sLang = f->baseName().token("-", 2);
-				if ( sLang.Empty() )
+				if ( sLang.empty() )
 					sLang = "NULL";
 				else
-					sLang = sLang.Erase(0, 1);  // remove the "L"
+					sLang = sLang.erase(0, 1);  // remove the "L"
+			}
 			else
+			{
-				sLang = f->GetBaseName().Left((int)f->GetBaseName().Length() - 4).PadNumber(3);
+				sLang = f->baseName().left((int)f->baseName().length() - 4).padNumber(3);
-				id = f->GetBaseName().Mid(((int)f->GetBaseName().Length() - 4) + 1, 4);
+				id = f->baseName().mid(((int)f->baseName().length() - 4) + 1, 4);
+			}
 			if ( sLang != "NULL" )
+			{
-				if ( sLang.ToInt() == lang )
+				if ( sLang.toInt() == lang )
+				{
 					++textCount;
-					if ( !textEntries.Empty() )
+					if ( !textEntries.empty() )
 						textEntries += " ";
 					textEntries += id;
+				}
+			}
 			f = p->GetNextFile(f);
+		}
-		CyString sTextCount((long)textCount);
+		Utils::String sTextCount((long)textCount);
-		writeData.push_back(CyString("		<t id=\"") + (long)start + "\">" + this->ConvertTextString(p->name()) + "</t>");
+		writeData.push_back("		<t id=\"" + Utils::String::Number((long)start) + "\">" + this->ConvertTextString(p->name()) + "</t>");
-		writeData.push_back(CyString("		&lt;t id=\"&quot;) + (long)(start + 1) + "\">" + this->ConvertTextString(p->author()) + "</t>");
+		writeData.push_back(&quot;		<;t id=\"&quot; + Utils::String::Number((long)(start + 1)) + "\">" + this->ConvertTextString(p->author()) + "</t>");
-		writeData.push_back(CyString("		&lt;t id=\"&quot;) + (long)(start + 2) + "\">" + this->ConvertTextString(p->version()) + "</t>");
+		writeData.push_back(&quot;		<;t id=\"&quot; + Utils::String::Number((long)(start + 2)) + "\">" + this->ConvertTextString(p->version()) + "</t>");
-		writeData.push_back(CyString("		&lt;t id=\"&quot;) + (long)(start + 3) + "\">" + this->ConvertTextString(p->GetLanguageName(lang).ToString()) + "</t>");
+		writeData.push_back(&quot;		<;t id=\"&quot; + Utils::String::Number((long)(start + 3)) + "\">" + this->ConvertTextString(p->GetLanguageName(lang).ToString()) + "</t>");
 		CLinkList<SSettingType> *settings = spk->GetSettingsList();
 		if ( settings && settings->size() )
+		{
-			writeData.push_back(CyString("		<t id=\"") + (long)(start + 4) + "\">" + (long)settings->size() + "</t>");
+			writeData.push_back(Utils::String("		<t id=\"") + (long)(start + 4) + "\">" + (long)settings->size() + "</t>");
-			writeData.push_back(CyString("		<t id=\"") + (long)(start + 5) + "\">" + (long)settingStart + "</t>");
+			writeData.push_back(Utils::String("		<t id=\"") + (long)(start + 5) + "\">" + (long)settingStart + "</t>");
 			for ( CListNode<SSettingType> *sNode = settings->Front(); sNode; sNode = sNode->next() )
+			{
 				SSettingType *st = sNode->Data();
-				writeData.push_back(CyString("		<t id=\"") + (long)(settingStart++) + "\">" + st->sKey + "</t>");
+				writeData.push_back(Utils::String("		<t id=\"") + (long)(settingStart++) + "\">" + st->sKey + "</t>");
-				writeData.push_back(CyString("		<t id=\"") + (long)(settingStart++) + "\">" + spk->GetSetting(st) + "</t>");
+				writeData.push_back(Utils::String("		<t id=\"") + (long)(settingStart++) + "\">" + spk->GetSetting(st) + "</t>");
+			}
+		}
 		else
-			writeData.push_back(CyString("		<t id=\"") + (long)(start + 4) + "\">0</t>");
+			writeData.push_back(Utils::String("		<t id=\"") + (long)(start + 4) + "\">0</t>");
-		writeData.push_back(CyString("		<t id=\"") + (long)(start + 6) + "\">" + sTextCount + "</t>");
+		writeData.push_back(Utils::String("		<t id=\"") + (long)(start + 6) + "\">" + sTextCount + "</t>");
 		if ( textCount )
-			writeData.push_back(CyString("		<t id=\"") + (long)(start + 7) + "\">" + textEntries + "</t>");
+			writeData.push_back(Utils::String("		<t id=\"") + (long)(start + 7) + "\">" + textEntries + "</t>");
 		start += 10;
+	}
 	// write ware names
 	if ( lWares.size() )
+	{
-		writeData.push_back(CyString("		<t id=\"5\">") + CyString::Number(start) + "</t>");
+		writeData.push_back("		<t id=\"5\">" + Utils::String::Number(start) + "</t>");
 		for ( CListNode<SGameWare> *node = lWares.Front(); node; node = node->next() )
+		{
 			SGameWare *w = node->Data();
 			if ( w->pWare && w->iType == WARETYPE_ADDED )
-				writeData.push_back(CyString("		<t id=\"") + (long)start + "\">" + this->ConvertTextString(w->sWareName.ToString()) + "</t>");
+				writeData.push_back(Utils::String("		<t id=\"") + (long)start + "\">" + this->ConvertTextString(w->sWareName) + "</t>");
 			else
-				writeData.push_back(CyString("		<t id=\"") + (long)start + "\">-1</t>");
+				writeData.push_back(Utils::String("		<t id=\"") + (long)start + "\">-1</t>");
-			writeData.push_back(CyString("		<t id=\"") + (long)(start + 1) + "\">" + CyString((char)w->cType) + "</t>");
+			writeData.push_back(Utils::String("		<t id=\"") + (long)(start + 1) + "\">" + Utils::String((char)w->cType) + "</t>");
-			writeData.push_back(CyString("		<t id=\"") + (long)(start + 2) + "\">" + (long)w->iPos + "</t>");
+			writeData.push_back(Utils::String("		<t id=\"") + (long)(start + 2) + "\">" + (long)w->iPos + "</t>");
 			start += 10;
+		}
+	}
 	if ( lShips.size() )
+	{
-		writeData.push_back(CyString("		<t id=\"7\">") + CyString::Number(start) + "</t>");
+		writeData.push_back("		<t id=\"7\">" + Utils::String::Number(start) + "</t>");
 		for ( CListNode<SGameShip> *node = lShips.Front(); node; node = node->next() )
+		{
 			SGameShip *gs = node->Data();
 			if ( gs->iType == WARETYPE_NONE )
 				continue;
 			if ( gs->pPackage && gs->iType == WARETYPE_ADDED )
-				writeData.push_back(CyString("		<t id=\"") + (long)start + "\">" + gs->sShipID + "</t>");
+				writeData.push_back(Utils::String("		<t id=\"") + (long)start + "\">" + gs->sShipID + "</t>");
 			else
-				writeData.push_back(CyString("		<t id=\"") + (long)start + "\">-1</t>");
+				writeData.push_back(Utils::String("		<t id=\"") + (long)start + "\">-1</t>");
-			writeData.push_back(CyString("		<t id=\"") + (long)(start + 1) + "\">" + (long)gs->iPos + "</t>");
+			writeData.push_back(Utils::String("		<t id=\"") + (long)(start + 1) + "\">" + (long)gs->iPos + "</t>");
-			writeData.push_back(CyString("		<t id=\"") + (long)(start + 2) + "\">Ship</t>");
+			writeData.push_back(Utils::String("		<t id=\"") + (long)(start + 2) + "\">Ship</t>");
 			// write shipyard info
 			if ( gs->pPackage )
+			{
 				int doStart = start + 5;
 				for ( int i = SHIPYARD_ARGON; i <= SHIPYARD_MAX; i *= 2 )
+				{
-					writeData.push_back(CyString("		<t id=\"") + (long)(doStart) + "\">" + ((gs->pPackage->IsShipyard(i)) ? CyString::Number(1) : CyString::Number(0)) + "</t>");
+					writeData.push_back(Utils::String("		<t id=\"") + (long)(doStart) + "\">" + ((gs->pPackage->IsShipyard(i)) ? Utils::String::Number(1) : Utils::String::Number(0)) + "</t>");
 					++doStart;
+				}
+			}
 			start += 20;
+		}
+	}
-	writeData.push_back(CyString("	</page>"));
+	writeData.push_back("	</page>");
+	// do emp
+	if (m_iGame == GAME_X3TC || m_iGame == GAME_X3 || m_iGame == GAME_X3AP || m_iGame == GAME_X3FL)
+	{
+		writeData.push_back("  <page id=\"17\" title=\"Plugin Manager Objects\">");
+		writeData.push_back(GetEMPText());
+		writeData.push_back("  </page>");
+	}
 	// wares
 	if ( m_iGame == GAME_X3AP || m_iGame == GAME_X3TC || m_iGame == GAME_X3FL || m_iGame == GAME_X3 || lWares.size() || lShips.size() )
+	{
 		if ( !gameNumber )
-			writeData.push_back(CyString("  <page id=\"17\" title=\"Plugin Manager Objects\">"));
+			writeData.push_back("  <page id=\"17\" title=\"Plugin Manager Objects\">");
 		else
-			writeData.push_back(CyString("  <page id=\"") + (long)gameNumber + "0017\" title=\"Plugin Manager Objects\">");
+			writeData.push_back(Utils::String("  <page id=\"") + (long)gameNumber + "0017\" title=\"Plugin Manager Objects\">");
-		writeData.push_back(CyString("		<t id=\"") + (long)(SHIPSTARTTEXT - 1) + "\">ZZ_BLANKSHIP</t>");
+		writeData.push_back(Utils::String("		<t id=\"") + (long)(SHIPSTARTTEXT - 1) + "\">ZZ_BLANKSHIP</t>");
-		// do emp
-		if ( m_iGame == GAME_X3TC || m_iGame == GAME_X3 || m_iGame == GAME_X3AP || m_iGame == GAME_X3FL)
-			writeData.push_back(GetEMPText());
 		// object names
 		for ( CListNode<SGameWare> *node = lWares.Front(); node; node = node->next() )
+		{
 			SGameWare *w = node->Data();
 			if ( !w->pWare || w->iType != WARETYPE_ADDED )
 				continue;
 			// find the correct text for the language
 			Utils::String name = CSpkFile::GetWareText(w->pWare, m_iLanguage);
 			Utils::String desc = CSpkFile::GetWareDesc(w->pWare, m_iLanguage);
 			if ( !name.empty() )
-				writeData.push_back(CyString("		<t id=\"") + (long)(w->iText + 3) + "\">" + this->ConvertTextString(name) + "</t>");
+				writeData.push_back(Utils::String("		<t id=\"") + (long)(w->iText + 3) + "\">" + this->ConvertTextString(name) + "</t>");
 			if ( !desc.empty() )
-				writeData.push_back(CyString("		<t id=\"") + (long)(w->iText + 4) + "\">" + this->ConvertTextString(desc) + "</t>");
+				writeData.push_back(Utils::String("		<t id=\"") + (long)(w->iText + 4) + "\">" + this->ConvertTextString(desc) + "</t>");
+		}
 		for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
+		{
 			SGameShip *s = node->Data();
 			if ( !s->pPackage || s->iType != WARETYPE_ADDED )
 				continue;
 			Utils::String name = s->pPackage->GetTextName(m_iLanguage);
 			Utils::String desc = s->pPackage->GetTextDescription(m_iLanguage);
 			if ( !name.empty() )
-				writeData.push_back(CyString("		<t id=\"") + (long)s->iText + "\">" + this->ConvertTextString(name) + "</t>");
+				writeData.push_back(Utils::String("		<t id=\"") + (long)s->iText + "\">" + this->ConvertTextString(name) + "</t>");
 			if ( !desc.empty() )
-				writeData.push_back(CyString("		<t id=\"") + (long)(s->iText + 1) + "\">" + this->ConvertTextString(desc) + "</t>");
+				writeData.push_back(Utils::String("		<t id=\"") + (long)(s->iText + 1) + "\">" + this->ConvertTextString(desc) + "</t>");
 		}
-		writeData.push_back(CyString("  </page>"));
+		writeData.push_back("  </page>");
 	}
-	writeData.push_back(CyString("</language>"));
+	writeData.push_back("</language>");
-	textFile.WriteFileUTF(&writeData);
+	textFile.writeFileUTF(&writeData);
 	size_t fileSize;
 	char *fileData = CFileIO(textFile.fullFilename()).ReadToData(&fileSize);
 	if ( fileData && fileSize)
 bool CPackages::isCurrentDir(const Utils::String &dir) const
+{
 	Utils::String cur = m_sCurrentDir;
 	if ( dir.Compare(cur) )
 		return true;
 	Utils::String checkDir = cur;
 	checkDir = checkDir.findReplace("/", "\\");
 	if ( checkDir.Compare(dir) )
 		return true;
 	checkDir = checkDir.findReplace("\\", "/");
 	if ( checkDir.Compare(dir) )
 		return true;
 	return false;
 }
 void CPackages::backupSaves(bool vanilla)
+{
 	if (!_sSaveDir.empty())
+	{
 		// copy any saves into the vanilla directory
 		Utils::String dir = (vanilla) ? "Vanilla" : "Modified";
 		// make sure the directory exists
 		CDirIO saveDir(this->saveDirectory());
 		CDirIO gameSaveDir(saveDir.dir(_sSaveDir));
 		if (!gameSaveDir.exists())
-			gameSaveDir.Create();
+			gameSaveDir.create();
 		if (!gameSaveDir.exists(dir))
-			gameSaveDir.Create(dir);
+			gameSaveDir.create(dir);
 		gameSaveDir.cd(dir);
 		// backup the saves
 		Utils::CStringList files;
 		if(saveDir.dirList(files, Utils::String::Null(), "*.sav"))
+		{
 			for(auto itr = files.begin(); itr != files.end(); ++itr)
+			{
 				CFileIO File(saveDir.file((*itr)->str));
-				if (!File.CheckFileExtension("sav"))
+				if (!File.isFileExtension("sav"))
 					continue;
 				// remove the file if already exists
 				if (gameSaveDir.exists((*itr)->str))
 					CFileIO::Remove(gameSaveDir.file((*itr)->str));
 					for (SStringList *node = files->Head(); node; node = node->next)
+					{
 						CFileIO saveFile(toDir.File(node->str));
 						if (saveFile.extension().Compare("sav")) {
 							saveFile.remove();
 						}
 					}
 					delete files;
+				}
+			}
 			*/
 			// now we copy of the backed up save games
 			Utils::CStringList files;
 			if(restoreDir.dirList(files, Utils::String::Null(), "*.sav"))
 			{
 				for(auto itr = files.begin(); itr != files.end(); itr++)
+				{
 					CFileIO File(restoreDir.file((*itr)->str));
 					// remove the file if already exists
 					if (toDir.exists((*itr)->str)) CFileIO::Remove(toDir.file((*itr)->str));
 	this->Reset();
 	m_bLoaded = false;
 	// clear the plugin manager directory
 	CDirIO Dir(m_sCurrentDir);
-	Dir.RemoveDir("PluginManager", true, true, 0);
+	Dir.removeDir("PluginManager", true, true, 0);
-	Dir.RemoveDir("dds", false, true, 0);
+	Dir.removeDir("dds", false, true, 0);
-	Dir.RemoveDir("objects", false, true, 0);
+	Dir.removeDir("objects", false, true, 0);
-	Dir.RemoveDir("types", false, true, 0);
+	Dir.removeDir("types", false, true, 0);
-	Dir.RemoveDir("textures", false, true, 0);
+	Dir.removeDir("textures", false, true, 0);
 	// remove the plugin manager mod files
 	if ( Dir.exists("mods/PluginManager.cat") )	CFileIO::Remove(Dir.file("mods/PluginManager.cat"));
 	if ( Dir.exists("mods/PluginManager.dat") )	CFileIO::Remove(Dir.file("mods/PluginManager.dat"));
+	{
 		// read the dummies
 		CFileIO File;
 		if ( File.open((e == -1) ? "Dummies.txt" : m_sTempDir + "/Dummies.txt") )
+		{
-			std::vector<CyString> *lines = File.ReadLines();
+			std::vector<Utils::String> *lines = File.readLines();
 			if ( lines )
+			{
 				int insection = 0;
 				SDummyEntry *currentSection = NULL;
 				for ( int j = 0; j < (int)lines->size(); j++ )
+				{
-					CyString line(lines->at(j));
+					Utils::String line(lines->at(j));
-					line.RemoveChar(9);
+					line.removeChar(9);
-					line.RemoveChar('\r');
+					line.removeChar('\r');
-					line.RemoveFirstSpace();
+					line.removeFirstSpace();
-					line.RemoveEndSpace();
+					line.removeEndSpace();
-					if ( line.Empty() )
+					if ( line.empty() )
 						continue;
 					if ( line[0] == '/' )
 						continue;
 					// read the section, first entry is section, second is size
-					while ( !line.Empty() )
+					while ( !line.empty() )
+					{
 						if ( !insection )
+						{
-							CyString section = line.GetToken(";", 1, 1);
+							CyString section = line.token(";", 1);
-							insection = line.GetToken(";", 2, 2).ToInt();
+							insection = line.token(";", 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.DelToken(";", 1, 2);
+							line = line.remTokens(";", 1, 2);
+						}
 						else
+						{
 							--insection;
 							// check the last entry for number of states
 							if ( currentSection->sSection.Compare("SDTYPE_GUN") )
+							{
-								int states = line.GetToken(";", 3, 3).ToInt();
+								int states = line.token(";", 3).toInt();
-								int parts = line.GetToken(";", 4 + (states * 2), 4 + (states * 2)).ToInt();
+								int parts = line.token(";", 4 + (states * 2)).toInt();
-								CyString data = line.GetToken(";", 1, 4 + (states * 2) + (parts * 2)) + ";";
+								Utils::String data = line.tokens(";", 1, 4 + (states * 2) + (parts * 2)) + ";";
-								currentSection->lEntries.PushBack(data);
+								currentSection->lEntries.PushBack(CyString(data));
 								// remove done
-								line = line.DelToken(";", 1, 4 + (states * 2) + (parts * 2));
+								line = line.remTokens(";", 1, 4 + (states * 2) + (parts * 2));
+							}
 							else
+							{
-								int states = line.GetToken(";", 3, 3).ToInt();
+								int states = line.token(";", 3).toInt();
-								CyString data = line.GetToken(";", 1, 3 + (states * 2)) + ";";
+								Utils::String data = line.tokens(";", 1, 3 + (states * 2)) + ";";
-								currentSection->lEntries.PushBack(data);
+								currentSection->lEntries.PushBack(CyString(data));
 								// remove done
-								line = line.DelToken(";", 1, 3 + (states * 2));
+								line = line.remTokens(";", 1, 3 + (states * 2));
+							}
+						}
+					}
+				}
 				found->lEntries.PushBack(CyString(dummy->sData));
+			}
+		}
 		// finally, write the file
-		std::vector<CyString> lines;
+		std::vector<Utils::String> lines;
-		lines.push_back(CyString("// Dummies file, created by SPK Libraries V") + CyString::CreateFromFloat(GetLibraryVersion(), 2));
+		lines.push_back("// Dummies file, created by SPK Libraries V" + Utils::String::FromFloat(GetLibraryVersion(), 2));
 		for ( SDummyEntry *dummy = dummyList.First(); dummy; dummy = dummyList.Next() )
+		{
 			lines.push_back("");
-			lines.push_back(CyString("// Section: ") + dummy-&gt;sSection + " Entries: " + (long)dummy->lEntries.Count());
+			lines.push_back("// Section: " + dummy-&gt;sSection.ToString() + " Entries: " + Utils::String::Number((long)dummy->lEntries.Count()));
-			lines.push_back(dummy->sSection + ";" + CyString::Number(dummy->lEntries.Count()) + ";");
+			lines.push_back(dummy->sSection.ToString() + ";" + Utils::String::Number(dummy->lEntries.Count()) + ";");
 			for ( SStringList *str = dummy->lEntries.Head(); str; str = str->next )
+			{
-				CyString strLine = str->str;
+				Utils::String strLine = str->str.ToString();
-				strLine.RemoveChar(9);
+				strLine.removeChar(9);
-				strLine.RemoveChar('\r');
+				strLine.removeChar('\r');
-				strLine.RemoveEndSpace();
+				strLine.removeEndSpace();
-				strLine.RemoveFirstSpace();
+				strLine.removeFirstSpace();
-				strLine = strLine.FindReplace("<::PiPe::>", "|");
+				strLine = strLine.findReplace("<::PiPe::>", "|");
-				if ( strLine.Right(1) != ";" )
+				if ( strLine.right(1) != ";" )
 					strLine += ";";
 				lines.push_back(strLine);
+			}
+		}
 		lines.push_back("");
 		// write the file to disk
 		CFileIO WriteFile(m_sTempDir + "/dummies.txt");
-		if ( WriteFile.WriteFile(&lines) )
+		if ( WriteFile.writeFile(&lines) )
+		{
 			this->PackFile(&WriteFile, "types\\dummies.pck");
 			WriteFile.remove();
+		}
+	}
 	// 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;
 	CyStringList cutList;
 	int e = ExtractGameFile("types/CutData.pck", m_sTempDir + "/CutData.txt");
 	if ( e )
 	{
 		CFileIO File;
 		if ( File.open((e == -1) ? "CutData.txt" : m_sTempDir + "/CutData.txt") )
+		{
-			std::vector<CyString> *lines = File.ReadLines();
+			std::vector<Utils::String> *lines = File.readLines();
 			if ( lines )
+			{
 				int entries = -1;
 				for ( int j = 0; j < (int)lines->size(); j++ )
+				{
-					CyString line(lines->at(j));
+					Utils::String line(lines->at(j));
-					line.RemoveChar(9);
+					line.removeChar(9);
-					line.RemoveChar('\r');
+					line.removeChar('\r');
-					line.RemoveChar(' ');
+					line.removeChar(' ');
-					if ( line.Empty() || line[0] == '/' )
+					if ( line.empty() || line[0] == '/' )
 						continue;
 					if ( entries == -1 )
-						entries = line.GetToken(";", 1, 1).ToInt();
+						entries = line.token(";", 1).toInt();
 					else
+					{
-						if ( line.Right(1) != ";" )
+						if ( line.right(1) != ";" )
 							line += ";";
-						cutList.PushBack(line);
+						cutList.PushBack(CyString(line));
 						if ( cutList.Count() == entries )
 							break;
+					}
+				}
 				delete lines;
+			}
 			File.remove();
+		}
+	}
 	for ( CListNode<SGameShip> *node = m_lGameShips.Front(); node; node = node->next() )
 	// write the file to disk
 	CFileIO WriteFile(m_sTempDir + "/CutData.txt");
 	if ( WriteFile.WriteFile(&cutList) )
+	{
 		this->PackFile(&WriteFile, "types\\CutData.pck");
 		WriteFile.remove();
+	}
+}
 void CPackages::CreateAnimations()
+{
 	if ( e )
+	{
 		CFileIO File;
 		if ( File.open((e == -1) ? "Animations.txt" : m_sTempDir + "/Animations.txt") )
+		{
-			std::vector<CyString> *lines = File.ReadLines();
+			std::vector<Utils::String> *lines = File.readLines();
 			if ( lines )
+			{
 				for ( int j = 0; j < (int)lines->size(); j++ )
+				{
-					CyString line(lines->at(j));
+					Utils::String line(lines->at(j));
-					aniList.PushBack(line);
+					aniList.PushBack(CyString(line));
+				}
 				delete lines;
+			}
 	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;
 		CyString line = strNode->str.GetToken("//", 1, 1);
 		// split into seperate lines
 		CyString first = line.GetToken(";", 1, 1);
 		if ( first.Compare("TAT_TAGSINGLESTEP") )
 		{
 			formatedAniList.PushBack(line.GetToken(";", 1, 5) + ";");
 			int max;
 			CyString *sLines = line.GetToken(";", 6).SplitToken(";", &max);
 			if ( max && sLines )
 			{
 				if ( sLines[max - 1].Empty() )
 					--max; // remove the last ";"
 				for ( int i = 0; i < max; i++ )
+				{
 					CyString l = CyString("\t") + sLines[i] + ";";
 					if ( i == (max - 1) )
 						formatedAniList.PushBack(l + comment);
 					else
 						formatedAniList.PushBack(l);
 				}
 			}
 			CLEANSPLIT(sLines, max);
 		}
 		else if ( (first.Compare("TAT_TAGONESHOT") || first.Compare("TAT_TAGLOOP")) && (line.IsIn("TATF_COORDS")) )
+		{
 			formatedAniList.PushBack(line.GetToken(";", 1, 5) + ";");
 			int max;
 			CyString *sLines = line.GetToken(";", 6).SplitToken(";", &max);
 			formatedAniList.PushBack(line + comment);
+	}
 	formatedAniList.PushFront(CyString::Number(parsedAniList.Count()) + ";");
 	formatedAniList.PushFront(CyString("// Animations, created by SPK Libraries V") + CyString::CreateFromFloat(GetLibraryVersion(), 2));
 	// write the file to disk
 	CFileIO WriteFile(m_sTempDir + "/Animations.txt");
 	if ( WriteFile.WriteFile(&formatedAniList) )
+	{
 		this->PackFile(&WriteFile, "types\\Animations.pck");
 	if ( e )
+	{
 		CFileIO File;
 		if ( File.open((e == -1) ? "Bodies.txt" : m_sTempDir + "/Bodies.txt") )
+		{
-			std::vector<CyString> *lines = File.ReadLines();
+			std::vector<Utils::String> *lines = File.readLines();
 			if ( lines )
+			{
 				int entries = 0;
 				for ( int j = 0; j < (int)lines->size(); j++ )
+				{
-					CyString line(lines->at(j));
+					Utils::String line(lines->at(j));
-					line.RemoveChar(' ');
+					line.removeChar(' ');
-					line.RemoveChar(9);
+					line.removeChar(9);
-					if ( line.Empty() || line[0] == '/' )
+					if ( line.empty() || line[0] == '/' )
 						continue;
 					if ( entries <= 0 )
+					{
-						entries = line.GetToken(";", 2, 2).ToInt();
+						entries = line.token(";", 2).toInt();
 						currentSection = new SBodies;
-						currentSection->sSection = line.GetToken(";", 1, 1);
+						currentSection->sSection = line.token(";", 1);
 						bodiesList.push_back(currentSection);
+					}
 					else if ( currentSection )
+					{
 						int num;
-						CyString *strs = line.SplitToken(";", &num);
+						Utils::String *strs = line.tokenise(";", &num);
 						if ( num && strs )
+						{
 							for ( int i = 0; i < num; i++ )
+							{
-								if ( strs[i].Empty() )
+								if ( strs[i].empty() )
 									continue;
+								if(!currentSection->lEntries.contains(strs[i] + ";"))
-								currentSection->lEntries.PushBack(strs[i] + ";", true);
+									currentSection->lEntries.pushBack(strs[i] + ";");
 								--entries;
+							}
+						}
 						CLEANSPLIT(strs, num);
+					}
 			// 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) )
+				if ( checkBody->Data()->sSection.Compare(section.ToString()))
+				{
 					foundSection = checkBody->Data();
 					break;
+				}
+			}
 			if ( !foundSection )
+			{
 				foundSection = new SBodies;
-				foundSection->sSection = section;
+				foundSection->sSection = section.ToString();
 				bodiesList.push_back(foundSection);
+			}
+			if(!foundSection->lEntries.contains(body.ToString()))
-			foundSection->lEntries.PushBack(body, true);
+				foundSection->lEntries.pushBack(body.ToString());
+		}
+	}
 	// now write the file
-	CyStringList writeList;
+	std::vector<Utils::String> writeList;
 	// the header first
-	writeList.PushBack(CyString("// Bodies file, created by SPK Libraries V") + CyString::CreateFromFloat(GetLibraryVersion(), 2));
+	writeList.push_back("// Bodies file, created by SPK Libraries V" + Utils::String::FromFloat(GetLibraryVersion(), 2));
-	writeList.PushBack("//body type;num bodies;");
+	writeList.push_back("//body type;num bodies;");
-	writeList.PushBack("//[body id/name]");
+	writeList.push_back("//[body id/name]");
 	// now our sections
 	for ( SBodies *bSection = bodiesList.First(); bSection; bSection = bodiesList.Next() )
+	{
-		writeList.PushBack("");
+		writeList.push_back("");
-		writeList.PushBack(CyString("// Section: ") + bSection->sSection);
+		writeList.push_back("// Section: " + bSection->sSection);
-		writeList.PushBack(bSection->sSection + ";" + CyString::Number(bSection->lEntries.Count()) + ";");
+		writeList.push_back(bSection->sSection + ";" + Utils::String::Number(bSection->lEntries.size()) + ";");
-		for ( SStringList *strNode = bSection->lEntries.Head(); strNode; strNode = strNode->next )
+		for(auto itr = bSection->lEntries.begin(); itr != bSection->lEntries.end(); itr++)
+		{
-			CyString str = strNode->str;
+			Utils::String str = (*itr)->str;
-			str.RemoveChar(9);
+			str.removeChar(9);
-			str.RemoveChar(' ');
+			str.removeChar(' ');
-			if ( str.Right(1) != ";" )
+			if ( str.right(1) != ";" )
 				str += ";";
-			writeList.PushBack(str);
+			writeList.push_back(str);
+		}
+	}
 	// write the file to disk
 	CFileIO WriteFile(m_sTempDir + "/Bodies.txt");
-	if ( WriteFile.WriteFile(&writeList) )
+	if ( WriteFile.writeFile(&writeList) )
+	{
 		this->PackFile(&WriteFile, "types\\Bodies.pck");
 		WriteFile.remove();
 	}
 }
 void CPackages::CreateCustomStarts()
+{
 	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
+	{
 		// find all spk files (only ones that can be custom starts
 		if ( node->Data()->GetType() != TYPE_SPK )
 			continue;
 		CSpkFile *p = (CSpkFile *)node->Data();
 		// only use custom starts
 		if ( !p->IsCustomStart() )
 			continue;
 		// get the name of the start to use
 		CyString name = p->GetCustomStartName();
 		if ( name.Empty() )
 			continue;
 					CFileIO File((e == -1) ? (str->data + ".pck") : (m_sTempDir + "/" + str->data.ToString() + ".pck"));
 					if ( File.exists() )
+					{
 						File.Rename(m_sCurrentDir + "/" + dir + "/" + str->str.ToString() + ".pck");
 						this->AddCreatedFile(dir + "/" + str->str.ToString() + ".pck");
 					}
 				}
 			}
 		}
 	}
 }
-void CPackages::AddCreatedFile(CyString file)
+void CPackages::AddCreatedFile(CyString sFile)
 {
+	Utils::String file = sFile.ToString();
-	file = file.Remove(m_sCurrentDir);
+	file = file.findRemove(m_sCurrentDir);
 	while ( file[0] == '/' )
-		file.Erase(0, 1);
+		file.erase(0, 1);
 	while ( file[0] == '\\' )
-		file.Erase(0, 1);
+		file.erase(0, 1);
+	if(!m_lCreatedFiles.contains(file, true))
-	m_lCreatedFiles.PushBack(file, true);
+		m_lCreatedFiles.pushBack(file);
+}
 void CPackages::CreateComponants()
+{
 	// first check we have any ships
+	{
 		// read the dummies
 		CFileIO File;
 		if ( File.open((e == -1) ? "Components.txt" : m_sTempDir + "/Components.txt") )
+		{
-			std::vector<CyString> *lines = File.ReadLines();
+			std::vector<Utils::String> *lines = File.readLines();
 			if ( lines )
+			{
 				int insection = 0;
 				int insubsection = 0;
 				SComponantEntry *currentSection = NULL;
 				SComponantEntry2 *currentSubSection = NULL;
 				for ( int j = 0; j < (int)lines->size(); j++ )
+				{
-					CyString line(lines->at(j));
+					Utils::String line(lines->at(j));
 					if ( line[0] == '/' )
 						continue;
-					line.RemoveChar('\r');
+					line.removeChar('\r');
-					line = line.RemoveFirstSpace();
+					line = line.removeFirstSpace();
-					line = line.RemoveEndSpace();
+					line = line.removeEndSpace();
-					if ( line.Empty() )
+					if ( line.empty() )
 						continue;
 					// read the section, first entry is section, second is size
-					while ( !line.Empty() )
+					while ( !line.empty() )
+					{
-						line = line.RemoveFirstSpace();
+						line = line.removeFirstSpace();
-						if ( line.Empty() )
+						if ( line.empty() )
 							break;
 						if ( !insection && !insubsection )
+						{
-							CyString section = line.GetToken(";", 1, 1);
+							Utils::String section = line.token(";", 1);
-							insection = line.GetToken(";", 2, 2).ToInt();
+							insection = line.token(";", 2).toInt();
 							// search for the sections
 							currentSection = NULL;
 							for ( CListNode<SComponantEntry> *node = dummyList.Front(); node; node = node->next() )
+							{
 								SComponantEntry *d = node->Data();
-								if ( d->sSection.Compare(section) )
+								if ( d->sSection.Compare(CyString(section)) )
+								{
 									currentSection = node->Data();
 									break;
+								}
+							}
 								currentSection->sSection = section;
 								dummyList.push_back(currentSection);
+							}
 							// we have some more ?
-							line = line.DelToken(";", 1, 2);
+							line = line.remTokens(";", 1, 2);
 						}
 						else if ( !insubsection )
+						{
 							--insection;
-							CyString section = line.GetToken(";", 1, 1);
+							Utils::String section = line.token(";", 1);
-							insubsection = line.GetToken(";", 2, 2).ToInt();
+							insubsection = line.token(";", 2).toInt();
 							currentSubSection = new SComponantEntry2;
 							currentSubSection->sSection = section;
 							currentSection->lEntries.push_back(currentSubSection);
-							line = line.DelToken(";", 1, 2);
+							line = line.remTokens(";", 1, 2);
+						}
 						else
+						{
 							--insubsection;
-							currentSubSection->lEntries.PushBack(line.Remove(' '), true);
+							currentSubSection->lEntries.PushBack(CyString(line.remove(' ')), true);
 							line = "";
+						}
+					}
+				}
 				found2->lEntries.PushBack(CyString(dummy->sData.remove(' ')));
+			}
+		}
 		// finally, write the file
-		std::vector<CyString> lines;
+		std::vector<Utils::String> lines;
-		lines.push_back(CyString("// Components file, created by SPK Libraries V") + CyString::CreateFromFloat(GetLibraryVersion(), 2));
+		lines.push_back("// Components file, created by SPK Libraries V" + Utils::String::FromFloat(GetLibraryVersion(), 2));
 		for ( SComponantEntry *dummy = dummyList.First(); dummy; dummy = dummyList.Next() )
+		{
 			lines.push_back("");
-			lines.push_back(CyString("// Section: ") + dummy-&gt;sSection + " Entries: " + (long)dummy->lEntries.size());
+			lines.push_back("// Section: " + dummy-&gt;sSection.ToString() + " Entries: " + Utils::String::Number((long)dummy->lEntries.size()));
-			lines.push_back(dummy->sSection + ";" + CyString::Number(dummy->lEntries.size()) + ";");
+			lines.push_back(dummy->sSection.ToString() + ";" + Utils::String::Number(dummy->lEntries.size()) + ";");
 			for ( CListNode<SComponantEntry2> *comp = dummy->lEntries.Front(); comp; comp = comp->next() )
+			{
-				lines.push_back(comp->Data()->sSection + ";&quot; + (long)comp->;Data()->lEntries.Count() + ";");
+				lines.push_back(comp->Data()->sSection.ToString() + ";&quot; + Utils::String::Number((long)comp->;Data()->lEntries.Count()) + ";");
 				for ( SStringList *str = comp->Data()->lEntries.Head(); str; str = str->next )
+				{
-					CyString cStr = str->str;
+					Utils::String cStr = str->str.ToString();
-					cStr.RemoveEndSpace();
+					cStr.removeEndSpace();
-					cStr.RemoveChar(9);
+					cStr.removeChar(9);
-					cStr.RemoveChar('\r');
+					cStr.removeChar('\r');
-					if ( cStr.Right(1) != ";" )
+					if ( cStr.right(1) != ";" )
 						cStr += ";";
 					lines.push_back(cStr);
+				}
+			}
+		}
 		// write the file to disk
 		CFileIO WriteFile(m_sTempDir + "/Components.txt");
-		if ( WriteFile.WriteFile(&lines) )
+		if ( WriteFile.writeFile(&lines) )
+		{
 			this->PackFile(&WriteFile, "types\\Components.pck");
 			WriteFile.remove();
+		}
+	}
 bool CPackages::readWares(int iLang, CLinkList<SWareEntry> &list)
+{
 	if ( iLang == 0 ) iLang = m_iLanguage;
 	Utils::String empWares = this->empWaresForGame();
 	for(CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next()) {
 		if ( !node->Data()->IsEnabled() ) continue;
 		node->Data()->readWares(iLang, list, empWares);
+	}
+	{
 		CFileIO File((e == -1) ? "Globals.txt" : m_sTempDir + "/Globals.txt");
 		if ( File.exists() )
+		{
 			CyStringList *lines = File.ReadLinesStr();
 			if ( lines )
+			{
 				int entries = -1;
 				for ( SStringList *str = lines->Head(); str; str = str->next )
+				{
 					str->str.RemoveChar('\r');
 				delete lines;
 				return true;
+			}
 		}
 	}
 	return false;
+}
 void CPackages::CreateGlobals()
+{
-	if ( m_lGlobals.Empty() )
+	if ( m_lGlobals.empty() )
 		return; // no global settings
 	CyStringList globals;
 	if ( ReadGlobals(globals) )
+	{
 		// apply out settings
-		for ( SStringList *str = m_lGlobals.Head(); str; str = str->;next )
+		for(auto itr = m_lGlobals.begin(); itr != m_lGlobals.end(); itr++)
+		{
-			SStringList *found = globals.FindString(str->str);
+			SStringList *found = globals.FindString((*itr)->str);
 			if ( found )
-				found->data = str->data;
+				found->data = (*itr)->data;
 		}
 		// now write it
 		CyStringList writeList;
 		for ( SStringList *str = globals.Head(); str; str = str->next )
 			writeList.PushBack(str->str + ";" + str->data + ";");
 		CFileIO WriteFile(m_sTempDir + "/Globals.txt");
 		if ( WriteFile.WriteFile(&writeList) )
+		{
 			this->PackFile(&WriteFile, "types/Globals.pck");
 			WriteFile.remove();
 		}
 	}
+}
 void CPackages::CreateTShips()
+{
 	// no ships ?
 	if ( m_lGameShips.empty() )
 		return;
 	// get the cockpit list to match with ships turrets
 	CyStringList Cockpits;
 	CyStringList *cockpitList = this->CreateCockpits();
 	if ( cockpitList )
+	{
 	int e = ExtractGameFile("types/TShips.pck", m_sTempDir + "/TShips.txt");
 	if ( e )
+	{
 		int fileType = 51;
 		CyStringList tshipsList;
 		// if we have no buffer, lets create one
 		CFileIO File;
 		if ( File.open((e == -1) ? "TShips.txt" : m_sTempDir + "/TShips.txt") )
+		{
 			int shiptext = SHIPSTARTTEXT;
-			std::vector<CyString> *lines = File.ReadLines();
+			std::vector<Utils::String> *lines = File.readLines();
 			if ( lines )
+			{
 				int count = -1;
 				for ( int j = 0; j < (int)lines->size(); j++ )
+				{
-					CyString line(lines->at(j));
+					Utils::String line(lines->at(j));
 					if ( line[0] == '/' )
 						continue;
-					line.RemoveChar('\r');
+					line.removeChar('\r');
-					line.RemoveChar(9);
+					line.removeChar(9);
-					line = line.RemoveFirstSpace();
+					line = line.removeFirstSpace();
-					line = line.RemoveEndSpace();
+					line = line.removeEndSpace();
-					if ( line.Empty() )
+					if ( line.empty() )
 						continue;
 					if ( count == -1 )
 					{
-						fileType = line.GetToken(";", 1, 1).ToInt();
+						fileType = line.token(";", 1).toInt();
-						count = line.GetToken(";", 2, 2).ToInt();
+						count = line.token(";", 2).toInt();
+					}
 					else
+					{
-						if ( line.Right(1) != ";" )
+						if ( line.right(1) != ";" )
 							line += ";";
 						// check for any ship overrides
 						bool added = false;
 						if ( !shipOverrides.empty() )
+								}
+							}
+						}
 						if ( !added )
-							tshipsList.PushBack(line);
+							tshipsList.PushBack(CyString(line));
 						--count;
 						if ( count < 0 )
 							break;
+					}
+				}
+	{
 		size_t newFileSize;
 		unsigned char *pckData = PCKData((unsigned char *)fileData, fileSize, &newFileSize, true);
 		if ( pckData )
+		{
-			CyString ext = "pck";
+			Utils::String ext = "pck";
-			if ( File.CheckFileExtension("bob") )
+			if ( File.isFileExtension("bob") )
 				ext = "pbb";
-			else if ( File.CheckFileExtension("bod") )
+			else if ( File.isFileExtension("bod") )
 				ext = "pbd";
-			CFileIO pckFile(File.ChangeFileExtension(ext));
+			CFileIO pckFile(File.changeFileExtension(ext));
 			if ( !CDirIO(pckFile.dir()).exists() )
-				CDirIO(pckFile.dir()).Create();
+				CDirIO(pckFile.dir()).create();
 			pckFile.WriteData((char *)pckData, newFileSize);
 			return true;
+		}
+	}
 		if ( !pckData )
 			pckData = UnPCKData((unsigned char *)fileData, fileSize, &newFileSize, true);
 		if ( pckData )
+		{
-			CyString ext = "txt";
+			Utils::String ext = "txt";
-			if ( File.CheckFileExtension("pbb") )
+			if ( File.isFileExtension("pbb") )
 				ext = "bob";
-			else if ( File.CheckFileExtension("pbd") )
+			else if ( File.isFileExtension("pbd") )
 				ext = "bod";
-			CFileIO pckFile(File.ChangeFileExtension(ext));
+			CFileIO pckFile(File.changeFileExtension(ext));
 			if ( !CDirIO(pckFile.dir()).exists() )
-				CDirIO(pckFile.dir()).Create();
+				CDirIO(pckFile.dir()).create();
 			pckFile.WriteData((char *)pckData, newFileSize);
 			// check for xml and rename
 			if ( checkxml )
+			{
+			{
 //				if ( !this->GetAddonDir().Empty() && CCatFile::IsAddonDir(filename) )
 //					filename = this->GetAddonDir() + "/" + filename;
 				CFileIO pckFile(m_sCurrentDir + "/" + filename);
 				if ( !CDirIO(pckFile.dir()).exists() )
-					CDirIO(pckFile.dir()).Create();
+					CDirIO(pckFile.dir()).create();
 				pckFile.WriteData((char *)pckData, newFileSize);
 				this->AddCreatedFile(pckFile.fullFilename());
 				return true;
+			}
+		}
+{
 	CFileIO File;
 	bool deleteFile = false;
 	// load from cat file
-	if ( CFileIO(file).CheckFileExtension("cat") )
+	if ( CFileIO(file).isFileExtension("cat") )
+	{
 		CCatFile cat;
 		if ( cat.open(file.ToString(), this->getAddonDir(), CATREAD_CATDECRYPT, false) != CATERR_NONE )
 			return false;
 		File.open(m_sTempDir + "/tships.txt");
 		deleteFile = true;
+	}
 	// otherwise its a normal file
-	else if ( CFileIO(file).CheckFileExtension("pck") )
+	else if ( CFileIO(file).isFileExtension("pck") )
+	{
 		C_File f(file.ToString());
 		if ( !f.ReadFromFile() )
 			return false;
 		f.UnPCKFile();
+{
 	CFileIO File;
 	bool deleteFile = false;
 	// read all text files from mod
-	if ( CFileIO(file).CheckFileExtension("cat") )
+	if ( CFileIO(file).isFileExtension("cat") )
+	{
 		bool done = false;
 		CCatFile cat;
 		if ( cat.open(file.ToString(), this->getAddonDir(), CATREAD_CATDECRYPT, false) != CATERR_NONE )
+		}
 		return done;
+	}
 	// otherwise its a normal file
-	else if ( CFileIO(file).CheckFileExtension("pck") )
+	else if ( CFileIO(file).isFileExtension("pck") )
+	{
 		C_File f(file.ToString());
 		if ( !f.ReadFromFile() )
 			return false;
 		f.UnPCKFile();
 int CPackages::AdjustFileType(CyString file, int filetype)
+{
 	CFileIO File(file);
 	Utils::String dir = File.GetDirIO().topDir();
 	CyString basename = File.baseName();
+	Utils::String ext = File.extension();
 	// mod files
-	if ( File.CheckFileExtension("cat") || File.CheckFileExtension("dat") )
+	if (ext.Compare("cat") || ext.Compare("dat"))
 		return FILETYPE_MOD;
 	// check for text files
 	if ( File.filename().isin("-L") && File.filename().left(4).isNumber() )
 		return FILETYPE_TEXT;
 	if ( File.baseName().Compare("conversations") )
 		return FILETYPE_TEXT;
-	if ( basename.Length() <= 4 && basename.IsNumber() && (File.CheckFileExtension("xml") || File.CheckFileExtension("pck")) )
+	if ( basename.Length() <= 4 && basename.IsNumber() && (File.isFileExtension("xml") || File.isFileExtension("pck")) )
 		return FILETYPE_TEXT;
 	// X2/X3 text file
 	if ( basename.Length() >= 5 && basename.Length() <= 8 && ((int)File.baseName()) )
 		return FILETYPE_TEXT;
 	if ( filetype == FILETYPE_TEXT ) // should no longer be anything text
 		return FILETYPE_SCRIPT;
-	if ( File.CheckFileExtension("wav") || File.CheckFileExtension("mp3") )
+	if ( File.isFileExtension("wav") || File.isFileExtension("mp3") )
 		return FILETYPE_SOUND;
 	return filetype;
 }
 void CPackages::RemoveFailedFiles()
+{
+	Utils::CStringList removed;
-	for ( SStringList *str = m_lNonRemovedFiles.Head(); str; str = str->next )
+	for (auto itr = m_lNonRemovedFiles.begin(); itr != m_lNonRemovedFiles.end(); itr++)
+	{
-		if ( CFileIO::Remove(str->str.ToString()) )
+		if (CFileIO::Remove((*itr)->str))
-			str->remove = true;
+			removed.pushBack((*itr)->str);
 	}
+	for (auto itr = removed.begin(); itr != removed.end(); itr++)
-	m_lNonRemovedFiles.RemoveMarked();
+		m_lNonRemovedFiles.remove((*itr)->str);
+}
 CXspFile *CPackages::extractShip(const Utils::String &sCatFile, const Utils::String &sId, CProgressInfo *progress)
+{
 	CVirtualFileSystem *pVfs = new CVirtualFileSystem();
 	if ( !pVfs->addMod(sCatFile) ) {
 		delete pVfs;
 		return NULL;
 	}
 	CXspFile *newShip = new CXspFile;
 	if ( !newShip->extractShip(pVfs, sId, progress) ) {
 		delete newShip;
 		newShip = NULL;
+	}
 	delete pVfs;
 	return newShip;
 }
 void CPackages::getMergedFiles(Utils::CStringList &list, CCatFile *cat1, CCatFile *cat2)
+{
 	// first add all files from the "primary" mod
 	for (auto itr = cat1->GetFiles()->cbegin(); itr != cat1->GetFiles()->cend(); itr++)
+			{
 				if ( !newCat.WriteFromCat(mod1, (*itr)->str) )
+				{
 					if ( cantMerge )
 						cantMerge->PushBack(CyString((*itr)->str), "1");
 				}
 			}
+		}
+	}
 	/*
 		Merging Files
 		* Text Files: Join all text entries into a single file (excluding page 17)
 		* Weapons: TBullets and TLaser (grab matching entrys from text files and adjust ids)
 	*/
 	// new merge the conflicting files
 	// first the text files
 	if ( !newCat.WriteCatFile() )
 		return false;
 	return true;
+}
 /**
  * Gets the file list from a mod that might have compatability problems
+ *
  * This includes all types and text files
+ *
 	// we need to read the file list for the mod
 	CCatFile cat;
 	if ( cat.open(file->filePointer(), this->getAddonDir(), CATREAD_JUSTCONTENTS, false) == CATERR_NONE )
+	{
 		for (unsigned int i = 0; i < cat.GetNumFiles(); i++ )
 		{
 			SInCatFile *f = cat.GetFile(i);
 			CyString filename = f->sFile;
 			filename = filename.FindReplace("\\", "/");
 			bool found = false;
 			if ( filename.Left(2).Compare("t/") || filename.Left(6).Compare("types/") )
 		if ( !f->IsFakePatch() ) continue;
 		if ( !f->CheckFileExt("cat") ) continue;
 		if ( newFile->ExtractFile(f, m_sTempDir) )
 			f->SetFullDir(m_sTempDir);
 	}
 	// compare mod files against all installed packages
 	int count = 0;
 	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
+	{
 		if ( !node->Data() ) continue;
 		CBaseFile *p = node->Data();
 		if ( !p->IsEnabled() ) continue;
 		if ( !p->AnyFileType(FILETYPE_MOD) ) continue;
 		if ( this->IsSamePackage(p, newFile) ) continue; // dont include self
 		if ( CheckCompatabilityBetweenMods(newFile, p, list) )
+		{
 			++count;
 			if ( packages && !packages->FindData(p) )
 				packages->push_back(p);
+	{
 		C_File *f = fNode->Data();
 		CFileIO::Remove(f->filePointer());
 		f->SetFullDir("");
+	}
 	return count;
+}
 bool CPackages::IsSamePackage(CBaseFile *p1, CBaseFile *p2)
 {
 	if ( !p1 || !p2 ) return false;
 	if ( p1 == p2 ) return true;
 	if ( p1->name().Compare(p2->name()) && p1->author().Compare(p2->author()) )
 		return true;
 	return false;
+}
-void CPackages::ApplyFakePatchOrder(CyStringList *list)
+void CPackages::ApplyFakePatchOrder(Utils::CStringList *list)
+{
 	if ( !list ) return;
-	m_lFakePatchOrder.Clear();
+	m_lFakePatchOrder.clear();
-	for ( SStringList *str = list->;Head(); str; str = str->next )
+	for(auto itr = list->;begin(); itr != list->end(); itr++)
-		m_lFakePatchOrder.PushBack(str->str, str->data);
+		m_lFakePatchOrder.pushBack((*itr)->str, (*itr)->data);
+}
 SAvailablePackage *CPackages::CreateAvailablePackageData(CBaseFile *package)
+{
 	if ( !package ) return NULL;
 		File.close();
+	}
 	list->PushBack("http://xpluginmanager.co.uk/tcscripts", true);
 	list->PushBack("http://xpluginmanager.co.uk/apscripts", true);
+	list->PushBack("http://xpluginmanager.co.uk/flscripts", true);
 	return list->Count();
+}
 void CPackages::ReadArchiveData(CyString filename, CBaseFile *archive)
 	HeaderData.CmtBuf=NULL;
 	memset(&OpenArchiveData.Reserved,0,sizeof(OpenArchiveData.Reserved));
 	bool error = false;
-	CyString extractedFile = CDirIO(m_sTempDir).File("extracted.tst").findreplace("/", "\\").findreplace("\\\\", "\\");
+	Utils::String extractedFile = CDirIO(m_sTempDir).file("extracted.tst").findReplace("/", "\\").findReplace("\\\\", "\\");
 	while ((RHCode=RARReadHeaderEx(hArcData,&HeaderData))==0)
+	{
-		CyString fileName = HeaderData.FileName;
+		Utils::String fileName = HeaderData.FileName;
 		if ( HeaderData.FileAttr == 16 )
 			continue;
 		wchar_t wText[200];
-		::MultiByteToWideChar(CP_ACP, NULL, (char *)extractedFile.c_str(), -1, wText, extractedFile.Length() + 1);
+		::MultiByteToWideChar(CP_ACP, NULL, (char *)extractedFile.c_str(), -1, wText, extractedFile.length() + 1);
 		PFCode=RARProcessFileW(hArcData, RAR_EXTRACT, NULL, NULL);
 		if (PFCode!=0)
+		{
 			error = true;
 			break;
 CBaseFile *CPackages::CreateFromArchive(CyString filename, bool toInstall )
+{
 	// make sure we can open the zip file
 	CBaseFile *archive = NULL;
-	if ( CFileIO(filename).CheckFileExtension("rar") )
+	if ( CFileIO(filename).isFileExtension("rar") )
 		archive = this->_archive_fromRar(filename, toInstall);
-	else if ( CFileIO(filename).CheckFileExtension("zip") )
+	else if ( CFileIO(filename).isFileExtension("zip") )
 		archive = this->_archive_fromZip(filename, toInstall);
 	if ( archive ) {
-		archive->setFilename(CFileIO(filename).ChangeFileExtension("spk").ToString());
+		archive->setFilename(CFileIO(filename).changeFileExtension("spk"));
 		if ( toInstall )
 			archive->setName(CFileIO(filename).filename());
 		else
 			archive->setName(CFileIO(filename).baseName());
+	}
+	}
 	return Utils::String::Null();
+}
-int CPackages::GeneratePackageUpdateData(CyString dir, bool includeSingle)
+int CPackages::GeneratePackageUpdateData(const Utils::String &dir, bool includeSingle)
+{
 	Utils::CStringList filedata;
 	CPackages packages;
 				CBaseFile *p = packages.OpenPackage(Dir.file((*itr)->str), &error, 0, SPKREAD_NODATA);
 				if ( !p )
 					continue;
 				if ( includeSingle )
-					p->createUpdateFile(dir.ToString());
+					p->createUpdateFile(dir);
 				filedata.pushBack(CPackages::FormatAvailablePackageData(p));
 				delete p;
+			}
+		}
+	}

Subversion Repositories spk

(root)//libspk/src/Packages.cpp – Rev 158 → 160