Replay system part 1

src/game/boe.global.hpp

@@ -26,4 +26,15 @@ struct effect_pat_type {
 	unsigned short pattern[9][9];
 };
 
+// Input recording system
+namespace ticpp { class Element; }
+using ticpp::Element;
+
+extern bool recording;
+extern bool replaying;
+
+extern bool init_action_log(std::string command, std::string file);
+extern void record_action(std::string action_type, std::string inner_text);
+extern Element* pop_next_action(std::string expected_action_type="");
+
 #endif

src/game/boe.main.cpp

@@ -2,10 +2,15 @@
 #include "boe.global.hpp"
 #include "universe/universe.hpp"
 
+#include <boost/algorithm/string/predicate.hpp>
 #include <boost/filesystem/operations.hpp>
+#include <boost/lexical_cast.hpp>
 #include <unordered_map>
 #include <string>
 #include <memory>
+#include <iostream>
+#include <ctime>
+#include <sstream>
 #include "boe.graphics.hpp"
 #include "boe.newgraph.hpp"
 #include "boe.fileio.hpp"
@@ -215,12 +220,95 @@ static void init_ui() {
 	init_buttons();
 }
 
+// Input recording system
+
+#include <ctime>
+#include <iomanip>
+
+bool recording = false;
+bool replaying = false;
+
+using namespace ticpp;
+Document log_document;
+std::string log_file;
+
+bool init_action_log(std::string command, std::string file) {
+	if (command == "record") {
+		// If a filename is given, use it as a base, but insert a timestamp for uniqueness.
+		if (file.empty())
+			file = "BoE";
+
+		if (boost::ends_with(file, ".xml"))
+			file = file.substr(0, file.length() - 4);
+
+		// Get a time stamp
+		std::time_t t = time(nullptr);
+		auto tm = *std::localtime(&t);
+		std::ostringstream stream;
+		stream << file << std::put_time(&tm, "_%d-%m-%Y_%H-%M-%S") << ".xml";
+		log_file = stream.str();
+
+		try {
+			Element root_element("actions");
+			log_document.InsertEndChild(root_element);
+			log_document.SaveFile(log_file);
+			recording = true;
+			std::cout << "Recording this session: " << log_file << std::endl;
+		} catch(...) {
+			std::cout << "Failed to write to file " << log_file << std::endl;
+		}
+		return true;
+	}
+	else if (command == "replay") {
+		try {
+			log_document.LoadFile(file);
+			replaying = true;
+		} catch(...) {
+			std::cout << "Failed to load file " << file << std::endl;
+		}
+		return true;
+	}
+	return false;
+}
+
+void record_action(std::string action_type, std::string inner_text) {
+	Element* root = log_document.FirstChildElement();
+	Element next_action(action_type);
+	Text action_text(inner_text);
+	next_action.InsertEndChild(action_text);
+	root->InsertEndChild(next_action);
+	log_document.SaveFile(log_file);
+}
+
+Element* pop_next_action(std::string expected_action_type) {
+	Element* root = log_document.FirstChildElement();
+	Element* next_action = root->FirstChildElement();
+
+	if (expected_action_type != "" && next_action->Value() != expected_action_type) {
+		std::ostringstream stream;
+		stream << "Replay error! Expected '" << expected_action_type << "' action next";
+		throw stream.str();
+	}
+
+	Element* clone = next_action->Clone()->ToElement();
+	root->RemoveChild(next_action);
+	return clone;
+}
+
 void process_args(int argc, char* argv[]) {
 	// Command line usage:
 	//  "Blades of Exile"                               # basic launch
 	//  "Blades of Exile" <save file>                   # launch and load save file
-
+	// 	"Blades of Exile" record <optional file>	    # record this session in a time-stamped xml file
+	//  "Blades of Exile" play <file>                   # replay a session from an xml file
 	if (argc > 1) {
+		std::string file = "";
+		if (argc > 2) {
+			file = argv[2];
+		}
+		if (init_action_log(argv[1], file))
+			return;
+
 		if(!load_party(argv[1], univ)) {
 			std::cout << "Failed to load save file: " << argv[1] << std::endl;
 			return;
@@ -245,21 +333,38 @@ void init_boe(int argc, char* argv[]) {
 #ifdef __APPLE__
 	init_menubar(); // Do this first of all because otherwise a default File and Window menu will be seen
 #endif
+
+	// TODO preferences need to be recorded in the action log for deterministic replay
 	sync_prefs();
 	init_shaders();
 	init_tiling();
 	init_snd_tool();
 
 	init_ui();
-	
+
 	adjust_window_mode();
 	// If we don't do this now it'll flash white to start with
 	mainPtr.clear(sf::Color::Black);
 	mainPtr.display();
 
 	set_cursor(watch_curs);
 	init_buf();
-	srand(time(nullptr));
+
+	// Seed the RNG
+	if (replaying) {
+		auto srand_element = pop_next_action("srand");
+
+		std::string ts(srand_element->GetText());
+		srand(atoi(ts.c_str()));
+	} else {
+		auto t = time(nullptr);
+		if (recording) {
+			std::string ts = boost::lexical_cast<std::string>(t);
+			record_action("srand", ts);
+		}
+		srand(t);
+	}
+	std::cout << rand() << std::endl;
 	init_screen_locs();	
 	init_startup();
 	flushingInput = true;

src/tools/prefs.win.cpp

@@ -1,5 +1,7 @@
 
 #include "prefs.hpp"
+#include "game/boe.global.hpp"
+#include "ticpp.h"
 #include <map>
 #include <string>
 #include <vector>
@@ -70,6 +72,9 @@ void clear_pref(std::string keypath) {
 }
 
 static bool save_prefs(fs::path fpath) {
+	// Don't save preferences when running a replay which might change them
+	if(replaying) return true;
+
 	if(!prefsDirty) return true;
 	fs::create_directories(fpath.parent_path());
 	std::ofstream fout(fpath.string().c_str());
@@ -99,10 +104,18 @@ static bool save_prefs(fs::path fpath) {
 static bool load_prefs(fs::path fpath) {
 	prefsDirty = false;
 	std::map<std::string,boost::any> temp_prefs;
-	std::ifstream fin(fpath.string().c_str());
+	std::istream* in;
+	if (replaying) {
+		Element* prefs_action = pop_next_action("load_prefs");
+		in = new std::istringstream(prefs_action->GetText());
+	} else {
+		in = new std::ifstream(fpath.c_str());
+	}
+	(fpath.string().c_str());
 	std::string line;
-	while(std::getline(fin, line)) {
-		if(!fin) {
+	std::ostringstream prefs_recording;
+	while(std::getline(*in, line)) {
+		if(!in) {
 			perror("Error reading preferences");
 			return false;
 		}
@@ -121,6 +134,10 @@ static bool load_prefs(fs::path fpath) {
 			printf("Error reading preferences: line is missing key:\n\t%s\n", line.c_str());
 			return false;
 		}
+		if (recording) {
+			prefs_recording << line << std::endl;
+		}
+
 		std::string key = line.substr(0, key_end + 1), val = line.substr(val_beg);
 		if(val == "true") temp_prefs[key] = true;
 		else if(val == "false") temp_prefs[key] = false;
@@ -138,6 +155,12 @@ static bool load_prefs(fs::path fpath) {
 		}
 	}
 	prefs.swap(temp_prefs);
+	delete in;
+
+	if (recording) {
+		record_action("load_prefs", prefs_recording.str());
+	}
+
 	return prefsLoaded = true;
 }