ViewVC Help

View File | Revision Log | View Changeset | Root Listing

root/Oni2/AE/Installer/trunk/source/installer.cpp

Comparing AE/Installer/trunk/source/installer.cpp (file contents):
Revision 489 by gumby, Sun Jan 24 23:58:16 2010 UTC vs.
Revision 508 by gumby, Sat Apr 24 17:52:34 2010 UTC

#	Line 17 | Line 17
17		#include "boost/date_time/gregorian/gregorian.hpp"
18		#include "boost/date_time/date_parsing.hpp"
19		#include "boost/date_time/posix_time/posix_time.hpp"
20	+	#include <boost/algorithm/string.hpp>
21		#include "installer.h"
22		#include "aeinstallerapp.h"
23
#	Line 230 | Line 231 | int globalizeData(void)
231
232
233		if ( strcmp(levels[i].c_str(), "0") ){
234	<	system((strOniSplit + " -move:overwrite ../GameDataFolder/level" + levels[i] + "_Final ../GameDataFolder/level" + levels[i] + "_Final/AKEV/AKEV*.oni").c_str());
234	>	system((strOniSplit + " -move:overwrite ../GameDataFolder/level" + levels[i] + "_Final ../GameDataFolder/level" + levels[i] +
235	>	"_Final/AKEV/AKEV*.oni").c_str());
236		remove(  "../GameDataFolder/level" + levels[i] + "_Final/AKEV" );
237		}
238
#	Line 244 | Line 246 | int globalizeData(void)
246		for (int i = 0; i < 15; i++)
247		{
248		logfile << "\tReimporting level" << levels[i] << "_Final.oni\n";
249	<	setStatusArea("Step " + lexical_cast<std::string>(parts_done + 1) + "/" + lexical_cast<std::string>(total_steps) + " reimporting level" + levels[i]+"_Final.oni");
249	>	setStatusArea("Step " + lexical_cast<std::string>(parts_done + 1) + "/" + lexical_cast<std::string>(total_steps) + " reimporting level" +
250	>	levels[i] + "_Final.oni");
251		logfile << (strOniSplit + " " + strImportOption + " ../GameDataFolder/level" + levels[i] + "_Final VanillaDats/level" + levels[i] + "_Final/level"
252		+ levels[i] + "_Final/level" + levels[i] + "_Final.oni >> Globalize.log").c_str() << '\n';
253		string sys_str = (strOniSplit + " " + strImportOption + " ../GameDataFolder/level" + levels[i] + "_Final VanillaDats/level" + levels[i] + "_Final/level"
#	Line 269 | Line 272 | int globalizeData(void)
272		setStatusArea("Step " + lexical_cast<std::string>(parts_done + 1) + "/" + lexical_cast<std::string>(total_steps) + ": moving level0_Characters" );
273		copy((path)"../GameDataFolder/level0_Characters", (path)("VanillaDats/level0_Final"));
274		GDFPaths.push_back( Characters );
275	+	//concactates level0....
276		for(int i = 0; i < GDFPaths.size(); i++)
277		{
278		directory_iterator end_iter;
#	Line 283 | Line 287 | int globalizeData(void)
287		}
288		}
289		}
290	+	//?: syntax is fun.
291	+	//condition ? value_if_true : value_if_false
292	+	(is_empty(Characters)   ? remove( Characters )  : 1);
293	+	(is_empty(Particles)    ? remove( Particles )   : 1);
294	+	(is_empty(Textures)             ? remove( Textures )    : 1);
295	+	(is_empty(Sounds)               ? remove( Sounds )              : 1);
296	+	(is_empty(TRAC)                 ? remove( TRAC )                : 1);
297	+	(is_empty(TRAM)                 ? remove( TRAM )                : 1);
298	+	(is_empty(Animations)   ? remove( Animations )  : 1);
299
300		create_directory((path)"../GameDataFolder/IGMD");
301		copy((path)"packages/VanillaBSL/IGMD", (path)"../GameDataFolder");
302		setProgressBar( 1000 );
303	<
304	<	if(exists("../../persist.dat"))
305	<	if(!exists("../persist.dat"))
306	<
294	<	//TODO: Concatenate level0 Dirs.
295	<
296	<	copy("../../persist.dat","..");
297	<	if(exists("../../key_config.txt"))
298	<	if(!exists("../key_config.txt"))
299	<	copy("../../key_config.txt","..");
300	<
303	>
304	>	if(exists("../../persist.dat") && !exists("../persist.dat")) copy("../../persist.dat","..");
305	>	if(exists("../../key_config.txt")&& !exists("../key_config.txt")) copy("../../key_config.txt","..");
306	>
307		#ifndef WIN32
308		/* On Mac only, set the current GDF to the AE GDF by writing to Oni's global preferences file (thankfully a standard OS X ".plist" XML file).
309		Tests for presence of prefs with [ -f ] before doing anything so it doesn't create a partial prefs file -- just in case user has never
310		run Oni before :-p */
311	<	string fullAEpath = escapePath(system_complete(".").parent_path().parent_path().string()); // get full path for edition/
312	<	char prefsCommand[300] = "[ -f ~/Library/Preferences/com.godgames.oni.plist ] && defaults write com.godgames.oni RetailInstallationPath -string '";
313	<	strcat(prefsCommand, fullAEpath.c_str()); // get path of Edition/ folder (Oni wants the folder that *contains* the GDF)
311	>	string fullAEpath = escapePath(system_complete(".").parent_path().parent_path().string()); // get full path for Edition/ (Oni wants folder that *contains* the GDF)
312	>	//bad Iritscen, bad! fixed buffers can cause crashes.
313	>	/*char prefsCommand[300] = "[ -f ~/Library/Preferences/com.godgames.oni.plist ] && defaults write com.godgames.oni RetailInstallationPath -string '";
314	>	strcat(prefsCommand, fullAEpath.c_str());
315		strcat(prefsCommand, "'"); // path string is enclosed in single quotes to avoid the need to escape UNIX-unfriendly characters
316	<	system(prefsCommand);
316	>	*/
317	>	string prefsCommand = "[ -f ~/Library/Preferences/com.godgames.oni.plist ] && defaults write com.godgames.oni RetailInstallationPath -string '"
318	>	+ fullAEpath + "'";
319	>	system(prefsCommand.c_str());
320	>
321		#endif
322
323		setStatusArea((string)"Done! Now select your mod packages and click install.");
#	Line 326 | Line 337 | int globalizeData(void)
337		vector<ModPackage> getPackages(string packageDir)
338		{
339		vector<ModPackage> packages;
340	+	ModPackage package;
341		packages.reserve(256);
342		fstream file;
343		string filename = "\0";
#	Line 337 | Line 349 | vector<ModPackage> getPackages(string pa
349		{
350		file.open((dir_itr->path().string() + "/" + MODINFO_CFG).c_str());
351
352	<	if(!file.fail())
352	>	if (!file.fail())
353		{
354	<	//would prefer to push a pointer to a package, but this will do for now
355	<	packages.push_back(fileToModPackage(file));
354	>	package = fileToModPackage(file, dir_itr->path().filename());
355	>	if (package.installerVersion.compare(INSTALLER_VERSION) < 1)  // if mod requires newer version of the Installer, we won't add it to the list
356	>	{
357	>	#ifdef WIN32
358	>	if (!package.platform.compare("Windows") || !package.platform.compare("Both")) // don't show package if it's not for the right OS
359	>	#else
360	>	if (!package.platform.compare("Macintosh") || !package.platform.compare("Both"))
361	>	#endif
362	>	packages.push_back(package);
363	>	}
364		}
365		file.close();
366		file.clear();
#	Line 355 | Line 375 | vector<ModPackage> getPackages(string pa
375		return packages;
376		}
377
378	<	ModPackage fileToModPackage(fstream &file)
379	<	{
360	<	/*
361	<	This converts a file to a ModPackage struct.
362	<
363	<	A few notes...
364	<	"iter" is the current word we are on. I should have named it "token" or something, but I don't have multiple iterators, so its ok.
365	<	I refer to (*iter) at the beginning of each if statement block. I could probably store it as a variable, but I'm pretty sure that dereferencing a pointer\iterator isn't much
366	<	slower than reading a variable.
367	<	*/
378	>	ModPackage fileToModPackage(fstream &file, string modName)
379	>	{
380		ModPackage package;
381		string line;
382	<	static string NameOfMod = "NameOfMod";  //used for comparing to the current token...
383	<	//I could have done it in reverse (*iter).compare("ModString") or
384	<	static string ARROW = "->";                             //did something like "ModString".compare(*iter), and it would have been
385	<	static string ModString = "ModString";  //functionably the same.
386	<	static string HasOnis = "HasOnis";
387	<	static string HasDeltas = "HasDeltas";
388	<	static string HasBSL = "HasBSL";
389	<	static string HasDats = "HasDats";
390	<	static string IsEngine = "IsEngine";
391	<	static string Readme = "Readme";
392	<	static string GlobalNeeded = "GlobalNeeded";
393	<	static string Category = "Category";
394	<	static string Creator = "Creator";
395	<	while (! file.eof() )
382	>	const string AEInstallVersion = "AEInstallVersion"; // used for comparing to the current token...
383	>	const string NameOfMod = "NameOfMod";
384	>	const string ARROW = "->";
385	>	const string ModString = "ModString";
386	>	const string ModVersion = "ModVersion";
387	>	const string Platform = "Platform";
388	>	const string HasOnis = "HasOnis";
389	>	const string HasDeltas = "HasDeltas";
390	>	const string HasBSL = "HasBSL";
391	>	const string HasDats = "HasDats";
392	>	const string IsEngine = "IsEngine";
393	>	const string Readme = "Readme";
394	>	const string GlobalNeeded = "GlobalNeeded";
395	>	const string Category = "Category";
396	>	const string Creator = "Creator";
397	>	package.modStringName = modName;
398	>	while (!file.eof())
399		{
400	<	getline (file,line);
400	>	getline(file,line);
401		vector<string> tokens;
402		vector<string>::iterator iter;
403	<	tokenize(line, tokens);                                 //string to vector of "words"
404	<	if (tokens.capacity() >= 3) {                   //make sure they are using enough stuff
405	<	iter = tokens.begin();                          //what word we are on, starts at first word
406	<	/* TODO: Get this "required Installer version" code working
407	<	if (!AEInstallVersion.compare(*iter))
408	<	If mod is too old, skip this mod.
409	<	*/
410	<	/*else*/if (!NameOfMod.compare(*iter))  {       //if it contains the name
411	<	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) {     // iterates through the words, ends if it reaches the end of the line or a "//" comment
412	<	if (ARROW.compare(*iter) && NameOfMod.compare(*iter)) {                 // ignores "->" and "NameOfMod"
403	>	tokenize(line, tokens);
404	>	if (tokens.capacity() >= 3)
405	>	{
406	>	iter = tokens.begin();
407	>
408	>	if (!AEInstallVersion.compare(*iter))
409	>	{
410	>	iter++; iter++;
411	>	package.installerVersion = *iter;
412	>	}
413	>	else if (!NameOfMod.compare(*iter))
414	>	{
415	>	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) // iterates through the words, ends if it reaches the end of the line or a "//" comment
416	>	{
417	>	if (ARROW.compare(*iter) && NameOfMod.compare(*iter)) // ignores "->" and "NameOfMod"
418		package.name += *iter + " ";
399	–	}
419		}
401	–
420		}
421	<	else if (!ModString.compare(*iter)) {
421	>	else if (!ModString.compare(*iter))
422	>	{
423		iter++; iter++;
424	<	package.modStringName = *iter;
424	>	//package.modStringName = *iter;
425		iter++;
426	<	package.modStringVersion = atoi((*iter).c_str());
426	>	package.modStringVersion = atof((*iter).c_str());
427		}
428	<	else if (!HasOnis.compare(*iter)) {
428	>	else if (!ModString.compare(*iter))
429	>	{
430	>	iter++; iter++;
431	>	package.modStringVersion = atof((*iter).c_str());
432	>	}
433	>	else if (!Platform.compare(*iter))
434	>	{
435	>	iter++; iter++;
436	>	package.platform = *iter;
437	>	}
438	>	else if (!HasOnis.compare(*iter))
439	>	{
440		iter++; iter++;
441	<	if ( boost::iequals(*iter, "Yes")) package.hasOnis = 1;
441	>	if (boost::iequals(*iter, "Yes")) package.hasOnis = 1;
442		}
443	<	else if (!HasBSL.compare(*iter)) {
444	<	if(toupper((*iter)[0]) == 'Y' && toupper((*iter)[1]) == 'E' && toupper((*iter)[2]) == 'S') package.hasBSL = true;
445	<	else if ( boost::iequals(*iter, "Addon")) package.hasAddon = true;
443	>	else if (!HasBSL.compare(*iter))
444	>	{
445	>	iter++; iter++;
446	>	if (boost::iequals(*iter, "Yes")) package.hasBSL = true;
447	>	else if (boost::iequals(*iter, "Addon")) package.hasAddon = true;
448		}
449	<	else if (!HasDeltas.compare(*iter)) {
449	>	else if (!HasDeltas.compare(*iter))
450	>	{
451		iter++; iter++;
452	<	if (toupper((*iter)[0]) + toupper((*iter)[1]) + toupper((*iter)[2]) == 'Y' + 'E' + 'S') package.hasDeltas = 1;
452	>	if (toupper((*iter)[0]) == 'Y' && toupper((*iter)[1]) == 'E' && toupper((*iter)[2]) == 'S') package.hasDeltas = 1;
453		}
454	<	else if (!HasDats.compare(*iter)) {
454	>	else if (!HasDats.compare(*iter))
455	>	{
456		iter++; iter++;
457	<	if (toupper((*iter)[0]) + toupper((*iter)[1]) + toupper((*iter)[2]) == 'Y' + 'E' + 'S') package.hasDats = 1;
457	>	if (toupper((*iter)[0]) == 'Y' && toupper((*iter)[1]) == 'E' && toupper((*iter)[2]) == 'S') package.hasDats = 1;
458		}
459	<	else if (!IsEngine.compare(*iter)) {
459	>	else if (!IsEngine.compare(*iter))
460	>	{
461		iter++; iter++;
462	<	if (toupper((*iter)[0]) + toupper((*iter)[1]) + toupper((*iter)[2]) == 'Y' + 'E' + 'S') package.isEngine = 1;
462	>	if (toupper((*iter)[0]) == 'Y' && toupper((*iter)[1]) == 'E' && toupper((*iter)[2]) == 'S') package.isEngine = 1;
463		}
464	<	else if (!GlobalNeeded.compare(*iter)) {
464	>	else if (!GlobalNeeded.compare(*iter))
465	>	{
466		iter++; iter++;
467	<	if (toupper((*iter)[0]) + toupper((*iter)[1]) + toupper((*iter)[2]) == 'Y' + 'E' + 'S') package.globalNeeded = 1;
468	<	else if (toupper((*iter)[0]) + toupper((*iter)[1]) == 'N' + 'O') package.globalNeeded = 1; // only place where checking for "No" is important atm.
467	>	if (toupper((*iter)[0]) == 'Y' && toupper((*iter)[1]) == 'E' && toupper((*iter)[2]) == 'S') package.globalNeeded = 1;
468	>	else if (toupper((*iter)[0]) == 'N' && toupper((*iter)[1]) == 'O') package.globalNeeded = 1; // only place where checking for "No" is important atm
469		}
470	<	else if (!Category.compare(*iter))  {
471	<	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) {     // iterates through the words, ends if it reaches end of line or a "//" comment
472	<	if (ARROW.compare(*iter) && Category.compare(*iter)) {                  // ignores "->" and "Category"
470	>	else if (!Category.compare(*iter))
471	>	{
472	>	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++)
473	>	{
474	>	if (ARROW.compare(*iter) && Category.compare(*iter)) // ignores "->" and "Category"
475		package.category += *iter + " ";
438	–	}
476		}
477		}
478	<	else if (!Creator.compare(*iter))  {    //if it contains the name
479	<	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) {     // iterates through the words, ends if it reaches end of line or a "//" comment
480	<	if (ARROW.compare(*iter) && Creator.compare(*iter)) {                   // ignores "->" and "Creator"
478	>	else if (!Creator.compare(*iter))
479	>	{
480	>	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++)
481	>	{
482	>	if (ARROW.compare(*iter) && Creator.compare(*iter)) // ignores "->" and "Creator"
483		package.creator += *iter + " ";
445	–	}
484		}
485		}
486	<	else if (!Readme.compare(*iter))  {     //if it contains the name
487	<	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) {     // iterates through the words, ends if it reaches end of line or a "//" comment
488	<	if (ARROW.compare(*iter) && Readme.compare(*iter)) {                    // ignores "->" and "Readme"
489	<	if(!(*iter).compare("\\n")) package.readme += '\n';
486	>	else if (!Readme.compare(*iter))
487	>	{
488	>	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++)
489	>	{
490	>	if (ARROW.compare(*iter) && Readme.compare(*iter)) // ignores "->" and "Readme"
491	>	{
492	>	if (!(*iter).compare("\\n")) package.readme += '\n';
493		else package.readme += *iter + " ";
494		}
495		}
496		}
497		}
457	–
498		}
499
500		return package;
#	Line 528 | Line 568 | void recompileAll(vector<string> install
568
569
570		setProgressBar( (int)(1000 * (float)(j-1) / (float)numberOfDats) ); //100% * dat we're on / total dats
571	<	setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +  dir_itr->path().filename() + " ");
571	>	setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +
572	>	dir_itr->path().filename() + " ");
573
574		system(importCommand.c_str());
575		j++;
#	Line 584 | Line 625 | void recompileAll(vector<string> install
625		importCommand += " ../GameDataFolder/" + dir_itr->path().filename() + ".dat >> Install.log";
626
627		setProgressBar( (int)(1000 * (float)(j-1) / (float)numberOfDats) ); //100% * dat we're on / total dats
628	<	setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +  dir_itr->path().filename() + " ");
628	>	setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +
629	>	dir_itr->path().filename() + " ");
630		system(importCommand.c_str());
631		j++;
632		}
#	Line 661 | Line 703 | void recompileAll(vector<string> install
703
704		void copyBSL(string copypath, vector<string>& BSLfolders, ModPackage pkg)
705		{
706	<	ofstream BSLlog("BSL2.log", ios::app );
706	>	ofstream BSLlog("BSL.log", ios::app );
707
708		try {
709		for ( directory_iterator dir_itr( copypath ), end_itr;
#	Line 769 | Line 811 | vector<string> getInstallString(string C
811		|                                                          Installer to be replaced (when the new Installer                     |
812		|                                                          launches, this function will be called again but will        |
813		|                                                          return UPDATE_SIMP_AVAIL or UPDATE_GLOB_AVAIL)                       |
814	+	|  UPDATE_PKG_AVAIL                     -- A newer version of individual package(s) is available        |
815		\* UPDATE_CONT_UPD                      -- Currently unused                                                                                */
816		int GetUpdateStatus(Install_info_cfg *currentAE, Install_info_cfg *updateAE, bool *installerJustUpdated)
817		{
#	Line 797 | Line 840 | int GetUpdateStatus(Install_info_cfg *cu
840		else
841		return UPDATE_LOG_READ_ERR;
842		}
843	<
843	>
844		// Is there an update folder, and is it a monthly release or a patch?
845	<	if (!exists("../updates/Edition"))
845	>	bool firstParty = 0;
846	>	if (exists("../updates/Edition"))
847		{
848	+	firstParty = 1;
849	+	}
850	+	else {
851		strEUFN = "Edition-patch";
852	<	if (!exists("../updates/Edition-patch"))
853	<	return UPDATE_NO_UPD_AVAIL;
852	>	if (exists("../updates/Edition-patch")) {
853	>	firstParty = 1;
854	>	}
855	>
856		}
857	<
858	<	// Unlike the current AE's version info, we *need* to find the update's version info or we won't continue
859	<	string updateCfgPath = ("../updates/" + strEUFN + "/install/packages/Globalize/Install_Info.cfg");
860	<	updateAECfg.open(updateCfgPath.c_str());
861	<	if (!updateAECfg.fail())
862	<	{
863	<	if (!ReadInstallInfoCfg(&updateAECfg, updateAE))
857	>
858	>	if(firstParty) {
859	>	// Unlike the current AE's version info, we *need* to find the update's version info or we won't continue
860	>	string updateCfgPath = ("../updates/" + strEUFN + "/install/packages/Globalize/Install_Info.cfg");
861	>	updateAECfg.open(updateCfgPath.c_str());
862	>	if (!updateAECfg.fail())
863	>	{
864	>	if (!ReadInstallInfoCfg(&updateAECfg, updateAE))
865	>	return UPDATE_LOG_READ_ERR;
866	>
867	>	updateAECfg.close();
868	>	updateAECfg.clear();
869	>	}
870	>	else
871		return UPDATE_LOG_READ_ERR;
816	–
817	–	updateAECfg.close();
818	–	updateAECfg.clear();
819	–	}
820	–	else
821	–	return UPDATE_LOG_READ_ERR;
872
873	<	// Now we check for an Installer update in progress
874	<	if (exists("Update.log"))
875	<	{
876	<	updateLog.open("Update.log");
877	<	if (!updateLog.fail())
828	<	{
829	<	vector<string> lines;
830	<	string line;
831	<	int num_lines = 0;
832	<	bool readingInstallerVersion = false, doneReadingFile = false;
833	<
834	<	while (!updateLog.eof() && !doneReadingFile)
873	>	// Now we check for an Installer update in progress
874	>	if (exists("Update.log"))
875	>	{
876	>	updateLog.open("Update.log");
877	>	if (!updateLog.fail())
878		{
879	<	getline(updateLog, line);
880	<	lines.push_back(line);
881	<	num_lines++;
882	<	vector<string> tokens;
883	<	vector<string>::iterator iter;
884	<	tokenize(line, tokens);
842	<	iter = tokens.begin();
843	<	if (!readingInstallerVersion && tokens.capacity() >= 4)
879	>	vector<string> lines;
880	>	string line;
881	>	int num_lines = 0;
882	>	bool readingInstallerVersion = false, doneReadingFile = false;
883	>
884	>	while (!updateLog.eof() && !doneReadingFile)
885		{
886	<	if (!strInstaller.compare(*iter))
886	>	getline(updateLog, line);
887	>	lines.push_back(line);
888	>	num_lines++;
889	>	vector<string> tokens;
890	>	vector<string>::iterator iter;
891	>	tokenize(line, tokens);
892	>	iter = tokens.begin();
893	>	if (!readingInstallerVersion && tokens.capacity() >= 4)
894		{
895	<	if (!strBeing.compare(*++iter))
896	<	readingInstallerVersion = true;
897	<	else if (!strWas.compare(*iter))
898	<	*installerJustUpdated = true; // our third indirect return value after currentAE and updateAE
895	>	if (!strInstaller.compare(*iter))
896	>	{
897	>	if (!strBeing.compare(*++iter))
898	>	readingInstallerVersion = true;
899	>	else if (!strWas.compare(*iter))
900	>	*installerJustUpdated = true; // our third indirect return value after currentAE and updateAE
901	>	}
902		}
903	<	}
853	<	else if (readingInstallerVersion && tokens.capacity() >= 3)
854	<	{
855	<	readingInstallerVersion = false;
856	<	string installerVersion = INSTALLER_VERSION;
857	<	if (installerVersion.compare(*iter)) // then the shell script-powered replacement failed
858	<	return UPDATE_INST_REPL_ERR;
859	<	else
903	>	else if (readingInstallerVersion && tokens.capacity() >= 3)
904		{
905	<	updateLog.close();
906	<	updateLog.clear();
907	<	Sleep(1000);
908	<	remove("Update.log");
909	<	ofstream newUpdateLog("Update.log");
866	<	if (!newUpdateLog.fail())
905	>	readingInstallerVersion = false;
906	>	string installerVersion = INSTALLER_VERSION;
907	>	if (installerVersion.compare(*iter)) // then the shell script-powered replacement failed
908	>	return UPDATE_INST_REPL_ERR;
909	>	else
910		{
911	<	// Write over old log with updated information
912	<	ptime startTime(second_clock::local_time());
913	<	string strStartTime = to_simple_string(startTime);
914	<	string newUpdateLine = installerVersion + " on " + strStartTime;
915	<	for (int a = 0; a < lines.capacity() - 2; a++) // if there were even lines in the log before this at all
911	>	updateLog.close();
912	>	updateLog.clear();
913	>	Sleep(1000);
914	>	remove("Update.log");
915	>	ofstream newUpdateLog("Update.log");
916	>	if (!newUpdateLog.fail())
917		{
918	<	newUpdateLog << lines[a].c_str();
919	<	newUpdateLog << "\n";
918	>	// Write over old log with updated information
919	>	ptime startTime(second_clock::local_time());
920	>	string strStartTime = to_simple_string(startTime);
921	>	string newUpdateLine = installerVersion + " on " + strStartTime;
922	>	for (int a = 0; a < lines.capacity() - 2; a++) // if there were even lines in the log before this at all
923	>	{
924	>	newUpdateLog << lines[a].c_str();
925	>	newUpdateLog << "\n";
926	>	}
927	>	newUpdateLog << "Installer was updated to:\n";
928	>	newUpdateLog << newUpdateLine.c_str();
929	>	*installerJustUpdated = true; // this value is indirectly returned to AEInstallerApp::OnInit()
930	>	doneReadingFile = true;
931	>	newUpdateLog.close();
932	>	newUpdateLog.clear();
933	>	//return UPDATE_CONT_UPD; // as noted above, we are not using this return value; in fact, we want...
934	>	//                                                       ...the code to continue running down through the Edition version check
935		}
936	<	newUpdateLog << "Installer was updated to:\n";
937	<	newUpdateLog << newUpdateLine.c_str();
879	<	*installerJustUpdated = true; // this value is indirectly returned to AEInstallerAp::OnInit()
880	<	doneReadingFile = true;
881	<	newUpdateLog.close();
882	<	newUpdateLog.clear();
883	<	//return UPDATE_CONT_UPD; // as noted above, we are not using this return value; in fact, we want...
884	<	//                                                       ...the code to continue running down through the Edition version check
936	>	else
937	>	return UPDATE_LOG_READ_ERR;
938		}
886	–	else
887	–	return UPDATE_LOG_READ_ERR;
939		}
940		}
941	+	updateLog.close();
942	+	updateLog.clear();
943		}
944	<	updateLog.close();
945	<	updateLog.clear();
944	>	else
945	>	return UPDATE_LOG_READ_ERR;
946		}
947	<	else
948	<	return UPDATE_LOG_READ_ERR;
896	<	}
897	<
898	<	if (updateAE->AEVersion.compare(currentAE->AEVersion) >= 1) // is the release update newer than what's installed?
899	<	{
900	<	if (!strEUFN.compare("Edition-patch")) // if update is a patch...
947	>
948	>	if (updateAE->AEVersion.compare(currentAE->AEVersion) >= 1) // is the release update newer than what's installed?
949		{
950	<	if (currentAE->AEVersion.compare(updateAE->AEVersion.substr(0, updateAE->AEVersion.length() - 1))) // ...is it for a different month?
951	<	return UPDATE_MNTH_REQD_ERR;
950	>	if (!strEUFN.compare("Edition-patch")) // if update is a patch...
951	>	{
952	>	if (currentAE->AEVersion.compare(updateAE->AEVersion.substr(0, updateAE->AEVersion.length() - 1))) // ...is it for a different month?
953	>	return UPDATE_MNTH_REQD_ERR;
954	>	}
955	>	string strNewInstallerPath = "../updates/" + strEUFN + "/install/" + strInstallerName;
956	>	string installerVersion = INSTALLER_VERSION;
957	>	if (updateAE->InstallerVersion.compare(installerVersion) >= 1)
958	>	{
959	>	if (exists(strNewInstallerPath))
960	>	return UPDATE_INST_AVAIL;
961	>	}
962	>	else if (updateAE->globalizationRequired)
963	>	return UPDATE_GLOB_AVAIL;
964	>	else
965	>	return UPDATE_SIMP_AVAIL;
966		}
967	<	string strNewInstallerPath = "../updates/" + strEUFN + "/install/" + strInstallerName;
968	<	string installerVersion = INSTALLER_VERSION;
969	<	if (updateAE->InstallerVersion.compare(installerVersion) >= 1)
967	>	}
968	>	try
969	>	{
970	>	directory_iterator end;
971	>	if (exists("../updates"))
972		{
973	<	if (exists(strNewInstallerPath))
974	<	return UPDATE_INST_AVAIL;
973	>	for (directory_iterator install_iter("../updates"); install_iter != end; ++install_iter)
974	>	{
975	>	ModPackage installedPackage, updatePackage;
976	>	if (is_directory(install_iter->path()) && exists(install_iter->path().string() + "/Mod_Info.cfg"))
977	>	{
978	>	fstream file;
979	>	file.open((install_iter->path().string() + "/Mod_Info.cfg").c_str());
980	>	if (!file.fail())
981	>	ModPackage updatePackage = fileToModPackage(file, install_iter->path().filename());
982	>	else
983	>	{
984	>	file.close();
985	>	continue;
986	>	}
987	>	if (exists("packages" + install_iter->path().filename() + "/Mod_Info.cfg"))
988	>	{
989	>	file.close();
990	>	file.open(("packages" + install_iter->path().filename() + "/Mod_Info.cfg").c_str());
991	>	if (!file.fail())
992	>	ModPackage installedPackage = fileToModPackage(file, install_iter->path().filename());
993	>	file.close();
994	>	if (updatePackage.modStringVersion > installedPackage.modStringVersion)
995	>	{
996	>	if (updatePackage.installerVersion <= INSTALLER_VERSION)
997	>	return UPDATE_PKG_AVAIL;
998	>	}
999	>	}
1000	>	else
1001	>	{
1002	>	file.close();
1003	>	return UPDATE_PKG_AVAIL;
1004	>	}
1005	>	}
1006	>	}
1007		}
912	–	else if (updateAE->globalizationRequired)
913	–	return UPDATE_GLOB_AVAIL;
914	–	else
915	–	return UPDATE_SIMP_AVAIL;
1008		}
1009	<	else
1010	<	return UPDATE_NO_UPD_AVAIL;
1011	<
1009	>	catch (exception & ex) {
1010	>	//      setStatusArea("Warning, handled exception: " + (string)ex.what());
1011	>	}
1012	>
1013		return UPDATE_NO_UPD_AVAIL;
1014		}
1015
#	Line 930 | Line 1023 | bool ReadInstallInfoCfg(fstream *fileHan
1023		string strDaodanVersion = "Daodan_Version";
1024		string strOniSplitVersion = "OniSplit_Version";
1025		string strGUIWinVersion = "GUI_Win_Version";
1026	<	string strGUIMacVersion = "GUI_Mac_Version";
1026	>	string strGUIMacVersion = "GUI_Mac_Version";
1027		string strReglobalize = "Reglobalize";
1028		string strDeleteList = "Delete_List";
1029		string strArrow = "->";
#	Line 939 | Line 1032 | bool ReadInstallInfoCfg(fstream *fileHan
1032
1033		while (getline(*fileHandler, line))
1034		{
1035	+	StripNewlines(&line);
1036		tokenize(line, tokens);
1037		iter = tokens.begin();
1038
#	Line 1141 | Line 1235 | bool ProcessInstallerUpdate(Install_info
1235
1236		string popenCommand = "../updates/" + strEUFN + "/install/";
1237		#ifdef WIN32
1238	<	// TODO: Fill in Windows equivalent of code below :-3
1238	>	popenCommand = "replace_installer.bat";
1239		#else
1240		// We can't just use '~' to mean "the home directory" because we need to check the path in C...
1241		// ...so we actually get the current user's shortname and manually construct the path to home
#	Line 1163 | Line 1257 | bool ProcessInstallerUpdate(Install_info
1257		#endif
1258		file.close();
1259		file.clear();
1260	+	#ifdef WIN32
1261	+	system(popenCommand.c_str());
1262	+	#else
1263		popen(popenCommand.c_str(), "r");
1264	<
1264	>	#endif
1265		return true; // returning 'true' tells the Installer to quit itself ASAP so it can be replaced by the process that is now running
1266		}
1267
#	Line 1193 | Line 1290 | bool ProcessAEUpdate(Install_info_cfg *c
1290		bool needNewTrashDir = false;
1291		bool readingVerAndDate = false;
1292
1196	–	// TODO: Fill in Windows equivalent of code below
1293		#ifdef WIN32
1294	<	string strTrashDir = "%RECYCLE%";
1294	>	string strTrashDir = "Trash\\"; // string unused in Windows because files are simply deleted
1295		#else
1296		FILE *fUserName = NULL;
1297		char chrUserName[32];
#	Line 1240 | Line 1336 | bool ProcessAEUpdate(Install_info_cfg *c
1336		needNewTrashDir = true;
1337		}
1338		}
1339	<
1339	>	#ifndef WIN32
1340		if (!*installerJustUpdated || needNewTrashDir) // prepare a new directory for deleted files to go to
1341		{
1342		tm tmStartTime = to_tm(startTime);
#	Line 1248 | Line 1344 | bool ProcessAEUpdate(Install_info_cfg *c
1344		boost::lexical_cast<string>(tmStartTime.tm_min) + "-" + boost::lexical_cast<string>(tmStartTime.tm_sec) + "/";
1345		create_directory(strTrashDir);
1346		}
1347	+	#endif
1348		file.close();
1349		file.clear();
1350
#	Line 1323 | Line 1420 | bool ProcessAEUpdate(Install_info_cfg *c
1420		curPos = thePath.find("/", lastPos);
1421		aParentPath = aParentPath + "/";
1422		}
1423	+	#ifndef WIN32
1424		rename((path)("../" + thePath), (path)(strTrashDir + thePath));
1425	+	#else
1426	+	remove((path)("../" + thePath));
1427	+	#endif
1428		}
1429		}
1430
1431	<	// Now we crawl the update's package folders for newer versions and move them over, trashing ones that are already present
1331	<	vector<ModPackage> updatePackages, currentPackages;
1332	<	bool matchFound;
1333	<	updatePackages.reserve(256);
1334	<	currentPackages.reserve(256);
1335	<
1336	<	currentPackages = getPackages();
1337	<	updatePackages = getPackages(strPathToEUFNPackages);
1338	<
1339	<	for (vector<ModPackage>::iterator iter1 = updatePackages.begin(); iter1 != updatePackages.end(); iter1++)
1340	<	{
1341	<	matchFound = false;
1342	<	for (vector<ModPackage>::iterator iter2 = currentPackages.begin(); iter2 != currentPackages.end(); iter2++)
1343	<	{
1344	<	if (!iter1->modStringName.compare(iter2->modStringName))
1345	<	{
1346	<	matchFound = true;
1347	<	if (iter1->modStringVersion > iter2->modStringVersion)
1348	<	{
1349	<	rename((path)(strPathToPackages + iter2->modStringName), (path)(strTrashDir + iter2->modStringName));
1350	<	rename((path)(strPathToEUFNPackages + iter1->modStringName), (path)(strPathToPackages + iter1->modStringName));
1351	<	}
1352	<	}
1353	<	}
1354	<	if (!matchFound) // then there's no old package in the way, so just move in the one from the update
1355	<	rename((path)(strPathToEUFNPackages + iter1->modStringName), (path)(strPathToPackages + iter1->modStringName));
1356	<	}
1431	>	ProcessPackageUpdates(strPathToEUFNPackages, strPathToPackages);
1432
1433		// Next, we get a list of which files and folders in the update's Globalize folder to move over; all files not starting with '.' will be moved...
1434		// ...and folders which do not exist in the current AE will be created there
#	Line 1410 | Line 1485 | bool ProcessAEUpdate(Install_info_cfg *c
1485		CheckForGlobalization(true); // the 'true' value forces re-globalization
1486
1487		globalPackages = getPackages(); // refresh the list in memory
1413	–
1488		// TODO: Refresh the packages list in the window
1489
1490		return true;
1491		}
1492
1493	+	void ProcessPackageUpdates(string pathToUpdate, string strPathToPackages)
1494	+	{
1495	+	ptime startTime(second_clock::local_time());
1496	+	#ifdef WIN32
1497	+	string strTrashDir = "Trash\\"; // string unused in Windows because files are simply deleted
1498	+	#else
1499	+	FILE *fUserName = NULL;
1500	+	char chrUserName[32];
1501	+	fUserName = popen("whoami", "r");
1502	+	fgets(chrUserName, sizeof(chrUserName), fUserName);
1503	+	pclose(fUserName);
1504	+	string strUserName = (string)chrUserName; // stringsblaaarrrgggghhhh
1505	+	int endOfName = strUserName.find("\n", 0);
1506	+	string strTrashDir = "/Users/" + strUserName.substr(0, endOfName) + "/.Trash/";
1507	+	bool needNewTrashDir = true;
1508	+	tm tmStartTime = to_tm(startTime);
1509	+	#endif
1510	+
1511	+	try
1512	+	{
1513	+	directory_iterator end;
1514	+	for (directory_iterator update_iter(pathToUpdate); update_iter != end; ++update_iter)
1515	+	{
1516	+	ModPackage installedPackage, updatePackage;
1517	+	string updtPath = update_iter->path().string();
1518	+	string updtFolder = update_iter->path().filename();
1519	+	string updtModInfo = updtPath + "/Mod_Info.cfg";
1520	+	string instModInfo = strPathToPackages + "/" + updtFolder + "/Mod_Info.cfg";
1521	+	if (!boost::iequals(updtFolder, "Edition")
1522	+	&& !boost::iequals(updtFolder, "Edition-patch")
1523	+	&& is_directory(update_iter->path())
1524	+	&& exists(updtModInfo))
1525	+	{
1526	+	fstream file;
1527	+	file.open((updtModInfo).c_str());
1528	+	if (!file.fail())
1529	+	updatePackage = fileToModPackage(file, updtFolder);
1530	+	else
1531	+	{
1532	+	file.close();
1533	+	continue;
1534	+	}
1535	+	if (exists(instModInfo))
1536	+	{
1537	+	file.close();
1538	+	file.clear();
1539	+	file.open(instModInfo.c_str());
1540	+	if (!file.fail())
1541	+	{
1542	+	installedPackage = fileToModPackage(file, updtFolder);
1543	+	file.close();
1544	+	if (updatePackage.modStringVersion > installedPackage.modStringVersion)
1545	+	{
1546	+	if (updatePackage.installerVersion <= INSTALLER_VERSION)
1547	+	{
1548	+	#ifdef WIN32
1549	+	remove_all((path)(strPathToPackages +  "/" + installedPackage.modStringName));
1550	+	#else
1551	+	if (needNewTrashDir)
1552	+	{
1553	+	strTrashDir = strTrashDir + "Old_packages_" + boost::lexical_cast<string>(tmStartTime.tm_hour) + "-" +
1554	+	boost::lexical_cast<string>(tmStartTime.tm_min) + "-" + boost::lexical_cast<string>(tmStartTime.tm_sec) + "/";
1555	+	create_directory(strTrashDir);
1556	+	needNewTrashDir = false;
1557	+	}
1558	+	rename((path)(strPathToPackages +  "/" + installedPackage.modStringName), (path)(strTrashDir + installedPackage.modStringName));
1559	+	#endif
1560	+	rename((path)(pathToUpdate + "/" + updatePackage.modStringName), (path)(strPathToPackages + "/" + updatePackage.modStringName));
1561	+	}
1562	+	}
1563	+	}
1564	+	else
1565	+	file.close();
1566	+	}
1567	+	file.close();
1568	+	file.clear();
1569	+	}
1570	+	}
1571	+	}
1572	+	catch (exception & ex)
1573	+	{
1574	+	setStatusArea("Warning, handled exception: " + (string)ex.what());
1575	+	}
1576	+	}
1577	+
1578		/* MakePathLocalToGlobalize is a function used once by ProcessAEUpdate() that takes a file in an        \
1579		|  update's Globalize folder and changes its path, originally relative to the Installer, to be          |
1580		|  relative to the structure of the Globalize folder; this makes it easier to have the Installer        |
#	Line 1457 | Line 1616 | void tokenize(const string& str, vector<
1616		}
1617		}
1618
1619	+	/* StripNewlines() gets rids of any linebreaks that come from text returned by getline(); \
1620	+	|  getline() should be stripping those out, but Windows CR/LF files seem to be sneaking   |
1621	+	\  some extra return characters into strings in the ReadInstallInfoCfg() function.               */
1622	+	void StripNewlines(string *theLine)
1623	+	{
1624	+	int deleteFromHere = 0;
1625	+	deleteFromHere = theLine->find("\r");
1626	+	if (deleteFromHere > 0)
1627	+	theLine->erase(deleteFromHere, theLine->size());
1628	+	}
1629	+
1630		void clearOldDats(void) {
1631		directory_iterator end_iter_gdf;
1632		for ( directory_iterator dir_itr_gdf( "../GameDataFolder" );
#	Line 1571 | Line 1741 | ModPackage::ModPackage()
1741		name = "";
1742		modStringName = "";
1743		modStringVersion = 0;
1744	+	platform = "Both";
1745		hasOnis = false;
1746		hasDeltas = false;
1747		hasBSL = false;

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)