From d49c502869bd1850dc94186b503c182d0c44c495 Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Wed, 3 Aug 2016 21:52:14 +0100
Subject: [PATCH 01/15] Update gitignore

---
 .gitignore | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index fc45dfb..e155f43 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,4 +8,7 @@
 
 # Data files
 /TriviaBot/data_management/questions
-/TriviaBot/bot/db/trivia.db
\ No newline at end of file
+/TriviaBot/bot/db/trivia.db
+
+# Compiled sqlite file
+sqlite3.obj
\ No newline at end of file

From 005dad899bc63c1f84e6bf9754e801c905bf85a9 Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Wed, 3 Aug 2016 22:04:05 +0100
Subject: [PATCH 02/15] Basic JS implementation

---
 TriviaBot/bot/GatewayHandler.cpp |  23 ++++---
 TriviaBot/bot/GatewayHandler.hpp |   5 +-
 TriviaBot/bot/TriviaBot.cpp      |  12 ++++
 TriviaBot/bot/TriviaGame.cpp     |   2 +-
 TriviaBot/bot/TriviaGame.hpp     |   4 +-
 TriviaBot/bot/js/V8Instance.cpp  | 101 +++++++++++++++++++++++++++++++
 TriviaBot/bot/js/V8Instance.hpp  |  31 ++++++++++
 7 files changed, 165 insertions(+), 13 deletions(-)
 create mode 100644 TriviaBot/bot/js/V8Instance.cpp
 create mode 100644 TriviaBot/bot/js/V8Instance.hpp

diff --git a/TriviaBot/bot/GatewayHandler.cpp b/TriviaBot/bot/GatewayHandler.cpp
index f15ab29..7e3af06 100644
--- a/TriviaBot/bot/GatewayHandler.cpp
+++ b/TriviaBot/bot/GatewayHandler.cpp
@@ -10,7 +10,7 @@ extern std::string bot_token;
 GatewayHandler::GatewayHandler() {
 	last_seq = 0;
 
-	ah = new APIHelper();
+	ah = std::make_shared<APIHelper>();
 }
 
 void GatewayHandler::handle_data(std::string data, client &c, websocketpp::connection_hdl &hdl) {
@@ -68,14 +68,7 @@ void GatewayHandler::on_dispatch(json decoded, client &c, websocketpp::connectio
 	}
 	else if (event_name == "GUILD_CREATE") {
 		std::string guild_id = data["id"];
-		try {
-			guilds[guild_id] = std::make_unique<DiscordObjects::Guild>(data);
-		}
-		catch (std::domain_error err) {
-			// this doesn't even work
-			c.get_alog().write(websocketpp::log::elevel::rerror, "Domain error");
-		}
-		
+		guilds[guild_id] = std::make_unique<DiscordObjects::Guild>(data);
 
 		c.get_alog().write(websocketpp::log::alevel::app, "Loaded guild: " + guilds[guild_id]->name);
 		
@@ -87,6 +80,11 @@ void GatewayHandler::on_dispatch(json decoded, client &c, websocketpp::connectio
 			// add ptr to said channel list to guild's channel list
 			guilds[guild_id]->channels.push_back(std::shared_ptr<DiscordObjects::Channel>(channels[channel_id]));
 		}
+
+		if (v8_instances.count(guild_id) == 0) {
+			v8_instances[guild_id] = std::make_unique<V8Instance>(ah);
+			c.get_alog().write(websocketpp::log::alevel::app, "Created v8 instance for guild " + guild_id);
+		}
 	}
 	else if (event_name == "TYPING_START") {}
 	else if (event_name == "MESSAGE_CREATE") {
@@ -156,6 +154,13 @@ void GatewayHandler::on_dispatch(json decoded, client &c, websocketpp::connectio
 		else if (words[0] == "`info") {
 			ah->send_message(channel->id, ":information_source: trivia-bot by Jack. <http://github.com/jackb-p/TriviaDiscord>");
 		}
+		else if (words[0] == "`js") {
+			std::string js = message.erase(0, 3);
+			auto it = v8_instances.find(channel->guild_id);
+			if (it != v8_instances.end()) {
+				it->second->exec_js(js, channel->id);
+			}
+		}
 		else if (games.find(channel->id) != games.end()) { // message received in channel with ongoing game
 			games[channel->id]->handle_answer(message, sender);
 		}
diff --git a/TriviaBot/bot/GatewayHandler.hpp b/TriviaBot/bot/GatewayHandler.hpp
index 4b60448..775a1a6 100644
--- a/TriviaBot/bot/GatewayHandler.hpp
+++ b/TriviaBot/bot/GatewayHandler.hpp
@@ -9,6 +9,7 @@
 #include "json/json.hpp"
 
 #include "TriviaGame.hpp"
+#include "js/V8Instance.hpp"
 #include "data_structures/User.hpp"
 #include "data_structures/Guild.hpp"
 #include "data_structures/Channel.hpp"
@@ -68,10 +69,12 @@ private:
 
 	// <channel_id, game obj>
 	std::map<std::string, std::unique_ptr<TriviaGame>> games;
+	// <guild_id, v8 instance>
+	std::map<std::string, std::unique_ptr<V8Instance>> v8_instances;
 
 	std::unique_ptr<boost::thread> heartbeat_thread;
 
-	APIHelper *ah;
+	std::shared_ptr<APIHelper> ah;
 };
 
 #endif
\ No newline at end of file
diff --git a/TriviaBot/bot/TriviaBot.cpp b/TriviaBot/bot/TriviaBot.cpp
index 548ad33..aeee6ca 100644
--- a/TriviaBot/bot/TriviaBot.cpp
+++ b/TriviaBot/bot/TriviaBot.cpp
@@ -1,4 +1,6 @@
 #include <curl/curl.h>
+#include <include/libplatform/libplatform.h>
+#include <include/v8.h>
 
 #include "ClientConnection.hpp"
 
@@ -7,6 +9,12 @@ std::string bot_token;
 int main(int argc, char *argv[]) {
 	curl_global_init(CURL_GLOBAL_DEFAULT);
 
+	v8::V8::InitializeICUDefaultLocation(argv[0]);
+	v8::V8::InitializeExternalStartupData(argv[0]);
+	v8::Platform* platform = v8::platform::CreateDefaultPlatform();
+	v8::V8::InitializePlatform(platform);
+	v8::V8::Initialize();
+
 	if (argc == 2) {
 		bot_token = argv[1];
 	}
@@ -34,6 +42,10 @@ int main(int argc, char *argv[]) {
 
 	std::getchar();
 
+	v8::V8::Dispose();
+	v8::V8::ShutdownPlatform();
+	delete platform;
+
 	curl_global_cleanup();
 
 	return 0;
diff --git a/TriviaBot/bot/TriviaGame.cpp b/TriviaBot/bot/TriviaGame.cpp
index a2385f1..94a5631 100644
--- a/TriviaBot/bot/TriviaGame.cpp
+++ b/TriviaBot/bot/TriviaGame.cpp
@@ -13,7 +13,7 @@
 #include "APIHelper.hpp"
 #include "data_structures/User.hpp"
 
-TriviaGame::TriviaGame(GatewayHandler *gh, APIHelper *ah, std::string channel_id, int total_questions, int delay) : interval(delay) {
+TriviaGame::TriviaGame(GatewayHandler *gh, std::shared_ptr<APIHelper> ah, std::string channel_id, int total_questions, int delay) : interval(delay) {
 	this->gh = gh;
 	this->ah = ah;
 	this->channel_id = channel_id;
diff --git a/TriviaBot/bot/TriviaGame.hpp b/TriviaBot/bot/TriviaGame.hpp
index fb393db..4031c1d 100644
--- a/TriviaBot/bot/TriviaGame.hpp
+++ b/TriviaBot/bot/TriviaGame.hpp
@@ -19,7 +19,7 @@ namespace DiscordObjects {
 
 class TriviaGame {
 public:
-	TriviaGame(GatewayHandler *gh, APIHelper *ah, std::string channel_id, int total_questions, int delay);
+	TriviaGame(GatewayHandler *gh, std::shared_ptr<APIHelper> ah, std::string channel_id, int total_questions, int delay);
 	~TriviaGame();
 
 	void start();
@@ -38,7 +38,7 @@ private:
 
 	std::string channel_id;
 	GatewayHandler *gh;
-	APIHelper *ah;
+	std::shared_ptr<APIHelper> ah;
 
 	const char hide_char = '#';
 
diff --git a/TriviaBot/bot/js/V8Instance.cpp b/TriviaBot/bot/js/V8Instance.cpp
new file mode 100644
index 0000000..434fd8d
--- /dev/null
+++ b/TriviaBot/bot/js/V8Instance.cpp
@@ -0,0 +1,101 @@
+#include <iostream>
+#include <string>
+
+#include "V8Instance.hpp"
+#include "../APIHelper.hpp"
+
+using namespace v8;
+
+V8Instance::V8Instance(std::shared_ptr<APIHelper> ah) {
+	this->ah = ah;
+	create();
+}
+
+V8Instance::~V8Instance() {
+	clean_up();
+}
+
+void V8Instance::create() {
+	Isolate::CreateParams create_params;
+	create_params.array_buffer_allocator = ArrayBuffer::Allocator::NewDefaultAllocator();
+
+	isolate = Isolate::New(create_params);
+	isolate->Enter();
+	std::cout << "Created isolate." << std::endl;
+
+	Isolate::Scope isolate_scope(isolate);
+	HandleScope handle_scope(isolate);
+
+	// set global context
+	Local<Context> context = create_context();
+	context->Enter();
+	Context::Scope context_scope(context);
+	std::cout << "Created context and context scope." << std::endl;
+}
+
+v8::Local<v8::Context> V8Instance::create_context() {
+	Local<ObjectTemplate> global = ObjectTemplate::New(isolate);
+	// bind print() function
+	Local<External> self = External::New(isolate, (void *) this);
+	global->Set(String::NewFromUtf8(isolate, "print", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, V8Instance::js_print, self));
+	std::cout << "Created global, assigned print function." << std::endl;
+
+	return Context::New(isolate, NULL, global);
+}
+
+void V8Instance::clean_up() {
+	std::cout << "Cleaning up." << std::endl;
+	isolate->Exit();
+	isolate->Dispose();
+	delete array_buffer_allocator;
+}
+
+void V8Instance::reload() {
+	clean_up();
+	create();
+}
+
+void V8Instance::exec_js(std::string js, std::string channel_id) {
+	std::cout << "Isolate nullptr? " << (isolate == nullptr) << std::endl;
+
+	HandleScope handle_scope(isolate);
+	Local<Context> context(isolate->GetCurrentContext());
+
+	std::cout << "Executing js: " << js << std::endl;
+
+	Local<String> source = String::NewFromUtf8(isolate, js.c_str(), NewStringType::kNormal).ToLocalChecked();
+	std::cout << "String coverted" << std::endl;
+
+	// compile
+	std::cout << "Context empty? " << context.IsEmpty() << std::endl;
+
+	TryCatch try_catch(isolate);
+	Local<Script> script;
+
+	if (!Script::Compile(context, source).ToLocal(&script)) {
+		String::Utf8Value error(try_catch.Exception());
+		std::cerr << "Error: " << *error << std::endl;
+
+		return;
+	}
+	std::cout << "Compiled" << std::endl;
+
+	// run
+	script->Run(context);
+	std::cout << "Ran" << std::endl;
+
+	ah->send_message(channel_id, print_text);
+	print_text = "";
+}
+
+void V8Instance::js_print(const v8::FunctionCallbackInfo<v8::Value> &args) {
+	auto data = args.Data().As<v8::External>();
+	V8Instance *self = static_cast<V8Instance *>(data->Value());
+
+	std::string output = "";
+	for (int i = 0; i < args.Length(); i++) {
+		v8::HandleScope handle_scope(args.GetIsolate());
+		v8::String::Utf8Value str(args[i]);
+		self->print_text += *str;
+	}
+}
\ No newline at end of file
diff --git a/TriviaBot/bot/js/V8Instance.hpp b/TriviaBot/bot/js/V8Instance.hpp
new file mode 100644
index 0000000..3bb0615
--- /dev/null
+++ b/TriviaBot/bot/js/V8Instance.hpp
@@ -0,0 +1,31 @@
+#ifndef BOT_JS_V8INSTANCE
+#define BOT_JS_V8INSTANCE
+
+#include <memory>
+
+#include <include/v8.h>
+#include <include/libplatform/libplatform.h>
+
+class APIHelper;
+
+class V8Instance {
+public:
+	V8Instance(std::shared_ptr<APIHelper> ah);
+	~V8Instance();
+	void reload();
+	void exec_js(std::string js, std::string channel_id);
+
+private:
+	void clean_up();
+	void create();
+	v8::Local<v8::Context> create_context();
+	static void js_print(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+	v8::ArrayBuffer::Allocator *array_buffer_allocator;
+	v8::Isolate *isolate;
+
+	std::shared_ptr<APIHelper> ah;
+	std::string print_text;
+};
+
+#endif
\ No newline at end of file

From 3656080a4338ad8a03d28246c7c9c6421ff38fdc Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Thu, 4 Aug 2016 02:41:02 +0100
Subject: [PATCH 03/15] Basic command creation/overwriting system

---
 TriviaBot/bot/GatewayHandler.cpp   |  43 +++++---
 TriviaBot/bot/GatewayHandler.hpp   |   3 +
 TriviaBot/bot/TriviaBot.cpp        |   2 -
 TriviaBot/bot/db/schema.sqlite     |  22 +++--
 TriviaBot/bot/js/CommandHelper.cpp | 153 +++++++++++++++++++++++++++++
 TriviaBot/bot/js/CommandHelper.hpp |  25 +++++
 6 files changed, 227 insertions(+), 21 deletions(-)
 create mode 100644 TriviaBot/bot/js/CommandHelper.cpp
 create mode 100644 TriviaBot/bot/js/CommandHelper.hpp

diff --git a/TriviaBot/bot/GatewayHandler.cpp b/TriviaBot/bot/GatewayHandler.cpp
index 7e3af06..1916ebc 100644
--- a/TriviaBot/bot/GatewayHandler.cpp
+++ b/TriviaBot/bot/GatewayHandler.cpp
@@ -11,6 +11,7 @@ GatewayHandler::GatewayHandler() {
 	last_seq = 0;
 
 	ah = std::make_shared<APIHelper>();
+	command_helper = std::make_unique<CommandHelper>();
 }
 
 void GatewayHandler::handle_data(std::string data, client &c, websocketpp::connection_hdl &hdl) {
@@ -95,6 +96,7 @@ void GatewayHandler::on_dispatch(json decoded, client &c, websocketpp::connectio
 
 		std::vector<std::string> words;
 		boost::split(words, message, boost::is_any_of(" "));
+		Command custom_command;
 		if (words[0] == "`trivia" || words[0] == "`t") {
 			int questions = 10;
 			int delay = 8;
@@ -136,14 +138,6 @@ void GatewayHandler::on_dispatch(json decoded, client &c, websocketpp::connectio
 			games[channel->id] = std::make_unique<TriviaGame>(this, ah, channel->id, questions, delay);
 			games[channel->id]->start();
 		} 
-		else if (words[0] == "`channels") {
-			std::string m = "Channel List:\n";
-			for (auto ch : channels) {
-				m += "> " + ch.second->name + " (" + ch.second->id + ") [" + ch.second->type + "] Guild: " 
-					+ guilds[ch.second->guild_id]->name + " (" + ch.second->guild_id + ")\n";
-			}
-			ah->send_message(channel->id, m);
-		}
 		else if (words[0] == "`guilds") {
 			std::string m = "Guild List:\n";
 			for (auto &gu : guilds) {
@@ -154,13 +148,40 @@ void GatewayHandler::on_dispatch(json decoded, client &c, websocketpp::connectio
 		else if (words[0] == "`info") {
 			ah->send_message(channel->id, ":information_source: trivia-bot by Jack. <http://github.com/jackb-p/TriviaDiscord>");
 		}
-		else if (words[0] == "`js") {
-			std::string js = message.erase(0, 3);
+		else if (words[0] == "`js" && message.length() > 4) {
+			std::string js = message.substr(4);
 			auto it = v8_instances.find(channel->guild_id);
-			if (it != v8_instances.end()) {
+			if (it != v8_instances.end() && js.length() > 0) {
 				it->second->exec_js(js, channel->id);
 			}
 		}
+		else if (words[0] == "`createjs" && message.length() > 8) {
+			std::string args = message.substr(10);
+			size_t seperator_loc = args.find("|");
+			if (seperator_loc != std::string::npos) {
+				std::string command_name = args.substr(0, seperator_loc);
+				std::string script = args.substr(seperator_loc + 1);
+				int result = command_helper->insert_command(channel->guild_id, command_name, script); 
+				switch (result) {
+				case 0:
+					ah->send_message(channel->id, ":warning: Error!"); break;
+				case 1:
+					ah->send_message(channel->id, ":new: Command `" + command_name + "` successfully created."); break;
+				case 2:
+					ah->send_message(channel->id, ":arrow_heading_up: Command `" + command_name + "` successfully updated."); break;
+				}
+			}
+		}
+		else if (words[0] == "`shutdown" && sender.id == "82232146579689472") { // it me
+			ah->send_message(channel->id, ":zzz: Goodbye!");
+			c.close(hdl, websocketpp::close::status::going_away, "`shutdown command used.");
+		}
+		else if (command_helper->get_command(channel->guild_id, words[0], custom_command)) {
+			auto it = v8_instances.find(channel->guild_id);
+			if (it != v8_instances.end() && custom_command.script.length() > 0) {
+				it->second->exec_js(custom_command.script, channel->id);
+			}
+		}
 		else if (games.find(channel->id) != games.end()) { // message received in channel with ongoing game
 			games[channel->id]->handle_answer(message, sender);
 		}
diff --git a/TriviaBot/bot/GatewayHandler.hpp b/TriviaBot/bot/GatewayHandler.hpp
index 775a1a6..0b781bd 100644
--- a/TriviaBot/bot/GatewayHandler.hpp
+++ b/TriviaBot/bot/GatewayHandler.hpp
@@ -9,6 +9,7 @@
 #include "json/json.hpp"
 
 #include "TriviaGame.hpp"
+#include "js/CommandHelper.hpp"
 #include "js/V8Instance.hpp"
 #include "data_structures/User.hpp"
 #include "data_structures/Guild.hpp"
@@ -62,6 +63,8 @@ private:
 	// bot's user obj
 	DiscordObjects::User user_object;
 
+	std::unique_ptr<CommandHelper> command_helper;
+
 	// <id, ptr to data>
 	std::map<std::string, std::unique_ptr<DiscordObjects::Guild>> guilds;
 	// channels pointers are shared pointers, held here but also in guild objects
diff --git a/TriviaBot/bot/TriviaBot.cpp b/TriviaBot/bot/TriviaBot.cpp
index aeee6ca..10d8ceb 100644
--- a/TriviaBot/bot/TriviaBot.cpp
+++ b/TriviaBot/bot/TriviaBot.cpp
@@ -40,8 +40,6 @@ int main(int argc, char *argv[]) {
 		std::cerr << "other exception" << std::endl;
 	}
 
-	std::getchar();
-
 	v8::V8::Dispose();
 	v8::V8::ShutdownPlatform();
 	delete platform;
diff --git a/TriviaBot/bot/db/schema.sqlite b/TriviaBot/bot/db/schema.sqlite
index 462cf6a..7cae0cd 100644
--- a/TriviaBot/bot/db/schema.sqlite
+++ b/TriviaBot/bot/db/schema.sqlite
@@ -1,14 +1,20 @@
 BEGIN TRANSACTION;
 CREATE TABLE "TotalScores" (
-	`User`	TEXT UNIQUE,
-	`TotalScore`	INTEGER,
-	`AverageTime`	INTEGER,
+	`User`              TEXT NOT NULL,
+	`TotalScore`        INTEGER NOT NULL,
+	`AverageTime`       INTEGER NOT NULL,
 	PRIMARY KEY(User)
 );
 CREATE TABLE "Questions" (
-	`ID`	INTEGER PRIMARY KEY AUTOINCREMENT,
-	`Category`	TEXT,
-	`Question`	TEXT,
-	`Answer`	TEXT
+	`ID`                INTEGER PRIMARY KEY AUTOINCREMENT,
+	`Category`          TEXT NOT NULL,
+	`Question`          TEXT NOT NULL,
+	`Answer`            TEXT NOT NULL
 );
-COMMIT;
\ No newline at end of file
+CREATE TABLE `CustomJS` (
+	`ID`                INTEGER PRIMARY KEY AUTOINCREMENT,
+	`GuildID`           TEXT NOT NULL,
+	`CommandName`       TEXT NOT NULL,
+	`Script`            TEXT NOT NULL
+);
+COMMIT;
diff --git a/TriviaBot/bot/js/CommandHelper.cpp b/TriviaBot/bot/js/CommandHelper.cpp
new file mode 100644
index 0000000..dade323
--- /dev/null
+++ b/TriviaBot/bot/js/CommandHelper.cpp
@@ -0,0 +1,153 @@
+#include "CommandHelper.hpp"
+
+#include <iostream>
+#include <algorithm>
+
+#include <sqlite3.h>
+
+CommandHelper::CommandHelper() {
+	sqlite3 *db; int return_code;
+	return_code = sqlite3_open("bot/db/trivia.db", &db);
+
+	std::string sql = "SELECT * FROM CustomJS";
+
+	sqlite3_stmt *stmt;
+	return_code = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
+
+
+	while (return_code != SQLITE_DONE) {
+		return_code = sqlite3_step(stmt);
+
+		if (return_code == SQLITE_ROW) {
+			std::string guild_id = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0));
+			std::string command_name = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 1));
+			std::string script = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 2));
+
+			commands.push_back({ guild_id, command_name, script });
+		}
+		else if (return_code != SQLITE_DONE) {
+			sqlite3_finalize(stmt);
+			std::cerr << "SQLite error." << std::endl;
+			return;
+		}
+	}
+
+	std::cout << commands.size() << " commands loaded." << std::endl;
+
+	sqlite3_finalize(stmt);
+	sqlite3_close(db);
+}
+
+bool CommandHelper::get_command(std::string guild_id, std::string command_name, Command &command) {
+	auto check_lambda = [guild_id, command_name](const Command &c) {
+		return guild_id == c.guild_id && command_name == c.command_name;
+	};
+
+	auto it = std::find_if(commands.begin(), commands.end(), check_lambda);
+	if (it == commands.end()) {
+		command = {};
+		return false;
+	} else {
+		command = { it->guild_id, it->command_name, it->script };
+	}
+}
+
+// returns: 0 error, 1 inserted, 2 updated
+int CommandHelper::insert_command(std::string guild_id, std::string command_name, std::string script) {
+	// TODO: if script empty, delete command
+
+	Command command { guild_id, command_name, script };
+
+	int ret_value;
+	std::string sql;
+	if (command_in_db(guild_id, command_name)) {
+		sql = "UPDATE CustomJS SET Script=?1 WHERE GuildID=?2 AND CommandName=?3;";
+		std::cout << "Command already exists, updating." << std::endl;
+		ret_value = 2;
+	} else {
+		sql = "INSERT INTO CustomJS(Script, GuildID, CommandName) VALUES (?1, ?2, ?3);";
+		std::cout << "Inserting new command." << std::endl;
+		ret_value = 1;
+	}
+
+	sqlite3 *db; int return_code;
+	return_code = sqlite3_open("bot/db/trivia.db", &db);
+	if (!return_code_ok(return_code)) return 0;
+
+	sqlite3_stmt *stmt;
+	return_code = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
+	if (!return_code_ok(return_code)) return 0;
+
+	return_code = sqlite3_bind_text(stmt, 1, script.c_str(), -1, (sqlite3_destructor_type)-1);
+	if (!return_code_ok(return_code)) return 0;
+
+	return_code = sqlite3_bind_text(stmt, 2, guild_id.c_str(), -1, (sqlite3_destructor_type)-1);
+	if (!return_code_ok(return_code)) return 0;
+
+	return_code = sqlite3_bind_text(stmt, 3, command_name.c_str(), -1, (sqlite3_destructor_type)-1);
+	if (!return_code_ok(return_code)) return 0;
+
+	return_code = sqlite3_step(stmt);
+	bool success = return_code == SQLITE_DONE;
+
+	sqlite3_finalize(stmt);
+	sqlite3_close(db);
+
+	if (success) {
+		if (ret_value == 1) {
+			commands.push_back({ guild_id, command_name, script });
+		}
+		if (ret_value == 2) {
+			// update command, don't add
+			auto check_lambda = [guild_id, command_name](const Command &c) {
+				return guild_id == c.guild_id && command_name == c.command_name;
+			};
+
+			auto it = std::find_if(commands.begin(), commands.end(), check_lambda);
+			if (it == commands.end()) {
+				return 0;
+			} else {
+				it->script = script;
+			}
+		}
+
+		return ret_value;
+	}
+
+	return 0;
+}
+
+bool CommandHelper::command_in_db(std::string guild_id, std::string command_name) {
+	sqlite3 *db; int return_code;
+	return_code = sqlite3_open("bot/db/trivia.db", &db);
+	if (!return_code_ok(return_code)) return false;
+
+	std::string sql = "SELECT EXISTS(SELECT 1 FROM CustomJS WHERE GuildID=?1 AND CommandName=?2);";
+
+	sqlite3_stmt *stmt;
+	return_code = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
+	if (!return_code_ok(return_code)) return false;
+
+	return_code = sqlite3_bind_text(stmt, 1, guild_id.c_str(), -1, (sqlite3_destructor_type) -1);
+	if (!return_code_ok(return_code)) return false;
+
+	return_code = sqlite3_bind_text(stmt, 2, command_name.c_str(), -1, (sqlite3_destructor_type) -1);
+	if (!return_code_ok(return_code)) return false;
+
+	sqlite3_step(stmt);
+
+	bool exists = sqlite3_column_int(stmt, 0) == 1; // returns 1 (true) if exists
+
+	sqlite3_finalize(stmt);
+	sqlite3_close(db);
+
+	return exists;
+}
+
+bool CommandHelper::return_code_ok(int return_code) {
+	if (return_code != SQLITE_OK) {
+		std::cerr << "SQLite error. " << std::endl;
+		return false;
+	}
+	return true;
+}
\ No newline at end of file
diff --git a/TriviaBot/bot/js/CommandHelper.hpp b/TriviaBot/bot/js/CommandHelper.hpp
new file mode 100644
index 0000000..2f95fd9
--- /dev/null
+++ b/TriviaBot/bot/js/CommandHelper.hpp
@@ -0,0 +1,25 @@
+#ifndef BOT_JS_COMMANDHELPER
+#define BOT_JS_COMMANDHELPER
+
+#include <vector>
+
+struct Command {
+	std::string guild_id;
+	std::string command_name;
+	std::string script;
+};
+
+class CommandHelper {
+public:
+	CommandHelper();
+	int insert_command(std::string guild_id, std::string command_name, std::string script);
+	bool get_command(std::string guild_id, std::string name, Command &command);
+
+private:
+	bool command_in_db(std::string guild_id, std::string command_name);
+	bool return_code_ok(int return_code);
+
+	std::vector<Command> commands;
+};
+
+#endif
\ No newline at end of file

From 893a6cbbe1c236b32a22b23a4f395b72e9fc6a73 Mon Sep 17 00:00:00 2001
From: Jack <jackbondpreston@outlook.com>
Date: Thu, 4 Aug 2016 02:53:54 +0100
Subject: [PATCH 04/15] Update README.md

---
 README.md | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/README.md b/README.md
index bb5e230..e57334a 100644
--- a/README.md
+++ b/README.md
@@ -22,22 +22,23 @@ LoadDB.cpp takes some time to execute.
 ### Commands
 `` `trivia`` is the base command.
 
-| Argument                | Description                                                                                                                                                                |
-| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `questions` `interval`  | Where `questions` and `interval` are integers. Makes the game last `questions` number of questions, optionally sets the time interval between hints to `interval` seconds. | 
-| stop                    | Stops the trivia game currently in the channel the message is sent from, if there is one.                                                                                  |
-| help                    | Prints a help list, similar to this table.                                                                                                                                 |
+| Argument | Description |
+| --- | --- |
+| `questions` `interval` | Where `questions` and `interval` are integers. Makes the game last `questions` number of questions, optionally sets the time interval between hints to `interval` seconds. | 
+| stop | Stops the trivia game currently in the channel the message is sent from, if there is one. |
+| help | Prints a help list, similar to this table. |
 
 
 ### Compiling
 #### Dependencies
-| Name          | Website                                                       | Notes                                                                                            |
-| ------------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
-| boost         | [boost.org](http://www.boost.org/)                            |                                                                                                  |
-| websocketpp   | [zaphoyd/websocketpp](https://github.com/zaphoyd/websocketpp) | Included as submodule.                                                                           |
-| cURL          | [curl.haxx.se](https://curl.haxx.se/)                         |                                                                                                  |
-| sqlite3       | [sqlite.org](https://www.sqlite.org/)                         | Included as submodule. Uses a [different repo](https://github.com/azadkuh/sqlite-amalgamation/). |
-| nlohmann/json | [nlohmann/json](https://github.com/nlohmann/json)             | (Slightly modified) source file included in repo.                                                |
+| Name | Website | Notes |
+| --- | --- | --- |
+| boost | [boost.org](http://www.boost.org/) | |
+| websocketpp | [zaphoyd/websocketpp](https://github.com/zaphoyd/websocketpp) | Included as submodule. |
+| cURL | [curl.haxx.se](https://curl.haxx.se/) | |
+| sqlite3 | [sqlite.org](https://www.sqlite.org/) | Included as submodule. Uses a [different repo](https://github.com/azadkuh/sqlite-amalgamation/). |
+| nlohmann/json | [nlohmann/json](https://github.com/nlohmann/json) | (Slightly modified) source file included in repo. |
+| V8 | [Google V8](https://developers.google.com/v8/) | Debian/Ubuntu `libv8` packages are too outdated. |
 
 #### Linux (debian)
 1. Clone the github repo: `git clone https://github.com/jackb-p/TriviaDiscord.git TriviaDiscord`

From a1c50b253d52f0d6fb0ef45e52e4ac25edb86ed5 Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Thu, 4 Aug 2016 17:39:48 +0100
Subject: [PATCH 05/15] Added logger, resolves #4

---
 TriviaBot/bot/APIHelper.cpp        | 10 ++++++--
 TriviaBot/bot/ClientConnection.cpp | 20 ++++++++-------
 TriviaBot/bot/GatewayHandler.cpp   | 19 +++++++++------
 TriviaBot/bot/Logger.cpp           | 39 ++++++++++++++++++++++++++++++
 TriviaBot/bot/Logger.hpp           | 14 +++++++++++
 TriviaBot/bot/TriviaBot.cpp        | 13 +++++++---
 TriviaBot/bot/TriviaGame.cpp       | 22 ++++++++---------
 TriviaBot/bot/http/HTTPHelper.cpp  |  4 ++-
 TriviaBot/bot/js/CommandHelper.cpp |  7 ++++--
 TriviaBot/bot/js/V8Instance.cpp    | 21 +++++++---------
 10 files changed, 120 insertions(+), 49 deletions(-)
 create mode 100644 TriviaBot/bot/Logger.cpp
 create mode 100644 TriviaBot/bot/Logger.hpp

diff --git a/TriviaBot/bot/APIHelper.cpp b/TriviaBot/bot/APIHelper.cpp
index f4b0703..2e8fd03 100644
--- a/TriviaBot/bot/APIHelper.cpp
+++ b/TriviaBot/bot/APIHelper.cpp
@@ -1,10 +1,11 @@
-#include "http/HTTPHelper.hpp"
+#include "APIHelper.hpp"
 
 #include <cstdio>
 #include <thread>
 #include <chrono>
 
-#include "APIHelper.hpp"
+#include "http/HTTPHelper.hpp"
+#include "Logger.hpp"
 
 using namespace std::chrono_literals;
 
@@ -25,9 +26,14 @@ void APIHelper::send_message(std::string channel_id, std::string message) {
 
 	int retries = 0;
 	while (response_code != 200 && retries < 2) {
+		Logger::write("[send_message] Got non-200 response code, retrying", Logger::LogLevel::Warning);
 		std::this_thread::sleep_for(100ms);
 		// try 3 times. usually enough to prevent 502 bad gateway issues
 		response = http->post_request(url, JSON_CTYPE, data.dump(), &response_code);
 		retries++;
 	}
+
+	if (response_code != 200) {
+		Logger::write("[send_message] Giving up on sending message", Logger::LogLevel::Warning);
+	}
 }
\ No newline at end of file
diff --git a/TriviaBot/bot/ClientConnection.cpp b/TriviaBot/bot/ClientConnection.cpp
index a0a3143..0037dc7 100644
--- a/TriviaBot/bot/ClientConnection.cpp
+++ b/TriviaBot/bot/ClientConnection.cpp
@@ -4,6 +4,7 @@
 #include <iostream>
 
 #include "GatewayHandler.hpp"
+#include "Logger.hpp"
 
 ClientConnection::ClientConnection() {
 	// Reset the log channels
@@ -58,7 +59,7 @@ void ClientConnection::start(std::string uri) {
 	client::connection_ptr con = c.get_connection(uri, ec);
 
 	if (ec) { // failed to create connection
-		c.get_alog().write(websocketpp::log::alevel::app, ec.message());
+		Logger::write("Failed to create connection: " + ec.message(), Logger::LogLevel::Severe);
 		return;
 	}
 
@@ -69,7 +70,7 @@ void ClientConnection::start(std::string uri) {
 
 // Event handlers
 void ClientConnection::on_socket_init(websocketpp::connection_hdl) {
-	c.get_alog().write(websocketpp::log::alevel::app, "Socket intialised.");
+	Logger::write("Socket initialised", Logger::LogLevel::Debug);
 }
 
 context_ptr ClientConnection::on_tls_init(websocketpp::connection_hdl) {
@@ -81,8 +82,8 @@ context_ptr ClientConnection::on_tls_init(websocketpp::connection_hdl) {
 			boost::asio::ssl::context::no_sslv3 |
 			boost::asio::ssl::context::single_dh_use);
 	}
-	catch (std::exception& e) {
-		std::cout << "Error in context pointer: " << e.what() << std::endl;
+	catch (std::exception &e) {
+		Logger::write("[tls] Error in context pointer: " + std::string(e.what()), Logger::LogLevel::Severe);
 	}
 	return ctx;
 }
@@ -91,23 +92,24 @@ void ClientConnection::on_fail(websocketpp::connection_hdl hdl) {
 	client::connection_ptr con = c.get_con_from_hdl(hdl);
 
 	// Print as much information as possible
-	c.get_elog().write(websocketpp::log::elevel::warn,
-		"Fail handler: \n" +
+	Logger::write("Fail handler: \n" +
 		std::to_string(con->get_state()) + "\n" +
 		std::to_string(con->get_local_close_code()) + "\n" +
 		con->get_local_close_reason() + "\n" +
 		std::to_string(con->get_remote_close_code()) + "\n" +
 		con->get_remote_close_reason() + "\n" +
-		std::to_string(con->get_ec().value()) + " - " + con->get_ec().message() + "\n");
+		std::to_string(con->get_ec().value()) + " - " + con->get_ec().message() + "\n",
+		Logger::LogLevel::Severe);
 }
 
 void ClientConnection::on_open(websocketpp::connection_hdl hdl) {
+	Logger::write("Connection opened", Logger::LogLevel::Debug);
 }
 
 void ClientConnection::on_message(websocketpp::connection_hdl hdl, message_ptr message) {
 	if (message->get_opcode() != websocketpp::frame::opcode::text) {
 		// If the message is not text, just print as hex
-		std::cout << "<< " << websocketpp::utility::to_hex(message->get_payload()) << std::endl;
+		Logger::write("Non-text message received: " + websocketpp::utility::to_hex(message->get_payload()), Logger::LogLevel::Warning);
 		return;
 	}
 
@@ -117,5 +119,5 @@ void ClientConnection::on_message(websocketpp::connection_hdl hdl, message_ptr m
 }
 
 void ClientConnection::on_close(websocketpp::connection_hdl) {
-	std::cout << "Closed." << std::endl;
+	Logger::write("Connection closed", Logger::LogLevel::Info);
 }
\ No newline at end of file
diff --git a/TriviaBot/bot/GatewayHandler.cpp b/TriviaBot/bot/GatewayHandler.cpp
index 1916ebc..7fef1cf 100644
--- a/TriviaBot/bot/GatewayHandler.cpp
+++ b/TriviaBot/bot/GatewayHandler.cpp
@@ -4,6 +4,7 @@
 
 #include "APIHelper.hpp"
 #include "data_structures/User.hpp"
+#include "Logger.hpp"
 
 extern std::string bot_token;
 
@@ -27,7 +28,7 @@ void GatewayHandler::handle_data(std::string data, client &c, websocketpp::conne
 		on_hello(decoded, c, hdl);
 		break;
 	case 11:
-		c.get_alog().write(websocketpp::log::alevel::app, "Heartbeat acknowledged.");
+		Logger::write("Heartbeat acknowledged", Logger::LogLevel::Debug);
 		break;
 	}
 }
@@ -43,14 +44,14 @@ void GatewayHandler::heartbeat(client *c, websocketpp::connection_hdl hdl, int i
 
 		c->send(hdl, heartbeat.dump(), websocketpp::frame::opcode::text);
 
-		c->get_alog().write(websocketpp::log::alevel::app, "Sent heartbeat. (seq: " + std::to_string(last_seq) + ")");
+		Logger::write("Sent heartbeat (seq: " + std::to_string(last_seq) + ")", Logger::LogLevel::Debug);
 	}
 }
 
 void GatewayHandler::on_hello(json decoded, client &c, websocketpp::connection_hdl &hdl) {
 	heartbeat_interval = decoded["d"]["heartbeat_interval"];
 
-	c.get_alog().write(websocketpp::log::alevel::app, "Heartbeat interval: " + std::to_string(heartbeat_interval / 1000.0f) + " seconds");
+	Logger::write("Heartbeat interval: " + std::to_string(heartbeat_interval / 1000.0f) + " seconds", Logger::LogLevel::Debug);
 
 	heartbeat_thread = std::make_unique<boost::thread>(boost::bind(&GatewayHandler::heartbeat, this, &c, hdl, heartbeat_interval));
 
@@ -65,13 +66,13 @@ void GatewayHandler::on_dispatch(json decoded, client &c, websocketpp::connectio
 	if (event_name == "READY") {
 		user_object.load_from_json(data["user"]);
 
-		c.get_alog().write(websocketpp::log::alevel::app, "Sign-on confirmed. (@" + user_object.username + "#" + user_object.discriminator + ")");
+		Logger::write("Sign-on confirmed. (@" + user_object.username + "#" + user_object.discriminator + ")", Logger::LogLevel::Info);
 	}
 	else if (event_name == "GUILD_CREATE") {
 		std::string guild_id = data["id"];
 		guilds[guild_id] = std::make_unique<DiscordObjects::Guild>(data);
 
-		c.get_alog().write(websocketpp::log::alevel::app, "Loaded guild: " + guilds[guild_id]->name);
+		Logger::write("Loaded guild: " + guilds[guild_id]->name, Logger::LogLevel::Debug);
 		
 		for (json channel : data["channels"]) {
 			std::string channel_id = channel["id"];
@@ -84,8 +85,10 @@ void GatewayHandler::on_dispatch(json decoded, client &c, websocketpp::connectio
 
 		if (v8_instances.count(guild_id) == 0) {
 			v8_instances[guild_id] = std::make_unique<V8Instance>(ah);
-			c.get_alog().write(websocketpp::log::alevel::app, "Created v8 instance for guild " + guild_id);
+			Logger::write("Created v8 instance for guild " + guild_id, Logger::LogLevel::Debug);
 		}
+
+		Logger::write("Loaded " + std::to_string(guilds.size()) + " guild(s)", Logger::LogLevel::Info);
 	}
 	else if (event_name == "TYPING_START") {}
 	else if (event_name == "MESSAGE_CREATE") {
@@ -206,7 +209,7 @@ void GatewayHandler::identify(client &c, websocketpp::connection_hdl &hdl) {
 	};
 
 	c.send(hdl, identify.dump(), websocketpp::frame::opcode::text);
-	c.get_alog().write(websocketpp::log::alevel::app, "Sent identify payload.");
+	Logger::write("Sent identify payload", Logger::LogLevel::Debug);
 }
 
 void GatewayHandler::delete_game(std::string channel_id) {
@@ -217,6 +220,6 @@ void GatewayHandler::delete_game(std::string channel_id) {
 		// remove from map
 		games.erase(it);
 	} else {
-		std::cerr << "Tried to delete a game that didn't exist.";
+		Logger::write("Tried to delete a game that didn't exist (channel_id: " + channel_id + ")", Logger::LogLevel::Warning);
 	}
 }
\ No newline at end of file
diff --git a/TriviaBot/bot/Logger.cpp b/TriviaBot/bot/Logger.cpp
new file mode 100644
index 0000000..e42b5ad
--- /dev/null
+++ b/TriviaBot/bot/Logger.cpp
@@ -0,0 +1,39 @@
+#include "Logger.hpp"
+
+#include <iostream>
+#include <iomanip>
+#include <ctime>
+
+namespace Logger {
+	std::ostream &operator<<(std::ostream &out, const LogLevel log_level) {
+		switch (log_level) {
+		case LogLevel::Debug:
+			return out << "debug";
+		case LogLevel::Info:
+			return out << "info";
+		case LogLevel::Warning:
+			return out << "warning";
+		case LogLevel::Severe:
+			return out << "severe";
+		}
+		return out << "";
+	}
+
+	std::ostream &get_ostream(LogLevel log_level) {
+		switch (log_level) {
+		case LogLevel::Debug:
+		case LogLevel::Info:
+			return std::clog;
+		case LogLevel::Severe:
+		case LogLevel::Warning:
+			return std::cerr;
+		}
+	}
+
+	void write(std::string text, LogLevel log_level) {
+		auto t = std::time(nullptr);
+		auto tm = *std::localtime(&t);
+
+		get_ostream(log_level) << "[" << std::put_time(&tm, "%Y-%m-%d %H:%M:%S") << "] [" << log_level << "] " << text << std::endl;
+	}
+}
\ No newline at end of file
diff --git a/TriviaBot/bot/Logger.hpp b/TriviaBot/bot/Logger.hpp
new file mode 100644
index 0000000..b587b81
--- /dev/null
+++ b/TriviaBot/bot/Logger.hpp
@@ -0,0 +1,14 @@
+#ifndef BOT_LOGGER
+#define BOT_LOGGER
+
+#include <string>
+
+namespace Logger {
+	enum class LogLevel {
+		Debug, Info, Warning, Severe
+	};
+
+	void write(std::string text, LogLevel log_level);
+}
+
+#endif
diff --git a/TriviaBot/bot/TriviaBot.cpp b/TriviaBot/bot/TriviaBot.cpp
index 10d8ceb..d284b93 100644
--- a/TriviaBot/bot/TriviaBot.cpp
+++ b/TriviaBot/bot/TriviaBot.cpp
@@ -3,6 +3,7 @@
 #include <include/v8.h>
 
 #include "ClientConnection.hpp"
+#include "Logger.hpp"
 
 std::string bot_token;
 
@@ -15,6 +16,8 @@ int main(int argc, char *argv[]) {
 	v8::V8::InitializePlatform(platform);
 	v8::V8::Initialize();
 
+	Logger::write("Initialised V8 and curl", Logger::LogLevel::Debug);
+
 	if (argc == 2) {
 		bot_token = argv[1];
 	}
@@ -30,14 +33,14 @@ int main(int argc, char *argv[]) {
 		ClientConnection conn;
 		conn.start(uri);
 	}
-	catch (const std::exception & e) {
-		std::cerr << e.what() << std::endl;
+	catch (const std::exception &e) {
+		Logger::write(e.what(), Logger::LogLevel::Severe);
 	}
 	catch (websocketpp::lib::error_code e) {
-		std::cerr << e.message() << std::endl;
+		Logger::write(e.message(), Logger::LogLevel::Severe);
 	}
 	catch (...) {
-		std::cerr << "other exception" << std::endl;
+		Logger::write("Other exception.", Logger::LogLevel::Severe);
 	}
 
 	v8::V8::Dispose();
@@ -46,5 +49,7 @@ int main(int argc, char *argv[]) {
 
 	curl_global_cleanup();
 
+	Logger::write("Cleaned up", Logger::LogLevel::Info);
+
 	return 0;
 }
\ No newline at end of file
diff --git a/TriviaBot/bot/TriviaGame.cpp b/TriviaBot/bot/TriviaGame.cpp
index 94a5631..275aa92 100644
--- a/TriviaBot/bot/TriviaGame.cpp
+++ b/TriviaBot/bot/TriviaGame.cpp
@@ -12,6 +12,7 @@
 #include "GatewayHandler.hpp"
 #include "APIHelper.hpp"
 #include "data_structures/User.hpp"
+#include "Logger.hpp"
 
 TriviaGame::TriviaGame(GatewayHandler *gh, std::shared_ptr<APIHelper> ah, std::string channel_id, int total_questions, int delay) : interval(delay) {
 	this->gh = gh;
@@ -56,7 +57,7 @@ TriviaGame::~TriviaGame() {
 
 	rc = sqlite3_open("bot/db/trivia.db", &db);
 	if (rc) {
-		std::cerr << "Cant't open database: " << sqlite3_errmsg(db) << std::endl;
+		Logger::write("Can't open database: " + *sqlite3_errmsg(db), Logger::LogLevel::Severe);
 	}
 
 	std::string sql_in_list;
@@ -71,7 +72,7 @@ TriviaGame::~TriviaGame() {
 
 	rc = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
 	if (rc != SQLITE_OK) {
-		std::cerr << "SQL error." << std::endl;
+		Logger::write("Error creating prepared statement: " + *sqlite3_errmsg(db), Logger::LogLevel::Severe);
 	}
 
 	// insert arguments
@@ -79,7 +80,7 @@ TriviaGame::~TriviaGame() {
 		rc = sqlite3_bind_text(stmt, i + 1, pairs[i].first.c_str(), -1, (sqlite3_destructor_type) -1);
 
 		if (rc != SQLITE_OK) {
-			std::cerr << "SQL error." << std::endl;
+			Logger::write("Error binding prepared statement argument: " + *sqlite3_errmsg(db), Logger::LogLevel::Severe);
 			break;
 		}
 	}
@@ -97,7 +98,7 @@ TriviaGame::~TriviaGame() {
 			data[id] = std::pair<int, int>(total_score, average_time);
 		} else if (rc != SQLITE_DONE) {
 			sqlite3_finalize(stmt);
-			std::cerr << "SQLite error." << std::endl;
+			Logger::write("Error fetching results: " + *sqlite3_errmsg(db), Logger::LogLevel::Severe);
 			break;
 		}
 	}
@@ -116,7 +117,7 @@ TriviaGame::~TriviaGame() {
 
 		rc = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
 		if (rc != SQLITE_OK) {
-			std::cerr << "SQL error." << std::endl;
+			Logger::write("Error creating prepared statement: " + *sqlite3_errmsg(db), Logger::LogLevel::Severe);
 		}
 
 		int count = 1;
@@ -140,7 +141,7 @@ TriviaGame::~TriviaGame() {
 	if (update_sql != "") {
 		rc = sqlite3_prepare_v2(db, update_sql.c_str(), -1, &stmt, 0);
 		if (rc != SQLITE_OK) {
-			std::cerr << "SQL error." << std::endl;
+			Logger::write("Error creating prepared statement: " + *sqlite3_errmsg(db), Logger::LogLevel::Severe);
 		}
 
 		int index = 1;
@@ -180,16 +181,15 @@ void TriviaGame::question() {
 		/// open db
 		rc = sqlite3_open("bot/db/trivia.db", &db);
 		if (rc) {
-			std::cerr << "Cant't open database: " << sqlite3_errmsg(db) << std::endl;
+			Logger::write("Error opening database: " + *sqlite3_errmsg(db), Logger::LogLevel::Severe);
 		}
 
 		// prepare statement
 		sqlite3_stmt *stmt;
 		sql = "SELECT * FROM Questions ORDER BY RANDOM() LIMIT 1;";
 		rc = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
-
 		if (rc != SQLITE_OK) {
-			std::cerr << "SQL error." << std::endl;
+			Logger::write("Error creating prepared statement: " + *sqlite3_errmsg(db), Logger::LogLevel::Severe);
 		}
 
 		rc = sqlite3_step(stmt);
@@ -205,9 +205,9 @@ void TriviaGame::question() {
 			boost::split(current_answers, answer, boost::is_any_of("*"));
 
 		}
-		else if (rc != SQLITE_DONE) {
+		else {
 			sqlite3_finalize(stmt);
-			std::cerr << "SQLite error." << std::endl;
+			Logger::write("Error fetching question: " + *sqlite3_errmsg(db), Logger::LogLevel::Severe);
 		}
 
 		sqlite3_finalize(stmt);
diff --git a/TriviaBot/bot/http/HTTPHelper.cpp b/TriviaBot/bot/http/HTTPHelper.cpp
index 33b6c0a..5c76703 100644
--- a/TriviaBot/bot/http/HTTPHelper.cpp
+++ b/TriviaBot/bot/http/HTTPHelper.cpp
@@ -1,5 +1,7 @@
 #include "HTTPHelper.hpp"
 
+#include "../Logger.hpp"
+
 extern std::string bot_token;
 
 /*
@@ -40,10 +42,10 @@ std::string HTTPHelper::post_request(std::string url, std::string content_type,
 		if (res == CURLE_OK) {
 			curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, response_code);
 		} else {
+			Logger::write("curl error", Logger::LogLevel::Warning);
 			return "";
 		}
 
-		/* always cleanup */
 		curl_easy_cleanup(curl);
 		curl_slist_free_all(headers);
 	}
diff --git a/TriviaBot/bot/js/CommandHelper.cpp b/TriviaBot/bot/js/CommandHelper.cpp
index dade323..d641f8b 100644
--- a/TriviaBot/bot/js/CommandHelper.cpp
+++ b/TriviaBot/bot/js/CommandHelper.cpp
@@ -5,6 +5,8 @@
 
 #include <sqlite3.h>
 
+#include "../Logger.hpp"
+
 CommandHelper::CommandHelper() {
 	sqlite3 *db; int return_code;
 	return_code = sqlite3_open("bot/db/trivia.db", &db);
@@ -32,7 +34,7 @@ CommandHelper::CommandHelper() {
 		}
 	}
 
-	std::cout << commands.size() << " commands loaded." << std::endl;
+	Logger::write(std::to_string(commands.size()) + " custom command loaded", Logger::LogLevel::Info);
 
 	sqlite3_finalize(stmt);
 	sqlite3_close(db);
@@ -145,8 +147,9 @@ bool CommandHelper::command_in_db(std::string guild_id, std::string command_name
 }
 
 bool CommandHelper::return_code_ok(int return_code) {
+	// TODO: NotLikeThis
 	if (return_code != SQLITE_OK) {
-		std::cerr << "SQLite error. " << std::endl;
+		Logger::write("SQLite error", Logger::LogLevel::Severe);
 		return false;
 	}
 	return true;
diff --git a/TriviaBot/bot/js/V8Instance.cpp b/TriviaBot/bot/js/V8Instance.cpp
index 434fd8d..a8fd3f0 100644
--- a/TriviaBot/bot/js/V8Instance.cpp
+++ b/TriviaBot/bot/js/V8Instance.cpp
@@ -3,6 +3,7 @@
 
 #include "V8Instance.hpp"
 #include "../APIHelper.hpp"
+#include "../Logger.hpp"
 
 using namespace v8;
 
@@ -21,7 +22,7 @@ void V8Instance::create() {
 
 	isolate = Isolate::New(create_params);
 	isolate->Enter();
-	std::cout << "Created isolate." << std::endl;
+	Logger::write("[v8] Created isolate", Logger::LogLevel::Debug);
 
 	Isolate::Scope isolate_scope(isolate);
 	HandleScope handle_scope(isolate);
@@ -30,7 +31,7 @@ void V8Instance::create() {
 	Local<Context> context = create_context();
 	context->Enter();
 	Context::Scope context_scope(context);
-	std::cout << "Created context and context scope." << std::endl;
+	Logger::write("[v8] Created context and context scope", Logger::LogLevel::Debug);
 }
 
 v8::Local<v8::Context> V8Instance::create_context() {
@@ -38,13 +39,13 @@ v8::Local<v8::Context> V8Instance::create_context() {
 	// bind print() function
 	Local<External> self = External::New(isolate, (void *) this);
 	global->Set(String::NewFromUtf8(isolate, "print", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, V8Instance::js_print, self));
-	std::cout << "Created global, assigned print function." << std::endl;
+	Logger::write("[v8] Created global obj, linked print function", Logger::LogLevel::Debug);
 
 	return Context::New(isolate, NULL, global);
 }
 
 void V8Instance::clean_up() {
-	std::cout << "Cleaning up." << std::endl;
+	Logger::write("[v8] Cleaning up", Logger::LogLevel::Debug);
 	isolate->Exit();
 	isolate->Dispose();
 	delete array_buffer_allocator;
@@ -56,33 +57,29 @@ void V8Instance::reload() {
 }
 
 void V8Instance::exec_js(std::string js, std::string channel_id) {
-	std::cout << "Isolate nullptr? " << (isolate == nullptr) << std::endl;
-
 	HandleScope handle_scope(isolate);
 	Local<Context> context(isolate->GetCurrentContext());
 
-	std::cout << "Executing js: " << js << std::endl;
+	Logger::write("[v8] Executing JS: " + js, Logger::LogLevel::Debug);
 
 	Local<String> source = String::NewFromUtf8(isolate, js.c_str(), NewStringType::kNormal).ToLocalChecked();
-	std::cout << "String coverted" << std::endl;
 
 	// compile
-	std::cout << "Context empty? " << context.IsEmpty() << std::endl;
+	Logger::write("[v8] Isolate nullptr? " + std::to_string(isolate == nullptr) + " Context empty? " + std::to_string(context.IsEmpty()), Logger::LogLevel::Debug);
 
 	TryCatch try_catch(isolate);
 	Local<Script> script;
 
 	if (!Script::Compile(context, source).ToLocal(&script)) {
 		String::Utf8Value error(try_catch.Exception());
-		std::cerr << "Error: " << *error << std::endl;
+		Logger::write("[v8] Compilation error: " + std::string((const char *) *error), Logger::LogLevel::Debug);
 
 		return;
 	}
-	std::cout << "Compiled" << std::endl;
 
 	// run
 	script->Run(context);
-	std::cout << "Ran" << std::endl;
+	Logger::write("[v8] Script compiled and run", Logger::LogLevel::Debug);
 
 	ah->send_message(channel_id, print_text);
 	print_text = "";

From 1b2ea3c6bf64650d94fa93da23f22887d7742d2a Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Thu, 4 Aug 2016 18:16:09 +0100
Subject: [PATCH 06/15] Add runtime error checking for custom JS

---
 TriviaBot/bot/APIHelper.cpp        |  4 ++++
 TriviaBot/bot/js/CommandHelper.cpp |  2 +-
 TriviaBot/bot/js/V8Instance.cpp    | 29 ++++++++++++++++++++++-------
 3 files changed, 27 insertions(+), 8 deletions(-)

diff --git a/TriviaBot/bot/APIHelper.cpp b/TriviaBot/bot/APIHelper.cpp
index 2e8fd03..5df8e88 100644
--- a/TriviaBot/bot/APIHelper.cpp
+++ b/TriviaBot/bot/APIHelper.cpp
@@ -15,6 +15,10 @@ APIHelper::APIHelper() : BASE_URL("https://discordapp.com/api"), CHANNELS_URL(BA
 }
 
 void APIHelper::send_message(std::string channel_id, std::string message) {
+	if (message == "") {
+		Logger::write("[send_message] Tried to send empty message", Logger::LogLevel::Warning);
+	}
+
 	const std::string url = CHANNELS_URL + "/" + channel_id + "/messages";
 	json data = {
 		{ "content", message }
diff --git a/TriviaBot/bot/js/CommandHelper.cpp b/TriviaBot/bot/js/CommandHelper.cpp
index d641f8b..4722632 100644
--- a/TriviaBot/bot/js/CommandHelper.cpp
+++ b/TriviaBot/bot/js/CommandHelper.cpp
@@ -34,7 +34,7 @@ CommandHelper::CommandHelper() {
 		}
 	}
 
-	Logger::write(std::to_string(commands.size()) + " custom command loaded", Logger::LogLevel::Info);
+	Logger::write(std::to_string(commands.size()) + " custom command(s) loaded", Logger::LogLevel::Info);
 
 	sqlite3_finalize(stmt);
 	sqlite3_close(db);
diff --git a/TriviaBot/bot/js/V8Instance.cpp b/TriviaBot/bot/js/V8Instance.cpp
index a8fd3f0..78ba8cf 100644
--- a/TriviaBot/bot/js/V8Instance.cpp
+++ b/TriviaBot/bot/js/V8Instance.cpp
@@ -67,22 +67,37 @@ void V8Instance::exec_js(std::string js, std::string channel_id) {
 	// compile
 	Logger::write("[v8] Isolate nullptr? " + std::to_string(isolate == nullptr) + " Context empty? " + std::to_string(context.IsEmpty()), Logger::LogLevel::Debug);
 
-	TryCatch try_catch(isolate);
+	TryCatch compile_try_catch(isolate);
 	Local<Script> script;
 
 	if (!Script::Compile(context, source).ToLocal(&script)) {
-		String::Utf8Value error(try_catch.Exception());
-		Logger::write("[v8] Compilation error: " + std::string((const char *) *error), Logger::LogLevel::Debug);
+		String::Utf8Value error(compile_try_catch.Exception());
+
+		std::string err_msg = *error;
+		Logger::write("[v8] Compilation error: " + err_msg, Logger::LogLevel::Debug);
+		ah->send_message(channel_id, ":warning: **Compilation error:** `" + err_msg + "`");
+
+		return;
+	}
+
+	TryCatch run_try_catch(isolate);
+	MaybeLocal<Value> v = script->Run(context);
+	if (v.IsEmpty()) {
+		String::Utf8Value error(run_try_catch.Exception());
+
+		std::string err_msg = *error;
+		Logger::write("[v8] Runtime error: " + err_msg, Logger::LogLevel::Debug);
+		ah->send_message(channel_id, ":warning: **Runtime error:** `" + err_msg + "`");
 
 		return;
 	}
 
-	// run
-	script->Run(context);
 	Logger::write("[v8] Script compiled and run", Logger::LogLevel::Debug);
 
-	ah->send_message(channel_id, print_text);
-	print_text = "";
+	if (print_text != "") {
+		ah->send_message(channel_id, print_text);
+		print_text = "";
+	}
 }
 
 void V8Instance::js_print(const v8::FunctionCallbackInfo<v8::Value> &args) {

From 47de861f45ad72a59aceabdf313401dbd3f8d2a0 Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Fri, 5 Aug 2016 02:27:46 +0100
Subject: [PATCH 07/15] Now tracks and caches all (I think) required data

---
 TriviaBot/bot/GatewayHandler.cpp              | 557 ++++++++++++++----
 TriviaBot/bot/GatewayHandler.hpp              |  31 +-
 TriviaBot/bot/TriviaBot.cpp                   |   9 +-
 TriviaBot/bot/data_structures/Channel.hpp     |  14 +
 TriviaBot/bot/data_structures/Guild.hpp       |  34 +-
 TriviaBot/bot/data_structures/GuildMember.hpp |  68 +++
 TriviaBot/bot/data_structures/Role.hpp        | 118 ++++
 TriviaBot/bot/data_structures/User.hpp        |   3 +
 8 files changed, 718 insertions(+), 116 deletions(-)
 create mode 100644 TriviaBot/bot/data_structures/GuildMember.hpp
 create mode 100644 TriviaBot/bot/data_structures/Role.hpp

diff --git a/TriviaBot/bot/GatewayHandler.cpp b/TriviaBot/bot/GatewayHandler.cpp
index 7fef1cf..9f359af 100644
--- a/TriviaBot/bot/GatewayHandler.cpp
+++ b/TriviaBot/bot/GatewayHandler.cpp
@@ -3,8 +3,8 @@
 #include <boost/algorithm/string.hpp>
 
 #include "APIHelper.hpp"
-#include "data_structures/User.hpp"
 #include "Logger.hpp"
+#include "data_structures/GuildMember.hpp"
 
 extern std::string bot_token;
 
@@ -64,131 +64,482 @@ void GatewayHandler::on_dispatch(json decoded, client &c, websocketpp::connectio
 	json data = decoded["d"];
 
 	if (event_name == "READY") {
-		user_object.load_from_json(data["user"]);
-
-		Logger::write("Sign-on confirmed. (@" + user_object.username + "#" + user_object.discriminator + ")", Logger::LogLevel::Info);
+		on_event_ready(data);
 	}
 	else if (event_name == "GUILD_CREATE") {
-		std::string guild_id = data["id"];
-		guilds[guild_id] = std::make_unique<DiscordObjects::Guild>(data);
-
-		Logger::write("Loaded guild: " + guilds[guild_id]->name, Logger::LogLevel::Debug);
-		
-		for (json channel : data["channels"]) {
-			std::string channel_id = channel["id"];
-			channel["guild_id"] = guild_id;
-			// create channel obj, add to overall channel list
-			channels[channel_id] = std::make_shared<DiscordObjects::Channel>(channel);
-			// add ptr to said channel list to guild's channel list
-			guilds[guild_id]->channels.push_back(std::shared_ptr<DiscordObjects::Channel>(channels[channel_id]));
-		}
-
-		if (v8_instances.count(guild_id) == 0) {
-			v8_instances[guild_id] = std::make_unique<V8Instance>(ah);
-			Logger::write("Created v8 instance for guild " + guild_id, Logger::LogLevel::Debug);
-		}
-
-		Logger::write("Loaded " + std::to_string(guilds.size()) + " guild(s)", Logger::LogLevel::Info);
+		on_event_guild_create(data);
+	}
+	else if (event_name == "GUILD_UPDATE") {
+		on_event_guild_update(data);
+	}
+	else if (event_name == "GUILD_DELETE") {
+		on_event_guild_delete(data);
+	}
+	else if (event_name == "GUILD_MEMBER_ADD") {
+		on_event_guild_member_add(data);
+	}
+	else if (event_name == "GUILD_MEMBER_UPDATE") {
+		on_event_guild_member_update(data);
+	}
+	else if (event_name == "GUILD_MEMBER_REMOVE") {
+		on_event_guild_member_remove(data);
+	}
+	else if (event_name == "GUILD_ROLE_CREATE") {
+		on_event_guild_role_create(data);
+	}
+	else if (event_name == "GUILD_ROLE_UPDATE") {
+		on_event_guild_role_update(data);
+	}
+	else if (event_name == "GUILD_ROLE_DELETE") {
+		on_event_guild_role_delete(data);
+	}
+	else if (event_name == "CHANNEL_CREATE") {
+		on_event_channel_create(data);
+	}
+	else if (event_name == "CHANNEL_UPDATE") {
+		on_event_channel_update(data);
+	}
+	else if (event_name == "CHANNEL_DELETE") {
+		on_event_channel_delete(data);
 	}
-	else if (event_name == "TYPING_START") {}
 	else if (event_name == "MESSAGE_CREATE") {
-		std::string message = data["content"];
-		auto channel = channels[data["channel_id"]];
+		on_event_message_create(data);
+	}
+}
 
-		DiscordObjects::User sender(data["author"]);
+void GatewayHandler::on_event_ready(json data) {
+	user_object.load_from_json(data["user"]);
 
-		std::vector<std::string> words;
-		boost::split(words, message, boost::is_any_of(" "));
-		Command custom_command;
-		if (words[0] == "`trivia" || words[0] == "`t") {
-			int questions = 10;
-			int delay = 8;
+	Logger::write("Sign-on confirmed. (@" + user_object.username + "#" + user_object.discriminator + ")", Logger::LogLevel::Info);
+}
 
-			if (words.size() > 3) {
-				ah->send_message(channel->id, ":exclamation: Invalid arguments!");
+void GatewayHandler::on_event_guild_create(json data) {
+	guilds[data["id"]] = DiscordObjects::Guild(data);
+	DiscordObjects::Guild &guild = guilds[data["id"]];
+
+	Logger::write("Loaded guild " + guild.id + ", now in " + std::to_string(guilds.size()) + " guild(s)", Logger::LogLevel::Info);
+
+	int channels_added = 0, roles_added = 0, members_added = 0;
+
+	for (json channel : data["channels"]) {
+		std::string channel_id = channel["id"];
+		channel["guild_id"] = guild.id;
+
+		channels[channel_id] = DiscordObjects::Channel(channel);
+		guilds[guild.id].channels.push_back(&channels[channel_id]);
+
+		channels_added++;
+	}
+	for (json role : data["roles"]) {
+		std::string role_id = role["id"];
+
+		roles[role_id] = DiscordObjects::Role(role);
+		guilds[guild.id].roles.push_back(&roles[role_id]);
+
+		roles_added++;
+	}
+	for (json member : data["members"]) {
+		std::string user_id = member["user"]["id"];
+
+		auto it = users.find(user_id);
+		if (it == users.end()) { // new user
+			users[user_id] = DiscordObjects::User(member["user"]);
+		}
+		users[user_id].guilds.push_back(guild.id);
+
+		DiscordObjects::GuildMember guild_member(member, &users[user_id]);
+		for (std::string role_id : member["roles"]) {
+			guild_member.roles.push_back(&roles[role_id]);
+		}
+
+		guilds[guild.id].members.push_back(guild_member);
+	}
+
+	if (v8_instances.count(guild.id) == 0) {
+		v8_instances[guild.id] = std::make_unique<V8Instance>(ah);
+		Logger::write("Created v8 instance for guild " + guild.id, Logger::LogLevel::Debug);
+	}
+
+	Logger::write("Loaded " + std::to_string(channels_added) + " channels, " + std::to_string(roles_added) 
+		+ " roles and " + std::to_string(members_added) + " members to guild " + guild.id, Logger::LogLevel::Debug);
+}
+
+void GatewayHandler::on_event_guild_update(json data) {
+	std::string guild_id = data["id"];
+
+	guilds[guild_id].load_from_json(data);
+	Logger::write("Updated guild " + guild_id, Logger::LogLevel::Debug);
+}
+
+void GatewayHandler::on_event_guild_delete(json data) {
+	std::string guild_id = data["id"];
+	bool unavailable = data.value("unavailable", false);
+
+	if (unavailable) {
+		Logger::write("Guild " + guild_id + " has become unavailable", Logger::LogLevel::Info);
+		guilds[guild_id].unavailable = true;
+	} else {
+		int channels_removed = 0;
+		for (auto it = channels.cbegin(); it != channels.cend();) {
+			if (it->second.guild_id == guild_id) {
+				channels.erase(it++);
+				channels_removed++;
+			} else {
+				++it;
+			}
+		}
+
+		guilds.erase(guilds.find(guild_id));
+		Logger::write("Guild " + guild_id + " and " + std::to_string(channels_removed) + " channels removed", Logger::LogLevel::Info);
+	}
+}
+
+void GatewayHandler::on_event_guild_member_add(json data) {
+	std::string guild_id = data["guild_id"];
+	std::string user_id = data["user"]["id"];
+
+	auto it = users.find(user_id);
+	if (it == users.end()) { // new user
+		users[user_id] = DiscordObjects::User(data["user"]);
+	}
+	users[user_id].guilds.push_back(guild_id);
+
+	DiscordObjects::GuildMember guild_member(data, &users[user_id]);
+	for (std::string role_id : data["roles"]) {
+		guild_member.roles.push_back(&roles[role_id]);
+	}
+
+	guilds[guild_id].members.push_back(guild_member);
+
+	Logger::write("Added new member " + guild_member.user->id + " to guild " + guild_id, Logger::LogLevel::Debug);
+}
+
+void GatewayHandler::on_event_guild_member_update(json data) {
+	std::cout << data.dump(4) << std::endl;
+
+	std::string user_id = data["user"]["id"];
+	DiscordObjects::Guild &guild = guilds[data["guild_id"]];
+
+	auto it = std::find_if(guild.members.begin(), guild.members.begin(), [user_id](const DiscordObjects::GuildMember &gm) {
+		return gm.user->id == user_id;
+	});
+	if (it != guild.members.end()) {
+		bool nick_changed = false;
+		size_t roles_change = 0;
+
+		std::string nick = data.value("nick", it->nick);
+		if (it->nick != nick) {
+			it->nick = nick;
+			nick_changed = true;
+		}
+
+		roles_change = it->roles.size();
+		it->roles.clear(); // reset and re-fill, changing the differences is probably more expensive anyway.
+		for (std::string role_id : data["roles"]) {
+			it->roles.push_back(&roles[role_id]);
+		}
+		roles_change = it->roles.size() - roles_change;
+		
+		std::string debug_string = "Updated member " + user_id + " of guild " + guild.id;
+		if (nick_changed) debug_string += ". Nick changed to " + nick;
+		if (roles_change != 0) debug_string += ". No. of roles changed by " + std::to_string(roles_change);
+		debug_string += ".";
+
+		Logger::write(debug_string, Logger::LogLevel::Debug);
+	}
+	else {
+		Logger::write("Tried to update member " + user_id + " (of guild " + guild.id + ") who does not exist.", Logger::LogLevel::Warning);
+	}
+}
+
+void GatewayHandler::on_event_guild_member_remove(json data) {
+	DiscordObjects::Guild &guild = guilds[data["guild_id"]];
+	std::string user_id = data["user"]["id"];
+
+	auto it = std::find_if(guild.members.begin(), guild.members.begin(), [user_id](const DiscordObjects::GuildMember &gm) {
+		return gm.user->id == user_id;
+	});
+
+	if (it != guilds[guild.id].members.end()) {
+		guild.members.erase(it);
+		
+		DiscordObjects::User &user = users[user_id];
+		user.guilds.erase(std::remove(user.guilds.begin(), user.guilds.end(), user.id));
+
+		if (user.guilds.size() == 0) {
+			users.erase(users.find(user_id));
+			Logger::write("User " + user_id + " removed from guild " + guild.id + " and no longer visible, deleted.", Logger::LogLevel::Debug);
+		}
+		else {
+			Logger::write("User " + user_id + " removed from guild " + guild.id, Logger::LogLevel::Debug);
+		}
+	}
+	else {
+		Logger::write("Tried to remove guild member " + user_id + " which doesn't exist", Logger::LogLevel::Warning);
+	}
+}
+
+void GatewayHandler::on_event_guild_role_create(json data) {
+	std::string role_id = data["role"]["id"];
+	std::string guild_id = data["guild_id"];
+	roles[role_id] = DiscordObjects::Role(data["role"]);
+
+	guilds[guild_id].roles.push_back(&roles[role_id]);
+
+	Logger::write("Created role " + role_id + " on guild " + guild_id, Logger::LogLevel::Debug);
+}
+
+void GatewayHandler::on_event_guild_role_update(json data) {
+	std::string role_id = data["role"]["id"];
+
+	roles[role_id].load_from_json(data["role"]);
+}
+
+void GatewayHandler::on_event_guild_role_delete(json data) {
+	std::string role_id = data["role_id"];
+	auto it = roles.find(role_id);
+
+	if (it != roles.end()) {
+		DiscordObjects::Role &role = roles[role_id];
+		DiscordObjects::Guild &guild = guilds[data["guild_id"]];
+
+		auto check_lambda = [role_id](const DiscordObjects::Role *r) {
+			return r->id == role_id;
+		};
+
+		auto it2 = std::find_if(guild.roles.begin(), guild.roles.end(), check_lambda);
+		if (it2 != guild.roles.end()) {
+			guild.roles.erase(it2);
+		}
+		else {
+			Logger::write("Tried to delete role " + role_id + " from guild " + guild.id + " but it doesn't exist there", Logger::LogLevel::Warning);
+		}
+
+		roles.erase(it);
+		Logger::write("Deleted role " + role_id + " (guild " + guild.id + ").", Logger::LogLevel::Debug);
+	}
+	else {
+		Logger::write("Tried to delete role " + role_id + " but it doesn't exist.", Logger::LogLevel::Warning);
+	}
+}
+
+void GatewayHandler::on_event_channel_create(json data) {
+	std::string channel_id = data["id"];
+	std::string guild_id = data["guild_id"];
+
+	channels[channel_id] = DiscordObjects::Channel(data);
+	Logger::write("Added channel " + channel_id + " to channel list. Now " + std::to_string(channels.size()) + " channels stored", Logger::LogLevel::Debug);
+	guilds[guild_id].channels.push_back(&channels[channel_id]);
+	Logger::write("Added channel " + channel_id + " to guild " + guild_id + "'s list. Now " + std::to_string(guilds[guild_id].channels.size()) + " channels stored", Logger::LogLevel::Debug);
+}
+
+void GatewayHandler::on_event_channel_update(json data) {
+	std::cout << "Update: " << data.dump(4) << std::endl;
+
+	std::string channel_id = data["id"];
+
+	auto it = channels.find(channel_id);
+	if (it == channels.end()) {
+		Logger::write("Got channel update for channel " + channel_id + " that doesn't exist. Creating channel instead.", Logger::LogLevel::Warning);
+		on_event_channel_create(data);
+	} else {
+		channels[channel_id].load_from_json(data);
+		Logger::write("Updated channel " + channel_id, Logger::LogLevel::Debug);
+	}
+}
+
+void GatewayHandler::on_event_channel_delete(json data) {
+	std::cout << "Delete: " << data.dump(4) << std::endl;
+
+	std::string channel_id = data["id"];
+	std::string guild_id = data["guild_id"];
+
+	auto it = channels.find(channel_id);
+	if (it == channels.end()) {
+		Logger::write("Tried to delete channel " + channel_id + " which doesn't exist", Logger::LogLevel::Warning);
+	}
+	else {
+		auto it2 = std::find_if(guilds[guild_id].channels.begin(), guilds[guild_id].channels.begin(), [channel_id](const DiscordObjects::Channel *c) {
+			return c->id == channel_id;
+		});
+		guilds[guild_id].channels.erase(it2);
+		Logger::write("Removed channel " + channel_id + " from guild " + guild_id + "'s list. Now " 
+			+ std::to_string(guilds[guild_id].channels.size()) + " channels stored", Logger::LogLevel::Debug);
+
+		channels.erase(it);
+		Logger::write("Removed channel " + channel_id + " from channel list. Now " + std::to_string(channels.size()) + " channels stored.", Logger::LogLevel::Debug);
+	}
+}
+
+void GatewayHandler::on_event_message_create(json data) {
+	std::string message = data["content"];
+	auto channel = channels[data["channel_id"]];
+
+	DiscordObjects::User sender(data["author"]);
+
+	std::vector<std::string> words;
+	boost::split(words, message, boost::is_any_of(" "));
+	Command custom_command;
+	if (words[0] == "`trivia" || words[0] == "`t") {
+		int questions = 10;
+		int delay = 8;
+
+		if (words.size() > 3) {
+			ah->send_message(channel.id, ":exclamation: Invalid arguments!");
+			return;
+		}
+		else  if (words.size() > 1) {
+			if (words[1] == "help" || words[1] == "h") {
+				std::string help = "**Base command \\`t[rivia]**. Arguments:\n";
+				help += "\\`trivia **{x}** **{y}**: Makes the game last **x** number of questions, optionally sets the time interval between hints to **y** seconds\n";
+				help += "\\`trivia **stop**: stops the ongoing game.\n";
+				help += "\\`trivia **help**: prints this message\n";
+
+				ah->send_message(channel.id, help);
 				return;
 			}
-			else  if(words.size() > 1) {
-				if (words[1] == "help" || words[1] == "h") {
-					std::string help = "**Base command \\`t[rivia]**. Arguments:\n";
-					help += "\\`trivia **{x}** **{y}**: Makes the game last **x** number of questions, optionally sets the time interval between hints to **y** seconds\n";
-					help += "\\`trivia **stop**: stops the ongoing game.\n";
-					help += "\\`trivia **help**: prints this message\n";
-
-					ah->send_message(channel->id, help);
+			else if (words[1] == "stop" || words[1] == "s") {
+				if (games.find(channel.id) != games.end()) {
+					delete_game(channel.id);
 					return;
 				}
-				else if (words[1] == "stop" || words[1] == "s") {
-					if (games.find(channel->id) != games.end()) {
-						delete_game(channel->id);
-						return;
+			}
+			else {
+				try {
+					questions = std::stoi(words[1]);
+					if (words.size() == 3) {
+						delay = std::stoi(words[2]);
 					}
 				}
+				catch (std::invalid_argument e) {
+					ah->send_message(channel.id, ":exclamation: Invalid arguments!");
+					return;
+				}
+			}
+		}
+
+		games[channel.id] = std::make_unique<TriviaGame>(this, ah, channel.id, questions, delay);
+		games[channel.id]->start();
+	}
+	else if (words[0] == "`guilds") {
+		std::string m = "Guild List:\n";
+		for (auto &gu : guilds) {
+			m += "> " + gu.second.name + " (" + gu.second.id + ") Channels: " + std::to_string(gu.second.channels.size()) + "\n";
+		}
+		ah->send_message(channel.id, m);
+	}
+	else if (words[0] == "`info") {
+		ah->send_message(channel.id, ":information_source: trivia-bot by Jack. <http://github.com/jackb-p/TriviaDiscord>");
+	}
+	else if (words[0] == "`js" && message.length() > 4) {
+		std::string js = message.substr(4);
+		auto it = v8_instances.find(channel.guild_id);
+		if (it != v8_instances.end() && js.length() > 0) {
+			it->second->exec_js(js, channel.id);
+		}
+	}
+	else if (words[0] == "`createjs" && message.length() > 8) {
+		std::string args = message.substr(10);
+		size_t seperator_loc = args.find("|");
+		if (seperator_loc != std::string::npos) {
+			std::string command_name = args.substr(0, seperator_loc);
+			std::string script = args.substr(seperator_loc + 1);
+			int result = command_helper->insert_command(channel.guild_id, command_name, script);
+			switch (result) {
+			case 0:
+				ah->send_message(channel.id, ":warning: Error!"); break;
+			case 1:
+				ah->send_message(channel.id, ":new: Command `" + command_name + "` successfully created."); break;
+			case 2:
+				ah->send_message(channel.id, ":arrow_heading_up: Command `" + command_name + "` successfully updated."); break;
+			}
+		}
+	}
+	else if (words[0] == "`shutdown" && sender.id == "82232146579689472") { // it me
+		ah->send_message(channel.id, ":zzz: Goodbye!");
+		// TODO: without needing c, hdl - c.close(hdl, websocketpp::close::status::going_away, "`shutdown command used.");
+	}
+	else if (words[0] == "`debug") {
+		if (words[1] == "channel" && words.size() == 3) {
+			auto it = channels.find(words[2]);
+			if (it != channels.end()) {
+				ah->send_message(channel.id, it->second.to_debug_string());
+			}
+			else {
+				ah->send_message(channel.id, ":question: Unrecognised channel.");
+			}
+		}
+		else if (words[1] == "guild" && words.size() == 3) {
+			auto it = guilds.find(words[2]);
+			if (it != guilds.end()) {
+				ah->send_message(channel.id, it->second.to_debug_string());
+			}
+			else {
+				ah->send_message(channel.id, ":question: Unrecognised guild.");
+			}
+		}
+		else if (words[1] == "member" && words.size() == 4) {
+			auto it = guilds.find(words[2]);
+			if (it != guilds.end()) {
+				std::string user_id = words[3];
+				auto it2 = std::find_if(it->second.members.begin(), it->second.members.end(), [user_id](const DiscordObjects::GuildMember &gm) {
+					return user_id == gm.user->id;
+				});
+
+				if (it2 != it->second.members.end()) {
+					ah->send_message(channel.id, it2->to_debug_string());
+				}
 				else {
-					try {
-						questions = std::stoi(words[1]);
-						if (words.size() == 3) {
-							delay = std::stoi(words[2]);
-						}
-					}
-					catch (std::invalid_argument e) {
-						ah->send_message(channel->id, ":exclamation: Invalid arguments!");
-						return;
-					}
+					ah->send_message(channel.id, ":question: Unrecognised user.");
 				}
 			}
+			else {
+				ah->send_message(channel.id, ":question: Unrecognised guild.");
+			}
+		}
+		else if (words[1] == "role" && words.size() == 3) {
+			auto it = roles.find(words[2]);
+			if (it != roles.end()) {
+				ah->send_message(channel.id, it->second.to_debug_string());
+			}
+			else {
+				ah->send_message(channel.id, ":question: Unrecognised role.");
+			}
+		}
+		else if (words[1] == "role" && words.size() == 4) {
+			std::string role_name = words[3];
 
-			games[channel->id] = std::make_unique<TriviaGame>(this, ah, channel->id, questions, delay);
-			games[channel->id]->start();
-		} 
-		else if (words[0] == "`guilds") {
-			std::string m = "Guild List:\n";
-			for (auto &gu : guilds) {
-				m += "> " + gu.second->name + " (" + gu.second->id + ") Channels: " + std::to_string(gu.second->channels.size()) + "\n";
-			}
-			ah->send_message(channel->id, m);
-		}
-		else if (words[0] == "`info") {
-			ah->send_message(channel->id, ":information_source: trivia-bot by Jack. <http://github.com/jackb-p/TriviaDiscord>");
-		}
-		else if (words[0] == "`js" && message.length() > 4) {
-			std::string js = message.substr(4);
-			auto it = v8_instances.find(channel->guild_id);
-			if (it != v8_instances.end() && js.length() > 0) {
-				it->second->exec_js(js, channel->id);
-			}
-		}
-		else if (words[0] == "`createjs" && message.length() > 8) {
-			std::string args = message.substr(10);
-			size_t seperator_loc = args.find("|");
-			if (seperator_loc != std::string::npos) {
-				std::string command_name = args.substr(0, seperator_loc);
-				std::string script = args.substr(seperator_loc + 1);
-				int result = command_helper->insert_command(channel->guild_id, command_name, script); 
-				switch (result) {
-				case 0:
-					ah->send_message(channel->id, ":warning: Error!"); break;
-				case 1:
-					ah->send_message(channel->id, ":new: Command `" + command_name + "` successfully created."); break;
-				case 2:
-					ah->send_message(channel->id, ":arrow_heading_up: Command `" + command_name + "` successfully updated."); break;
+			auto it = guilds.find(words[2]);
+			if (it != guilds.end()) {
+				auto check_lambda = [role_name](DiscordObjects::Role *r) {
+					return role_name == r->name;
+				};
+
+				auto it2 = std::find_if(it->second.roles.begin(), it->second.roles.end(), check_lambda);
+				if (it2 != it->second.roles.end()) {
+					ah->send_message(channel.id, (*it2)->to_debug_string());
+				}
+				else {
+					ah->send_message(channel.id, ":question: Unrecognised role.");
 				}
 			}
-		}
-		else if (words[0] == "`shutdown" && sender.id == "82232146579689472") { // it me
-			ah->send_message(channel->id, ":zzz: Goodbye!");
-			c.close(hdl, websocketpp::close::status::going_away, "`shutdown command used.");
-		}
-		else if (command_helper->get_command(channel->guild_id, words[0], custom_command)) {
-			auto it = v8_instances.find(channel->guild_id);
-			if (it != v8_instances.end() && custom_command.script.length() > 0) {
-				it->second->exec_js(custom_command.script, channel->id);
+			else {
+				ah->send_message(channel.id, ":question: Unrecognised guild.");
 			}
 		}
-		else if (games.find(channel->id) != games.end()) { // message received in channel with ongoing game
-			games[channel->id]->handle_answer(message, sender);
+		else {
+			ah->send_message(channel.id, ":question: Unknown parameters.");
 		}
 	}
+	else if (command_helper->get_command(channel.guild_id, words[0], custom_command)) {
+		auto it = v8_instances.find(channel.guild_id);
+		if (it != v8_instances.end() && custom_command.script.length() > 0) {
+			it->second->exec_js(custom_command.script, channel.id);
+		}
+	}
+	else if (games.find(channel.id) != games.end()) { // message received in channel with ongoing game
+		games[channel.id]->handle_answer(message, sender);
+	}
 }
 
 void GatewayHandler::identify(client &c, websocketpp::connection_hdl &hdl) {
diff --git a/TriviaBot/bot/GatewayHandler.hpp b/TriviaBot/bot/GatewayHandler.hpp
index 0b781bd..19d579c 100644
--- a/TriviaBot/bot/GatewayHandler.hpp
+++ b/TriviaBot/bot/GatewayHandler.hpp
@@ -14,6 +14,7 @@
 #include "data_structures/User.hpp"
 #include "data_structures/Guild.hpp"
 #include "data_structures/Channel.hpp"
+#include "data_structures/Role.hpp"
 
 typedef websocketpp::client<websocketpp::config::asio_tls_client> client;
 using json = nlohmann::json;
@@ -58,6 +59,27 @@ private:
 	int last_seq;
 	int heartbeat_interval;
 
+	void on_event_ready(json data);
+
+	/* guild events */
+	void on_event_guild_create(json data); // https://discordapp.com/developers/docs/topics/gateway#guild-create
+	void on_event_guild_update(json data); // https://discordapp.com/developers/docs/topics/gateway#guild-update
+	void on_event_guild_delete(json data); // https://discordapp.com/developers/docs/topics/gateway#guild-delete
+	void on_event_guild_member_add(json data); // https://discordapp.com/developers/docs/topics/gateway#guild-member-add
+	void on_event_guild_member_update(json data); // https://discordapp.com/developers/docs/topics/gateway#guild-member-update
+	void on_event_guild_member_remove(json data); // https://discordapp.com/developers/docs/topics/gateway#guild-member-remove
+	void on_event_guild_role_create(json data); // https://discordapp.com/developers/docs/topics/gateway#guild-role-create
+	void on_event_guild_role_update(json data); // https://discordapp.com/developers/docs/topics/gateway#guild-role-update
+	void on_event_guild_role_delete(json data); // https://discordapp.com/developers/docs/topics/gateway#guild-role-delete
+
+	/* channel events */
+	void on_event_channel_create(json data); // https://discordapp.com/developers/docs/topics/gateway#channel-create
+	void on_event_channel_update(json data); // https://discordapp.com/developers/docs/topics/gateway#channel-update
+	void on_event_channel_delete(json data); // https://discordapp.com/developers/docs/topics/gateway#channel-delete
+
+	/* message events */
+	void on_event_message_create(json data); // https://discordapp.com/developers/docs/topics/gateway#message-create
+
 	const int protocol_version = 5;
 
 	// bot's user obj
@@ -65,10 +87,11 @@ private:
 
 	std::unique_ptr<CommandHelper> command_helper;
 
-	// <id, ptr to data>
-	std::map<std::string, std::unique_ptr<DiscordObjects::Guild>> guilds;
-	// channels pointers are shared pointers, held here but also in guild objects
-	std::map<std::string, std::shared_ptr<DiscordObjects::Channel>> channels;
+	/* <id, obj> */
+	std::map<std::string, DiscordObjects::Guild> guilds;
+	std::map<std::string, DiscordObjects::Channel> channels;
+	std::map<std::string, DiscordObjects::User> users;
+	std::map<std::string, DiscordObjects::Role> roles;
 
 	// <channel_id, game obj>
 	std::map<std::string, std::unique_ptr<TriviaGame>> games;
diff --git a/TriviaBot/bot/TriviaBot.cpp b/TriviaBot/bot/TriviaBot.cpp
index d284b93..1a22042 100644
--- a/TriviaBot/bot/TriviaBot.cpp
+++ b/TriviaBot/bot/TriviaBot.cpp
@@ -34,13 +34,13 @@ int main(int argc, char *argv[]) {
 		conn.start(uri);
 	}
 	catch (const std::exception &e) {
-		Logger::write(e.what(), Logger::LogLevel::Severe);
+		Logger::write("std exception: " + std::string(e.what()), Logger::LogLevel::Severe);
 	}
 	catch (websocketpp::lib::error_code e) {
-		Logger::write(e.message(), Logger::LogLevel::Severe);
+		Logger::write("websocketpp exception: " + e.message(), Logger::LogLevel::Severe);
 	}
 	catch (...) {
-		Logger::write("Other exception.", Logger::LogLevel::Severe);
+		Logger::write("other exception.", Logger::LogLevel::Severe);
 	}
 
 	v8::V8::Dispose();
@@ -51,5 +51,8 @@ int main(int argc, char *argv[]) {
 
 	Logger::write("Cleaned up", Logger::LogLevel::Info);
 
+	std::cout << "Press enter to exit" << std::endl;
+	std::getchar();
+
 	return 0;
 }
\ No newline at end of file
diff --git a/TriviaBot/bot/data_structures/Channel.hpp b/TriviaBot/bot/data_structures/Channel.hpp
index 9aef03d..1529db3 100644
--- a/TriviaBot/bot/data_structures/Channel.hpp
+++ b/TriviaBot/bot/data_structures/Channel.hpp
@@ -32,6 +32,7 @@ namespace DiscordObjects {
 		Channel(json data);
 
 		void load_from_json(json data);
+		std::string to_debug_string();
 
 		bool operator==(Channel rhs);
 
@@ -73,6 +74,19 @@ namespace DiscordObjects {
 		user_limit = data.value("user_limit", -1);
 	}
 
+	inline std::string Channel::to_debug_string() {
+		return "**__Channel " + id + "__**"
+			+ "\n**guild_id:** " + guild_id
+			+ "\n**name:** " + name
+			+ "\n**type:** " + type
+			+ "\n**position:** " + std::to_string(position)
+			+ "\n**is_private:** " + std::to_string(is_private)
+			+ "\n**topic:** " + (topic == "" ? "[empty]" : topic)
+			+ "\n**last_message_id:** " + last_message_id
+			+ "\n**bitrate:** " + std::to_string(bitrate)
+			+ "\n**user_limit:** " + std::to_string(user_limit);
+	}
+
 	inline bool Channel::operator==(Channel rhs) {
 		return id == rhs.id && id != "null";
 	}
diff --git a/TriviaBot/bot/data_structures/Guild.hpp b/TriviaBot/bot/data_structures/Guild.hpp
index 933d082..78ab956 100644
--- a/TriviaBot/bot/data_structures/Guild.hpp
+++ b/TriviaBot/bot/data_structures/Guild.hpp
@@ -1,13 +1,15 @@
-#ifndef BOT_DATA__STRUCTURES_Guild
-#define BOT_DATA__STRUCTURES_Guild
+#ifndef BOT_DATA__STRUCTURES_GUILD
+#define BOT_DATA__STRUCTURES_GUILD
 
 #include <string>
-#include <memory>
+#include <vector>
 
 #include "../json/json.hpp"
 
 #include "Channel.hpp"
 #include "User.hpp"
+#include "Role.hpp"
+#include "GuildMember.hpp"
 
 using json = nlohmann::json;
 
@@ -48,6 +50,7 @@ namespace DiscordObjects {
 		Guild(json data);
 
 		void load_from_json(json data);
+		std::string to_debug_string();
 
 		bool operator==(Guild rhs);
 
@@ -62,13 +65,15 @@ namespace DiscordObjects {
 		// bool        embed_enabled;
 		// std::string	embed_channel_id;
 		int         verification_level;
-		// TODO: Implement all guil fields
+		// TODO: Implement all guild fields
 		// std::vector<?> voice_states
-		// std::vector<?> roles
 		// std::vector<?> emojis
 		// std::vector<?> features
+		bool unavailable;
 
-		std::vector<std::shared_ptr<Channel>> channels;
+		std::vector<Channel *> channels;
+		std::vector<GuildMember> members;
+		std::vector<Role *> roles;
 		//std::vector<std::unique_ptr<DiscordObjects::User>>    users;
 	};
 
@@ -93,6 +98,23 @@ namespace DiscordObjects {
 		afk_channel_id = data.value("afk_channel_id", "null");
 		afk_timeout = data.value("afk_timeout", -1);
 		verification_level = data.value("verification_level", -1);
+		unavailable = data.value("unavailable", false);
+	}
+
+	inline std::string Guild::to_debug_string() {
+		return "**__Guild " + id + "__**"
+			+ "\n**name:** " + name
+			+ "\n**icon:** " + icon
+			+ "\n**splash:** " + splash
+			+ "\n**owner_id:** " + owner_id
+			+ "\n**region:** " + region
+			+ "\n**afk_channel_id:** " + afk_channel_id
+			+ "\n**afk_timeout:** " + std::to_string(afk_timeout)
+			+ "\n**verification_level:** " + std::to_string(verification_level)
+			+ "\n**unavailable:** " + std::to_string(unavailable)
+			+ "\n**channels:** " + std::to_string(channels.size())
+			+ "\n**roles:** " + std::to_string(roles.size())
+			+ "\n**members:** " + std::to_string(members.size());
 	}
 
 	inline bool Guild::operator==(Guild rhs) {
diff --git a/TriviaBot/bot/data_structures/GuildMember.hpp b/TriviaBot/bot/data_structures/GuildMember.hpp
new file mode 100644
index 0000000..0997c21
--- /dev/null
+++ b/TriviaBot/bot/data_structures/GuildMember.hpp
@@ -0,0 +1,68 @@
+#ifndef BOT_DATA__STRUCTURES_GUILDMEMBER
+#define BOT_DATA__STRUCTURES_GUILDMEMBER
+
+#include <string>
+#include <vector>
+
+#include "../json/json.hpp"
+
+#include "User.hpp"
+#include "Role.hpp"
+
+namespace DiscordObjects {
+	class GuildMember {
+	public:
+		GuildMember();
+		GuildMember(json data, User *user);
+
+		void load_from_json(json data);
+		std::string to_debug_string();
+
+		bool operator==(GuildMember rhs);
+
+		User *user;
+		std::string nick;
+		std::vector<Role *> roles;
+		std::string joined_at; // TODO: better type
+		bool deaf;
+		bool mute;
+	};
+
+	inline GuildMember::GuildMember() {
+		user = nullptr;
+		nick = "null";
+		joined_at = "null";
+		deaf = false;
+		mute = false;
+	}
+
+	inline GuildMember::GuildMember(json data, User *user) {
+		this->user = user;
+		load_from_json(data);
+	}
+
+	inline void GuildMember::load_from_json(json data) {
+		nick = data.value("nick", "null");
+		joined_at = data.value("joined_at", "null");
+		deaf = data.value("deaf", false);
+		mute = data.value("mute", false);
+	}
+
+	inline std::string GuildMember::to_debug_string() {
+		return "**__GuildMember " + user->id + "__**"
+			+ "\n**mention:** <@" + user->id + "> / " + user->username + "#" + user->discriminator
+			+ "\n**bot:** " + std::to_string(user->bot)
+			+ "\n**mfa_enabled:** " + std::to_string(user->mfa_enabled)
+			+ "\n**avatar:** " + user->avatar
+			+ "\n**nick:** " + nick
+			+ "\n**joined_at:** " + joined_at
+			+ "\n**deaf:** " + std::to_string(deaf)
+			+ "\n**mute:** " + std::to_string(mute);
+	}
+
+	inline bool GuildMember::operator==(GuildMember rhs) {
+		return user->id == rhs.user->id;
+	}
+}
+
+#endif
\ No newline at end of file
diff --git a/TriviaBot/bot/data_structures/Role.hpp b/TriviaBot/bot/data_structures/Role.hpp
new file mode 100644
index 0000000..3776e06
--- /dev/null
+++ b/TriviaBot/bot/data_structures/Role.hpp
@@ -0,0 +1,118 @@
+#ifndef BOT_DATA__STRUCTURES_ROLE
+#define BOT_DATA__STRUCTURES_ROLE
+
+#include <string>
+#include <sstream>
+#include <iomanip>
+
+#include "../json/json.hpp"
+
+using json = nlohmann::json;
+
+namespace DiscordObjects {
+
+	class Role {
+	public:
+		Role();
+		Role(json data);
+
+		void load_from_json(json data);
+		std::string to_debug_string();
+
+		bool operator==(Role rhs);
+
+		std::string id;
+		std::string name;
+		int colour;
+		bool hoist;
+		int position;
+		int permissions;
+		bool managed;
+		bool mentionable;
+	};
+
+	inline Role::Role() {
+		id = "null";
+		name = "null";
+		colour = -1;
+		hoist = false;
+		position = -1;
+		permissions = 0;
+		managed = false;
+		mentionable = false;
+	}
+
+	inline Role::Role(json data) {
+		load_from_json(data);
+	}
+
+	inline void Role::load_from_json(json data) {
+		id = data.value("id", "null");
+		name = data.value("name", "null");
+		colour = data.value("color", -1);
+		hoist = data.value("hoist", false);
+		position = data.value("position", -1);
+		permissions = data.value("permissions", 0);
+		managed = data.value("managed", false);
+		mentionable = data.value("mentionable", false);
+	}
+
+	inline std::string Role::to_debug_string() {
+		std::stringstream colour_ss;
+		colour_ss << std::setw(6) << std::setfill('0') << colour;
+		std::string colour_str = colour_ss.str();
+
+		return "**__Role " + id + "__**"
+			+ "\n**name:** " + name
+			+ "\n**colour:** #" + colour_str
+			+ "\n**hoist:** " + std::to_string(hoist)
+			+ "\n**position:** " + std::to_string(position)
+			+ "\n**permissions:** " + std::to_string(permissions)
+			+ "\n**managed:** " + std::to_string(managed)
+			+ "\n**mentionable:** " + std::to_string(mentionable);
+	}
+
+	inline bool Role::operator==(Role rhs) {
+		return id == rhs.id;
+	}
+
+
+	/* permission values */
+	enum class Permission {
+		CreateInstantInvite = 0x00000001, // Allows creation of instant invites
+		KickMembers = 0x00000002, // Allows kicking members
+		BanMembers = 0x00000004, // Allows banning members
+		Administrator = 0x00000008, // Allows all permissions and bypasses channel permission overwrites
+		ManageChannels = 0x00000010, // Allows management and editing of channels
+		ManageGuild = 0x00000020, // Allows management and editing of the guild
+		ReadMessages = 0x00000400, // Allows reading messages in a channel.The channel will not appear for users without this permission
+		SendMessages = 0x00000800, // Allows for sending messages in a channel.
+		SendTTSMessages = 0x00001000, // Allows for sending of / tts messages
+		ManageMessages = 0x00002000, // Allows for deletion of other users messages
+		EmbedLinks = 0x00004000, // Links sent by this user will be auto - embedded
+		AttachFiles = 0x00008000, // Allows for uploading images and files
+		ReadMessageHistory = 0x00010000, // Allows for reading of message history
+		MentionEveryone = 0x00020000, // Allows for using the @everyone tag to notify all users in a channel, and the @here tag to notify all online users in a channel
+		Connect = 0x00100000, // Allows for joining of a voice channel
+		Speak = 0x00200000, // Allows for speaking in a voice channel
+		MuteMembers = 0x00400000, // Allows for muting members in a voice channel
+		DeafenMembers = 0x00800000, // Allows for deafening of members in a voice channel
+		MoveMembers = 0x01000000, // Allows for moving of members between voice channels
+		UseVAD = 0x02000000, // Allows for using voice - activity - detection in a voice channel
+		ChangeNickname = 0x04000000, // Allows for modification of own nickname
+		ManageNicknames = 0x08000000, // Allows for modification of other users nicknames
+		ManageRoles = 0x10000000 // Allows management and editing of roles
+	};
+
+	/* implement bitwise operators */
+	inline Permission operator|(Permission lhs, Permission rhs) {
+		return static_cast<Permission>(static_cast<int>(lhs) | static_cast<int>(rhs));
+	}
+
+	inline Permission operator|=(Permission &lhs, Permission rhs) {
+		lhs = static_cast<Permission>(static_cast<int>(lhs) | static_cast<int>(rhs));
+		return lhs;
+	}
+}
+
+#endif
\ No newline at end of file
diff --git a/TriviaBot/bot/data_structures/User.hpp b/TriviaBot/bot/data_structures/User.hpp
index 1bc36e8..546a1fc 100644
--- a/TriviaBot/bot/data_structures/User.hpp
+++ b/TriviaBot/bot/data_structures/User.hpp
@@ -2,6 +2,7 @@
 #define BOT_DATA__STRUCTURES_USER
 
 #include <string>
+#include <vector>
 
 #include "../json/json.hpp"
 
@@ -37,6 +38,8 @@ namespace DiscordObjects {
 		std::string avatar;
 		bool bot;
 		bool mfa_enabled;
+
+		std::vector<std::string> guilds;
 	};
 
 	inline User::User() {

From f47d8adc360e480258d146ed5f99dc9e6ef04272 Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Fri, 5 Aug 2016 22:32:47 +0100
Subject: [PATCH 08/15] Most of Boobot's JS object implementation

---
 TriviaBot/bot/APIHelper.cpp             |  16 ++
 TriviaBot/bot/GatewayHandler.cpp        |  65 ++++---
 TriviaBot/bot/data_structures/Guild.hpp |   3 +-
 TriviaBot/bot/data_structures/Role.hpp  |   6 +-
 TriviaBot/bot/data_structures/Text.txt  | 125 ------------
 TriviaBot/bot/js/V8Instance.cpp         | 240 ++++++++++++++++++++++--
 TriviaBot/bot/js/V8Instance.hpp         |  48 ++++-
 7 files changed, 319 insertions(+), 184 deletions(-)
 delete mode 100644 TriviaBot/bot/data_structures/Text.txt

diff --git a/TriviaBot/bot/APIHelper.cpp b/TriviaBot/bot/APIHelper.cpp
index 5df8e88..a6633ee 100644
--- a/TriviaBot/bot/APIHelper.cpp
+++ b/TriviaBot/bot/APIHelper.cpp
@@ -17,6 +17,22 @@ APIHelper::APIHelper() : BASE_URL("https://discordapp.com/api"), CHANNELS_URL(BA
 void APIHelper::send_message(std::string channel_id, std::string message) {
 	if (message == "") {
 		Logger::write("[send_message] Tried to send empty message", Logger::LogLevel::Warning);
+		return;
+	}
+
+	if (message.length() > 4000) {
+		Logger::write("[send_message] Tried to send a message over 4000 characters", Logger::LogLevel::Warning);
+		return;
+	}
+	else if (message.length() > 2000) {
+		std::cout << message.length() << std::endl;
+
+		std::string first = message.substr(0, 2000);
+		std::string second = message.substr(2000);
+		send_message(channel_id, first);
+		std::this_thread::sleep_for(50ms);
+		send_message(channel_id, second);
+		return;
 	}
 
 	const std::string url = CHANNELS_URL + "/" + channel_id + "/messages";
diff --git a/TriviaBot/bot/GatewayHandler.cpp b/TriviaBot/bot/GatewayHandler.cpp
index 9f359af..092f10c 100644
--- a/TriviaBot/bot/GatewayHandler.cpp
+++ b/TriviaBot/bot/GatewayHandler.cpp
@@ -152,11 +152,11 @@ void GatewayHandler::on_event_guild_create(json data) {
 			guild_member.roles.push_back(&roles[role_id]);
 		}
 
-		guilds[guild.id].members.push_back(guild_member);
+		guilds[guild.id].members[user_id] = guild_member;
 	}
 
 	if (v8_instances.count(guild.id) == 0) {
-		v8_instances[guild.id] = std::make_unique<V8Instance>(ah);
+		v8_instances[guild.id] = std::make_unique<V8Instance>(guild.id, ah, &guilds, &channels, &users, &roles);
 		Logger::write("Created v8 instance for guild " + guild.id, Logger::LogLevel::Debug);
 	}
 
@@ -209,36 +209,32 @@ void GatewayHandler::on_event_guild_member_add(json data) {
 		guild_member.roles.push_back(&roles[role_id]);
 	}
 
-	guilds[guild_id].members.push_back(guild_member);
+	guilds[guild_id].members[user_id] = guild_member;
 
 	Logger::write("Added new member " + guild_member.user->id + " to guild " + guild_id, Logger::LogLevel::Debug);
 }
 
 void GatewayHandler::on_event_guild_member_update(json data) {
-	std::cout << data.dump(4) << std::endl;
-
 	std::string user_id = data["user"]["id"];
 	DiscordObjects::Guild &guild = guilds[data["guild_id"]];
 
-	auto it = std::find_if(guild.members.begin(), guild.members.begin(), [user_id](const DiscordObjects::GuildMember &gm) {
-		return gm.user->id == user_id;
-	});
+	auto it = guild.members.find(user_id);
 	if (it != guild.members.end()) {
 		bool nick_changed = false;
 		size_t roles_change = 0;
 
-		std::string nick = data.value("nick", it->nick);
-		if (it->nick != nick) {
-			it->nick = nick;
+		std::string nick = data.value("nick", "null");
+		if (it->second.nick != nick) {
+			it->second.nick = nick;
 			nick_changed = true;
 		}
 
-		roles_change = it->roles.size();
-		it->roles.clear(); // reset and re-fill, changing the differences is probably more expensive anyway.
+		roles_change = it->second.roles.size();
+		it->second.roles.clear(); // reset and re-fill, changing the differences is probably more expensive anyway.
 		for (std::string role_id : data["roles"]) {
-			it->roles.push_back(&roles[role_id]);
+			it->second.roles.push_back(&roles[role_id]);
 		}
-		roles_change = it->roles.size() - roles_change;
+		roles_change = it->second.roles.size() - roles_change;
 		
 		std::string debug_string = "Updated member " + user_id + " of guild " + guild.id;
 		if (nick_changed) debug_string += ". Nick changed to " + nick;
@@ -256,15 +252,12 @@ void GatewayHandler::on_event_guild_member_remove(json data) {
 	DiscordObjects::Guild &guild = guilds[data["guild_id"]];
 	std::string user_id = data["user"]["id"];
 
-	auto it = std::find_if(guild.members.begin(), guild.members.begin(), [user_id](const DiscordObjects::GuildMember &gm) {
-		return gm.user->id == user_id;
-	});
-
+	auto it = guild.members.find(user_id);
 	if (it != guilds[guild.id].members.end()) {
 		guild.members.erase(it);
 		
 		DiscordObjects::User &user = users[user_id];
-		user.guilds.erase(std::remove(user.guilds.begin(), user.guilds.end(), user.id));
+		user.guilds.erase(std::remove(user.guilds.begin(), user.guilds.end(), guild.id));
 
 		if (user.guilds.size() == 0) {
 			users.erase(users.find(user_id));
@@ -275,7 +268,7 @@ void GatewayHandler::on_event_guild_member_remove(json data) {
 		}
 	}
 	else {
-		Logger::write("Tried to remove guild member " + user_id + " which doesn't exist", Logger::LogLevel::Warning);
+		Logger::write("Tried to remove guild member " + user_id + " who doesn't exist", Logger::LogLevel::Warning);
 	}
 }
 
@@ -373,9 +366,12 @@ void GatewayHandler::on_event_channel_delete(json data) {
 
 void GatewayHandler::on_event_message_create(json data) {
 	std::string message = data["content"];
-	auto channel = channels[data["channel_id"]];
 
-	DiscordObjects::User sender(data["author"]);
+	DiscordObjects::Channel &channel = channels[data["channel_id"]];
+	DiscordObjects::Guild &guild = guilds[channel.guild_id];
+	DiscordObjects::GuildMember &sender = guild.members[data["author"]["id"]];
+
+	if (sender.user->bot) return; // ignore bots to prevent looping
 
 	std::vector<std::string> words;
 	boost::split(words, message, boost::is_any_of(" "));
@@ -431,14 +427,14 @@ void GatewayHandler::on_event_message_create(json data) {
 	else if (words[0] == "`info") {
 		ah->send_message(channel.id, ":information_source: trivia-bot by Jack. <http://github.com/jackb-p/TriviaDiscord>");
 	}
-	else if (words[0] == "`js" && message.length() > 4) {
+	else if (words[0] == "~js" && message.length() > 4) {
 		std::string js = message.substr(4);
 		auto it = v8_instances.find(channel.guild_id);
 		if (it != v8_instances.end() && js.length() > 0) {
-			it->second->exec_js(js, channel.id);
+			it->second->exec_js(js, &channel, &sender);
 		}
 	}
-	else if (words[0] == "`createjs" && message.length() > 8) {
+	else if (words[0] == "~createjs" && message.length() > 8) {
 		std::string args = message.substr(10);
 		size_t seperator_loc = args.find("|");
 		if (seperator_loc != std::string::npos) {
@@ -455,7 +451,7 @@ void GatewayHandler::on_event_message_create(json data) {
 			}
 		}
 	}
-	else if (words[0] == "`shutdown" && sender.id == "82232146579689472") { // it me
+	else if (words[0] == "`shutdown" && sender.user->id == "82232146579689472") { // it me
 		ah->send_message(channel.id, ":zzz: Goodbye!");
 		// TODO: without needing c, hdl - c.close(hdl, websocketpp::close::status::going_away, "`shutdown command used.");
 	}
@@ -482,12 +478,10 @@ void GatewayHandler::on_event_message_create(json data) {
 			auto it = guilds.find(words[2]);
 			if (it != guilds.end()) {
 				std::string user_id = words[3];
-				auto it2 = std::find_if(it->second.members.begin(), it->second.members.end(), [user_id](const DiscordObjects::GuildMember &gm) {
-					return user_id == gm.user->id;
-				});
 
+				auto it2 = it->second.members.find(user_id);
 				if (it2 != it->second.members.end()) {
-					ah->send_message(channel.id, it2->to_debug_string());
+					ah->send_message(channel.id, it2->second.to_debug_string());
 				}
 				else {
 					ah->send_message(channel.id, ":question: Unrecognised user.");
@@ -532,13 +526,18 @@ void GatewayHandler::on_event_message_create(json data) {
 		}
 	}
 	else if (command_helper->get_command(channel.guild_id, words[0], custom_command)) {
+		std::string args = "";
+		if (message.length() > (words[0].length() + 1)) {
+			args = message.substr(words[0].length() + 1);
+		}
+
 		auto it = v8_instances.find(channel.guild_id);
 		if (it != v8_instances.end() && custom_command.script.length() > 0) {
-			it->second->exec_js(custom_command.script, channel.id);
+			it->second->exec_js(custom_command.script, &channel, &sender, args);
 		}
 	}
 	else if (games.find(channel.id) != games.end()) { // message received in channel with ongoing game
-		games[channel.id]->handle_answer(message, sender);
+		games[channel.id]->handle_answer(message, *sender.user);
 	}
 }
 
diff --git a/TriviaBot/bot/data_structures/Guild.hpp b/TriviaBot/bot/data_structures/Guild.hpp
index 78ab956..aa90a44 100644
--- a/TriviaBot/bot/data_structures/Guild.hpp
+++ b/TriviaBot/bot/data_structures/Guild.hpp
@@ -3,6 +3,7 @@
 
 #include <string>
 #include <vector>
+#include <map>
 
 #include "../json/json.hpp"
 
@@ -72,7 +73,7 @@ namespace DiscordObjects {
 		bool unavailable;
 
 		std::vector<Channel *> channels;
-		std::vector<GuildMember> members;
+		std::map<std::string, GuildMember> members;
 		std::vector<Role *> roles;
 		//std::vector<std::unique_ptr<DiscordObjects::User>>    users;
 	};
diff --git a/TriviaBot/bot/data_structures/Role.hpp b/TriviaBot/bot/data_structures/Role.hpp
index 3776e06..1e88a72 100644
--- a/TriviaBot/bot/data_structures/Role.hpp
+++ b/TriviaBot/bot/data_structures/Role.hpp
@@ -58,13 +58,9 @@ namespace DiscordObjects {
 	}
 
 	inline std::string Role::to_debug_string() {
-		std::stringstream colour_ss;
-		colour_ss << std::setw(6) << std::setfill('0') << colour;
-		std::string colour_str = colour_ss.str();
-
 		return "**__Role " + id + "__**"
 			+ "\n**name:** " + name
-			+ "\n**colour:** #" + colour_str
+			+ "\n**colour:** " + std::to_string(colour)
 			+ "\n**hoist:** " + std::to_string(hoist)
 			+ "\n**position:** " + std::to_string(position)
 			+ "\n**permissions:** " + std::to_string(permissions)
diff --git a/TriviaBot/bot/data_structures/Text.txt b/TriviaBot/bot/data_structures/Text.txt
deleted file mode 100644
index c1e31ab..0000000
--- a/TriviaBot/bot/data_structures/Text.txt
+++ /dev/null
@@ -1,125 +0,0 @@
-Example data:
-
-!!!!!!!!!!!!!!!!! GUILD_CREATE Event
-{
-    "afk_channel_id": null,
-    "afk_timeout": 300,
-    "channels": [
-        {
-            "id": "200398901767962624",
-            "is_private": false,
-            "last_message_id": "201355522635595776",
-            "name": "general",
-            "permission_overwrites": [],
-            "position": 0,
-            "topic": "",
-            "type": "text"
-        },
-        {
-            "bitrate": 64000,
-            "id": "200398901767962625",
-            "is_private": false,
-            "name": "General",
-            "permission_overwrites": [],
-            "position": 0,
-            "type": "voice",
-            "user_limit": 0
-        }
-    ],
-    "default_message_notifications": 0,
-    "emojis": [],
-    "features": [],
-    "icon": null,
-    "id": "200398901767962624",
-    "joined_at": "2016-07-06T23:54:20.824000+00:00",
-    "large": false,
-    "member_count": 2,
-    "members": [
-        {
-            "deaf": false,
-            "joined_at": "2016-07-06T23:53:41.425000+00:00",
-            "mute": false,
-            "roles": [
-                "200399346498273280"
-            ],
-            "user": {
-                "avatar": "1dc076d2d273615dd23546c86dbdfd9c",
-                "discriminator": "8212",
-                "id": "82232146579689472",
-                "username": "Jack"
-            }
-        },
-        {
-            "deaf": false,
-            "joined_at": "2016-07-06T23:54:20.824000+00:00",
-            "mute": false,
-            "roles": [
-                "200399601507893248"
-            ],
-            "user": {
-                "avatar": "e871ceecaa362718af6d3174bc941977",
-                "bot": true,
-                "discriminator": "8194",
-                "id": "199657095258177539",
-                "username": "trivia-bot"
-            }
-        }
-    ],
-    "mfa_level": 0,
-    "name": "EleGiggle",
-    "owner_id": "82232146579689472",
-    "presences": [
-        {
-            "game": null,
-            "status": "online",
-            "user": {
-                "id": "82232146579689472"
-            }
-        },
-        {
-            "game": null,
-            "status": "online",
-            "user": {
-                "id": "199657095258177539"
-            }
-        }
-    ],
-    "region": "london",
-    "roles": [
-        {
-            "color": 0,
-            "hoist": false,
-            "id": "200398901767962624",
-            "managed": false,
-            "mentionable": false,
-            "name": "@everyone",
-            "permissions": 36953089,
-            "position": 0
-        },
-        {
-            "color": 3066993,
-            "hoist": true,
-            "id": "200399346498273280",
-            "managed": false,
-            "mentionable": false,
-            "name": "All Perms",
-            "permissions": 506715199,
-            "position": 1
-        },
-        {
-            "color": 15844367,
-            "hoist": true,
-            "id": "200399601507893248",
-            "managed": false,
-            "mentionable": false,
-            "name": "Robot",
-            "permissions": 536083519,
-            "position": 1
-        }
-    ],
-    "splash": null,
-    "unavailable": false,
-    "verification_level": 0,
-    "voice_states": []
-}
-
diff --git a/TriviaBot/bot/js/V8Instance.cpp b/TriviaBot/bot/js/V8Instance.cpp
index 78ba8cf..04ed7c3 100644
--- a/TriviaBot/bot/js/V8Instance.cpp
+++ b/TriviaBot/bot/js/V8Instance.cpp
@@ -1,14 +1,20 @@
-#include <iostream>
+#include <iostream>
 #include <string>
 
 #include "V8Instance.hpp"
 #include "../APIHelper.hpp"
 #include "../Logger.hpp"
 
-using namespace v8;
+V8Instance::V8Instance(std::string guild_id, std::shared_ptr<APIHelper> ah, std::map<std::string, DiscordObjects::Guild> *guilds, std::map<std::string, DiscordObjects::Channel> *channels,
+	std::map<std::string, DiscordObjects::User> *users, std::map<std::string, DiscordObjects::Role> *roles) {
 
-V8Instance::V8Instance(std::shared_ptr<APIHelper> ah) {
+	this->guild_id = guild_id;
 	this->ah = ah;
+	this->guilds = guilds;
+	this->channels = channels;
+	this->users = users;
+	this->roles = roles;
+
 	create();
 }
 
@@ -38,17 +44,91 @@ v8::Local<v8::Context> V8Instance::create_context() {
 	Local<ObjectTemplate> global = ObjectTemplate::New(isolate);
 	// bind print() function
 	Local<External> self = External::New(isolate, (void *) this);
-	global->Set(String::NewFromUtf8(isolate, "print", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, V8Instance::js_print, self));
-	Logger::write("[v8] Created global obj, linked print function", Logger::LogLevel::Debug);
+
+	global->Set(
+		String::NewFromUtf8(isolate, "print", NewStringType::kNormal).ToLocalChecked(),
+		FunctionTemplate::New(isolate, V8Instance::js_print, self)
+	);
+	global->SetAccessor(
+		String::NewFromUtf8(isolate, "server", NewStringType::kNormal).ToLocalChecked(), 
+		V8Instance::js_get_server, 
+		(AccessorSetterCallback) 0, 
+		self
+	);
+	global->SetAccessor(
+		String::NewFromUtf8(isolate, "channel", NewStringType::kNormal).ToLocalChecked(), 
+		V8Instance::js_get_channel, 
+		(AccessorSetterCallback) 0, 
+		self
+	); 
+	global->SetAccessor(
+		String::NewFromUtf8(isolate, "user", NewStringType::kNormal).ToLocalChecked(), 
+		V8Instance::js_get_user,
+		(AccessorSetterCallback) 0, 
+		self
+	); 
+	global->SetAccessor(
+		String::NewFromUtf8(isolate, "input", NewStringType::kNormal).ToLocalChecked(), 
+		V8Instance::js_get_input, 
+		(AccessorSetterCallback) 0, 
+		self
+	);
+
+	Logger::write("[v8] Created global obj, linked data and functions", Logger::LogLevel::Debug);
 
 	return Context::New(isolate, NULL, global);
 }
 
+void V8Instance::js_get_server(Local<String> property, const PropertyCallbackInfo<Value> &info) {
+	auto data = info.Data().As<External>();
+	V8Instance *self = static_cast<V8Instance *>(data->Value());
+
+	Local<Object> obj = Object::New(info.GetIsolate());
+	self->add_to_obj(obj, (*self->guilds)[self->guild_id]);
+	info.GetReturnValue().Set(obj);
+}
+
+void V8Instance::js_get_channel(Local<String> property, const PropertyCallbackInfo<Value> &info) {
+	auto data = info.Data().As<External>();
+	V8Instance *self = static_cast<V8Instance *>(data->Value());
+
+	if (!self->current_channel) {
+		Logger::write("[v8] current_channel is null pointer", Logger::LogLevel::Severe);
+		info.GetReturnValue().SetNull();
+		return;
+	}
+
+	Local<Object> obj = Object::New(info.GetIsolate());
+	self->add_to_obj(obj, (*self->current_channel));
+	info.GetReturnValue().Set(obj);
+}
+
+void V8Instance::js_get_user(Local<String> property, const PropertyCallbackInfo<Value> &info) {
+	auto data = info.Data().As<External>();
+	V8Instance *self = static_cast<V8Instance *>(data->Value());
+
+	if (!self->current_sender) {
+		Logger::write("[v8] current_sender is null pointer", Logger::LogLevel::Severe);
+		info.GetReturnValue().SetNull();
+		return;
+	}
+
+	Local<Object> obj = Object::New(info.GetIsolate());
+	self->add_to_obj(obj, (*self->current_sender));
+	info.GetReturnValue().Set(obj);
+}
+
+void V8Instance::js_get_input(Local<String> property, const PropertyCallbackInfo<Value> &info) {
+	auto data = info.Data().As<External>();
+	V8Instance *self = static_cast<V8Instance *>(data->Value());
+
+	info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), self->current_input.c_str(), NewStringType::kNormal).ToLocalChecked());
+}
+
 void V8Instance::clean_up() {
 	Logger::write("[v8] Cleaning up", Logger::LogLevel::Debug);
 	isolate->Exit();
 	isolate->Dispose();
-	delete array_buffer_allocator;
 }
 
 void V8Instance::reload() {
@@ -56,11 +136,15 @@ void V8Instance::reload() {
 	create();
 }
 
-void V8Instance::exec_js(std::string js, std::string channel_id) {
+void V8Instance::exec_js(std::string js, DiscordObjects::Channel *channel, DiscordObjects::GuildMember *sender, std::string args) {
 	HandleScope handle_scope(isolate);
 	Local<Context> context(isolate->GetCurrentContext());
 
-	Logger::write("[v8] Executing JS: " + js, Logger::LogLevel::Debug);
+	current_sender = sender;
+	current_channel = channel;
+	current_input = args;
+
+	Logger::write("[v8] Preparing JS: " + js, Logger::LogLevel::Debug);
 
 	Local<String> source = String::NewFromUtf8(isolate, js.c_str(), NewStringType::kNormal).ToLocalChecked();
 
@@ -75,7 +159,7 @@ void V8Instance::exec_js(std::string js, std::string channel_id) {
 
 		std::string err_msg = *error;
 		Logger::write("[v8] Compilation error: " + err_msg, Logger::LogLevel::Debug);
-		ah->send_message(channel_id, ":warning: **Compilation error:** `" + err_msg + "`");
+		ah->send_message(channel->id, ":warning: **Compilation error:** `" + err_msg + "`");
 
 		return;
 	}
@@ -87,21 +171,23 @@ void V8Instance::exec_js(std::string js, std::string channel_id) {
 
 		std::string err_msg = *error;
 		Logger::write("[v8] Runtime error: " + err_msg, Logger::LogLevel::Debug);
-		ah->send_message(channel_id, ":warning: **Runtime error:** `" + err_msg + "`");
-
-		return;
+		ah->send_message(channel->id, ":warning: **Runtime error:** `" + err_msg + "`");
 	}
 
 	Logger::write("[v8] Script compiled and run", Logger::LogLevel::Debug);
 
+	current_sender = nullptr;
+	current_channel = nullptr;
+	current_input = "";
+
 	if (print_text != "") {
-		ah->send_message(channel_id, print_text);
+		ah->send_message(channel->id, print_text);
 		print_text = "";
 	}
 }
 
 void V8Instance::js_print(const v8::FunctionCallbackInfo<v8::Value> &args) {
-	auto data = args.Data().As<v8::External>();
+	auto data = args.Data().As<External>();
 	V8Instance *self = static_cast<V8Instance *>(data->Value());
 
 	std::string output = "";
@@ -110,4 +196,130 @@ void V8Instance::js_print(const v8::FunctionCallbackInfo<v8::Value> &args) {
 		v8::String::Utf8Value str(args[i]);
 		self->print_text += *str;
 	}
+}
+
+void V8Instance::add_to_obj(Local<Object> &object, std::string field_name, std::string value) {
+	add_to_obj(object, field_name, value.c_str());
+}
+
+void V8Instance::add_to_obj(Local<Object> &object, std::string field_name, const char value[]) {
+	if (value == "null") {
+		object->Set(String::NewFromUtf8(isolate, field_name.c_str(), NewStringType::kNormal).ToLocalChecked(), Null(isolate));
+		return;
+	}
+
+	object->Set(String::NewFromUtf8(isolate, field_name.c_str(), NewStringType::kNormal).ToLocalChecked(),
+		String::NewFromUtf8(isolate, value, NewStringType::kNormal).ToLocalChecked());
+}
+
+void V8Instance::add_to_obj(Local<Object> &object, std::string field_name, int32_t value) {
+	object->Set(String::NewFromUtf8(isolate, field_name.c_str(), NewStringType::kNormal).ToLocalChecked(),
+		Integer::New(isolate, value));
+}
+
+void V8Instance::add_to_obj(Local<Object> &object, std::string field_name, bool value) {
+	object->Set(String::NewFromUtf8(isolate, field_name.c_str(), NewStringType::kNormal).ToLocalChecked(),
+		Boolean::New(isolate, value));
+}
+
+void V8Instance::add_to_obj(Local<Object> &object, std::string field_name, Local<Object> value) {
+	object->Set(String::NewFromUtf8(isolate, field_name.c_str(), NewStringType::kNormal).ToLocalChecked(), value);
+}
+
+void V8Instance::add_to_obj(Local<Object> &object, std::string field_name, Local<Array> value) {
+	object->Set(String::NewFromUtf8(isolate, field_name.c_str(), NewStringType::kNormal).ToLocalChecked(), value);
+}
+
+void V8Instance::add_to_obj(Local<Object> &object, DiscordObjects::Guild guild) {
+	/* Boobot fields */
+	add_to_obj(object, "Id", guild.id);
+	add_to_obj(object, "Name", guild.name);
+	add_to_obj(object, "IconUrl", "https://discordapp.com/api/guilds/" + guild.id + "/icons/" + guild.icon + ".jpg");
+
+	Local<Object> owner_obj = Object::New(isolate);
+	DiscordObjects::GuildMember &owner = guild.members[guild.owner_id];
+	add_to_obj(owner_obj, owner);
+	add_to_obj(object, "Owner", owner_obj);
+
+	Local<Array> roles_arr = Array::New(isolate, guild.roles.size());
+	for (uint32_t i = 0; i < guild.roles.size(); i++) {
+		Local<Object> obj = Object::New(isolate);
+		DiscordObjects::Role &role = *guild.roles[i];
+		add_to_obj(obj, role);
+
+		roles_arr->Set(i, obj);
+	}
+	add_to_obj(object, "Roles", roles_arr);
+
+	Local<Array> members_arr = Array::New(isolate, guild.members.size());
+	int i = 0;
+	for (auto it : guild.members) {
+		Local<Object> obj = Object::New(isolate);
+		DiscordObjects::GuildMember &member = it.second;
+		add_to_obj(obj, member);
+
+		members_arr->Set(i, obj);
+		i++;
+	}
+	add_to_obj(object, "Users", members_arr);
+}
+
+void V8Instance::add_to_obj(Local<Object> &object, DiscordObjects::Channel channel) {
+	/* Boobot fields */
+	add_to_obj(object, "Id", channel.id);
+	add_to_obj(object, "Name", channel.name);
+	add_to_obj(object, "Topic", channel.topic);
+	add_to_obj(object, "IsVoice", channel.type == "voice");
+	
+	Local<Array> users = Array::New(isolate, 1);
+	users->Set(0, String::NewFromUtf8(isolate, "NOT IMPLEMENTED", NewStringType::kNormal).ToLocalChecked());
+	add_to_obj(object, "Users", users);
+
+	/* Additional fields */
+	add_to_obj(object, "LastMessageId", channel.last_message_id);
+	add_to_obj(object, "Bitrate", channel.bitrate);
+	add_to_obj(object, "UserLimit", channel.user_limit);
+}
+
+void V8Instance::add_to_obj(Local<Object> &object, DiscordObjects::Role role) {
+	/* Boobot fields */
+	add_to_obj(object, "Id", role.id);
+	add_to_obj(object, "Name", role.name);
+	add_to_obj(object, "Position", role.position);
+	add_to_obj(object, "Red", "NOT IMPLEMENTED");
+	add_to_obj(object, "Blue", "NOT IMPLEMENTED");
+	add_to_obj(object, "Green", "NOT IMPLEMENTED");
+
+	/* Additional fields */
+	add_to_obj(object, "Mentionable", role.mentionable);
+	add_to_obj(object, "Mention", "<@&" + role.id + ">");
+	add_to_obj(object, "Hoist", role.hoist);
+}
+
+void V8Instance::add_to_obj(Local<Object> &object, DiscordObjects::GuildMember member) {
+	/* Boobot fields */
+	add_to_obj(object, "Id", member.user->id);
+	add_to_obj(object, "Name", member.user->username);
+	add_to_obj(object, "Mention", "<@!" + member.user->id + ">");
+	add_to_obj(object, "AvatarUrl", "https://discordapp.com/api/users/" + member.user->id + "/avatars/" + member.user->avatar + ".jpg");
+
+	Local<Array> roles = Array::New(isolate, member.roles.size());
+	int i = 0;
+	for (DiscordObjects::Role *role : member.roles) {
+		Local<Object> role_obj = Object::New(isolate);
+		add_to_obj(role_obj, *role);
+
+		roles->Set(i, role_obj);
+		i++;
+	}
+	add_to_obj(object, "Roles", roles);
+
+	add_to_obj(object, "State", "NOT IMPLEMENTED");
+	add_to_obj(object, "CurrentGame", "NOT IMPLEMENTED");
+
+	/* Additional fields */
+	add_to_obj(object, "Nick", member.nick);
+	add_to_obj(object, "Deaf", member.deaf);
+	add_to_obj(object, "Mute", member.mute);
+	add_to_obj(object, "JoinedAt", member.joined_at);
 }
\ No newline at end of file
diff --git a/TriviaBot/bot/js/V8Instance.hpp b/TriviaBot/bot/js/V8Instance.hpp
index 3bb0615..eb7fb3f 100644
--- a/TriviaBot/bot/js/V8Instance.hpp
+++ b/TriviaBot/bot/js/V8Instance.hpp
@@ -2,30 +2,66 @@
 #define BOT_JS_V8INSTANCE
 
 #include <memory>
+#include <map>
 
 #include <include/v8.h>
 #include <include/libplatform/libplatform.h>
 
+#include "../data_structures/Guild.hpp"
+#include "../data_structures/Channel.hpp"
+#include "../data_structures/Role.hpp"
+#include "../data_structures/GuildMember.hpp"
+#include "../data_structures/User.hpp"
+
 class APIHelper;
 
+using namespace v8;
+
 class V8Instance {
 public:
-	V8Instance(std::shared_ptr<APIHelper> ah);
+	V8Instance(std::string guild_id, std::shared_ptr<APIHelper> ah, std::map<std::string, DiscordObjects::Guild> *guilds,
+		std::map<std::string, DiscordObjects::Channel> *channels, std::map<std::string, DiscordObjects::User> *users, std::map<std::string, DiscordObjects::Role> *roles);
 	~V8Instance();
 	void reload();
-	void exec_js(std::string js, std::string channel_id);
+	void exec_js(std::string js, DiscordObjects::Channel *channel, DiscordObjects::GuildMember *sender, std::string args = "");
 
 private:
 	void clean_up();
 	void create();
-	v8::Local<v8::Context> create_context();
-	static void js_print(const v8::FunctionCallbackInfo<v8::Value> &args);
+	Local<Context> create_context();
 
-	v8::ArrayBuffer::Allocator *array_buffer_allocator;
-	v8::Isolate *isolate;
+	void add_to_obj(Local<Object> &object, std::string field_name, std::string value);
+	void add_to_obj(Local<Object> &object, std::string field_name, const char value[]);
+	void add_to_obj(Local<Object> &object, std::string field_name, int32_t value);
+	void add_to_obj(Local<Object> &object, std::string field_name, bool value);
+	void add_to_obj(Local<Object> &object, std::string field_name, Local<Object> value);
+	void add_to_obj(Local<Object> &object, std::string field_name, Local<Array> value);
 
+	void add_to_obj(Local<Object> &object, DiscordObjects::Guild guild);
+	void add_to_obj(Local<Object> &object, DiscordObjects::Channel channel);
+	void add_to_obj(Local<Object> &object, DiscordObjects::Role role);
+	void add_to_obj(Local<Object> &object, DiscordObjects::GuildMember member);
+
+	static void js_print(const FunctionCallbackInfo<Value> &args);
+	static void js_get_server(Local<String> property, const PropertyCallbackInfo<Value> &info);
+	static void js_get_channel(Local<String> property, const PropertyCallbackInfo<Value> &info);
+	static void js_get_user(Local<String> property, const PropertyCallbackInfo<Value> &info);
+	static void js_get_input(Local<String> property, const PropertyCallbackInfo<Value> &info);
+
+	std::map<std::string, DiscordObjects::Guild> *guilds;
+	std::map<std::string, DiscordObjects::Channel> *channels;
+	std::map<std::string, DiscordObjects::User> *users;
+	std::map<std::string, DiscordObjects::Role> *roles;
+
+	std::string guild_id;
+	Isolate *isolate;
 	std::shared_ptr<APIHelper> ah;
+
+	/* variables which change when a new command is executed */
 	std::string print_text;
+	std::string current_input;
+	DiscordObjects::Channel *current_channel;
+	DiscordObjects::GuildMember *current_sender;
 };
 
 #endif
\ No newline at end of file

From e4cc0230553ccce17cebe3dec1d9105b626e3f67 Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Wed, 10 Aug 2016 17:07:41 +0100
Subject: [PATCH 09/15] Overhaul a lot, fix the JS implementation

---
 TriviaBot/bot/APIHelper.cpp                   |  59 --
 TriviaBot/bot/DiscordAPI.cpp                  |  84 ++
 .../bot/{APIHelper.hpp => DiscordAPI.hpp}     |  15 +-
 TriviaBot/bot/GatewayHandler.cpp              | 252 ++++--
 TriviaBot/bot/GatewayHandler.hpp              |  25 +-
 TriviaBot/bot/TriviaBot.cpp                   |  34 +-
 TriviaBot/bot/TriviaGame.cpp                  |  17 +-
 TriviaBot/bot/TriviaGame.hpp                  |   4 +-
 TriviaBot/bot/data_structures/Channel.hpp     |   2 +-
 TriviaBot/bot/data_structures/Guild.hpp       |   6 +-
 TriviaBot/bot/data_structures/GuildMember.hpp |   7 +-
 TriviaBot/bot/data_structures/Role.hpp        |   2 +-
 TriviaBot/bot/data_structures/User.hpp        |   9 +-
 TriviaBot/bot/http/HTTPHelper.cpp             | 135 ++-
 TriviaBot/bot/http/HTTPHelper.hpp             |   9 +-
 TriviaBot/bot/js/CommandHelper.cpp            | 276 +++---
 TriviaBot/bot/js/CommandHelper.hpp            |  22 +-
 TriviaBot/bot/js/V8Instance.cpp               | 841 +++++++++++++-----
 TriviaBot/bot/js/V8Instance.hpp               |  69 +-
 19 files changed, 1236 insertions(+), 632 deletions(-)
 delete mode 100644 TriviaBot/bot/APIHelper.cpp
 create mode 100644 TriviaBot/bot/DiscordAPI.cpp
 rename TriviaBot/bot/{APIHelper.hpp => DiscordAPI.hpp} (55%)

diff --git a/TriviaBot/bot/APIHelper.cpp b/TriviaBot/bot/APIHelper.cpp
deleted file mode 100644
index a6633ee..0000000
--- a/TriviaBot/bot/APIHelper.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "APIHelper.hpp"
-
-#include <cstdio>
-#include <thread>
-#include <chrono>
-
-#include "http/HTTPHelper.hpp"
-#include "Logger.hpp"
-
-using namespace std::chrono_literals;
-
-APIHelper::APIHelper() : BASE_URL("https://discordapp.com/api"), CHANNELS_URL(BASE_URL + "/channels"),
-	JSON_CTYPE("application/json") {
-	http = new HTTPHelper();
-}
-
-void APIHelper::send_message(std::string channel_id, std::string message) {
-	if (message == "") {
-		Logger::write("[send_message] Tried to send empty message", Logger::LogLevel::Warning);
-		return;
-	}
-
-	if (message.length() > 4000) {
-		Logger::write("[send_message] Tried to send a message over 4000 characters", Logger::LogLevel::Warning);
-		return;
-	}
-	else if (message.length() > 2000) {
-		std::cout << message.length() << std::endl;
-
-		std::string first = message.substr(0, 2000);
-		std::string second = message.substr(2000);
-		send_message(channel_id, first);
-		std::this_thread::sleep_for(50ms);
-		send_message(channel_id, second);
-		return;
-	}
-
-	const std::string url = CHANNELS_URL + "/" + channel_id + "/messages";
-	json data = {
-		{ "content", message }
-	};
-
-	std::string response;
-	long response_code = -1;
-	response = http->post_request(url, JSON_CTYPE, data.dump(), &response_code);
-
-	int retries = 0;
-	while (response_code != 200 && retries < 2) {
-		Logger::write("[send_message] Got non-200 response code, retrying", Logger::LogLevel::Warning);
-		std::this_thread::sleep_for(100ms);
-		// try 3 times. usually enough to prevent 502 bad gateway issues
-		response = http->post_request(url, JSON_CTYPE, data.dump(), &response_code);
-		retries++;
-	}
-
-	if (response_code != 200) {
-		Logger::write("[send_message] Giving up on sending message", Logger::LogLevel::Warning);
-	}
-}
\ No newline at end of file
diff --git a/TriviaBot/bot/DiscordAPI.cpp b/TriviaBot/bot/DiscordAPI.cpp
new file mode 100644
index 0000000..3bb582a
--- /dev/null
+++ b/TriviaBot/bot/DiscordAPI.cpp
@@ -0,0 +1,84 @@
+#include "DiscordAPI.hpp"
+
+#include <cstdio>
+#include <thread>
+#include <chrono>
+
+#include "http/HTTPHelper.hpp"
+#include "Logger.hpp"
+
+using namespace std::chrono_literals;
+
+namespace DiscordAPI {
+	const std::string base_url = "https://discordapp.com/api";
+	const std::string channels_url = base_url + "/channels";
+	const std::string gateway_url = base_url + "/gateway";
+
+	const std::string json_mime_type = "application/json";
+
+	void send_message(std::string channel_id, std::string message) {
+		if (message == "") {
+			Logger::write("[API] [send_message] Tried to send empty message", Logger::LogLevel::Warning);
+			return;
+		}
+
+		if (message.length() > 4000) {
+			Logger::write("[API] [send_message] Tried to send a message over 4000 characters", Logger::LogLevel::Warning);
+			return;
+		}
+		else if (message.length() > 2000) {
+			std::cout << message.length() << std::endl;
+
+			std::string first = message.substr(0, 2000);
+			std::string second = message.substr(2000);
+			send_message(channel_id, first);
+			std::this_thread::sleep_for(50ms);
+			send_message(channel_id, second);
+			return;
+		}
+
+		const std::string url = channels_url + "/" + channel_id + "/messages";
+		json data = {
+			{ "content", message }
+		};
+
+		std::string response;
+		long response_code = 0;
+		response = HTTP::post_request(url, json_mime_type, data.dump(), &response_code);
+
+		int retries = 0;
+		while (response_code != 200 && retries < 2) {
+			Logger::write("[API] [send_message] Got non-200 response code, retrying", Logger::LogLevel::Warning);
+			std::this_thread::sleep_for(100ms);
+			// try 3 times. usually enough to prevent 502 bad gateway issues
+			response = HTTP::post_request(url, json_mime_type, data.dump(), &response_code);
+			retries++;
+		}
+
+		if (response_code != 200) {
+			Logger::write("[API] [send_message] Giving up on sending message", Logger::LogLevel::Warning);
+		}
+	}
+
+	json get_gateway() {
+		std::string response;
+		long response_code;
+		response = HTTP::get_request(gateway_url, &response_code);
+
+		int retries = 0;
+		while (response_code != 200 && retries < 4) {
+			Logger::write("[API] [get_gateway] Got non-200 response code, retrying", Logger::LogLevel::Warning);
+			std::this_thread::sleep_for(100ms);
+			// try 3 times. usually enough to prevent 502 bad gateway issues
+			response = HTTP::get_request(gateway_url, &response_code);
+			retries++;
+		}
+
+		if (response_code != 200) {
+			Logger::write("[API] [get_gateway] Giving up on getting gateway url", Logger::LogLevel::Warning);
+			return json {};
+		}
+
+		return json::parse(response);
+	}
+}
\ No newline at end of file
diff --git a/TriviaBot/bot/APIHelper.hpp b/TriviaBot/bot/DiscordAPI.hpp
similarity index 55%
rename from TriviaBot/bot/APIHelper.hpp
rename to TriviaBot/bot/DiscordAPI.hpp
index 5859463..2c389d7 100644
--- a/TriviaBot/bot/APIHelper.hpp
+++ b/TriviaBot/bot/DiscordAPI.hpp
@@ -9,18 +9,9 @@ using json = nlohmann::json;
 
 class HTTPHelper;
 
-class APIHelper {
-public:
-	APIHelper();
-
+namespace DiscordAPI {
+	json get_gateway();
 	void send_message(std::string channel_id, std::string message);
-
-private:
-	const std::string BASE_URL;
-	const std::string CHANNELS_URL;
-	const std::string JSON_CTYPE;
-
-	HTTPHelper *http;
-};
+}
 
 #endif
\ No newline at end of file
diff --git a/TriviaBot/bot/GatewayHandler.cpp b/TriviaBot/bot/GatewayHandler.cpp
index 092f10c..d14792e 100644
--- a/TriviaBot/bot/GatewayHandler.cpp
+++ b/TriviaBot/bot/GatewayHandler.cpp
@@ -2,7 +2,7 @@
 
 #include <boost/algorithm/string.hpp>
 
-#include "APIHelper.hpp"
+#include "DiscordAPI.hpp"
 #include "Logger.hpp"
 #include "data_structures/GuildMember.hpp"
 
@@ -11,8 +11,7 @@ extern std::string bot_token;
 GatewayHandler::GatewayHandler() {
 	last_seq = 0;
 
-	ah = std::make_shared<APIHelper>();
-	command_helper = std::make_unique<CommandHelper>();
+	CommandHelper::init();
 }
 
 void GatewayHandler::handle_data(std::string data, client &c, websocketpp::connection_hdl &hdl) {
@@ -33,9 +32,17 @@ void GatewayHandler::handle_data(std::string data, client &c, websocketpp::conne
 	}
 }
 
-void GatewayHandler::heartbeat(client *c, websocketpp::connection_hdl hdl, int interval) {
+void GatewayHandler::send_heartbeat(client *c, websocketpp::connection_hdl hdl, int interval) {
 	while (true) {
 		boost::this_thread::sleep(boost::posix_time::milliseconds(interval));
+		if (!c) {
+			Logger::write("[send_heartbeat] Client pointer is null", Logger::LogLevel::Severe);
+			break;
+		}
+		else if (c->stopped()) {
+			break;
+		}
+
 
 		json heartbeat = {
 			{ "op", 1 },
@@ -48,14 +55,49 @@ void GatewayHandler::heartbeat(client *c, websocketpp::connection_hdl hdl, int i
 	}
 }
 
+void GatewayHandler::send_identify(client &c, websocketpp::connection_hdl &hdl) {
+	json identify = {
+		{ "op", 2 },
+		{ "d", {
+			{ "token", bot_token },
+			{ "properties",{
+				{ "$browser", "Microsoft Windows 10" },
+				{ "$device", "TriviaBot-0.0" },
+				{ "$referrer", "" },
+				{ "$referring_domain", "" }
+			} },
+			{ "compress", false },
+			{ "large_threshold", 250 },
+			{ "shard",{ 0, 1 } }
+		} }
+	};
+
+	c.send(hdl, identify.dump(), websocketpp::frame::opcode::text);
+	Logger::write("Sent identify payload", Logger::LogLevel::Debug);
+}
+
+void GatewayHandler::send_request_guild_members(client &c, websocketpp::connection_hdl &hdl, std::string guild_id) {
+	json request_guild_members = {
+		{ "op", 8 },
+		{ "d", {
+			{ "guild_id", guild_id },
+			{ "query", "" },
+			{ "limit", 0 }
+		} }
+	};
+
+	c.send(hdl, request_guild_members.dump(), websocketpp::frame::opcode::text);
+	Logger::write("Requested guild members for " + guild_id, Logger::LogLevel::Debug);
+}
+
 void GatewayHandler::on_hello(json decoded, client &c, websocketpp::connection_hdl &hdl) {
 	heartbeat_interval = decoded["d"]["heartbeat_interval"];
 
 	Logger::write("Heartbeat interval: " + std::to_string(heartbeat_interval / 1000.0f) + " seconds", Logger::LogLevel::Debug);
 
-	heartbeat_thread = std::make_unique<boost::thread>(boost::bind(&GatewayHandler::heartbeat, this, &c, hdl, heartbeat_interval));
+	heartbeat_thread = std::make_unique<boost::thread>(boost::bind(&GatewayHandler::send_heartbeat, this, &c, hdl, heartbeat_interval));
 
-	identify(c, hdl);
+	send_identify(c, hdl);
 }
 
 void GatewayHandler::on_dispatch(json decoded, client &c, websocketpp::connection_hdl &hdl) {
@@ -105,6 +147,9 @@ void GatewayHandler::on_dispatch(json decoded, client &c, websocketpp::connectio
 	else if (event_name == "MESSAGE_CREATE") {
 		on_event_message_create(data);
 	}
+	else if (event_name == "PRESENCE_UPDATE") {
+		on_event_presence_update(data);
+	}
 }
 
 void GatewayHandler::on_event_ready(json data) {
@@ -113,13 +158,31 @@ void GatewayHandler::on_event_ready(json data) {
 	Logger::write("Sign-on confirmed. (@" + user_object.username + "#" + user_object.discriminator + ")", Logger::LogLevel::Info);
 }
 
+void GatewayHandler::on_event_presence_update(json data) {
+	std::string user_id = data["user"]["id"];
+
+	auto it = users.find(user_id);
+	if (it != users.end()) {
+		it->second.status = data.value("status", "offline");
+		if (data["game"] == nullptr) {
+			it->second.game = "null";
+		}
+		else {
+			it->second.game = data["game"].value("name", "null");
+		}
+	}
+	else {
+		Logger::write("Tried to add presence for user " + user_id + " who doesn't exist", Logger::LogLevel::Warning);
+	}
+}
+
 void GatewayHandler::on_event_guild_create(json data) {
 	guilds[data["id"]] = DiscordObjects::Guild(data);
 	DiscordObjects::Guild &guild = guilds[data["id"]];
 
-	Logger::write("Loaded guild " + guild.id + ", now in " + std::to_string(guilds.size()) + " guild(s)", Logger::LogLevel::Info);
+	Logger::write("Received info for guild " + guild.id + ", now in " + std::to_string(guilds.size()) + " guild(s)", Logger::LogLevel::Info);
 
-	int channels_added = 0, roles_added = 0, members_added = 0;
+	int channels_added = 0, roles_added = 0, members_added = 0, presences_added = 0;
 
 	for (json channel : data["channels"]) {
 		std::string channel_id = channel["id"];
@@ -147,21 +210,41 @@ void GatewayHandler::on_event_guild_create(json data) {
 		}
 		users[user_id].guilds.push_back(guild.id);
 
-		DiscordObjects::GuildMember guild_member(member, &users[user_id]);
+		DiscordObjects::GuildMember *guild_member = new DiscordObjects::GuildMember(member, &users[user_id]);
 		for (std::string role_id : member["roles"]) {
-			guild_member.roles.push_back(&roles[role_id]);
+			guild_member->roles.push_back(&roles[role_id]);
 		}
 
-		guilds[guild.id].members[user_id] = guild_member;
+		guilds[guild.id].members.push_back(guild_member);
+
+		members_added++;
+	}
+	for (json presence : data["presences"]) {
+		std::string user_id = presence["user"]["id"];
+
+		auto it = users.find(user_id);
+		if (it != users.end()) {
+			it->second.status = presence.value("status", "offline");
+			if (presence["game"] == nullptr) {
+				it->second.game = "null";
+			} else {
+				it->second.game = presence["game"].value("name", "null");
+			}
+
+			presences_added++;
+		}
+		else {
+			Logger::write("Tried to add presence for user " + user_id + " who doesn't exist", Logger::LogLevel::Warning);
+		}
 	}
 
 	if (v8_instances.count(guild.id) == 0) {
-		v8_instances[guild.id] = std::make_unique<V8Instance>(guild.id, ah, &guilds, &channels, &users, &roles);
+		v8_instances[guild.id] = std::make_unique<V8Instance>(guild.id, &guilds, &channels, &users, &roles);
 		Logger::write("Created v8 instance for guild " + guild.id, Logger::LogLevel::Debug);
 	}
 
-	Logger::write("Loaded " + std::to_string(channels_added) + " channels, " + std::to_string(roles_added) 
-		+ " roles and " + std::to_string(members_added) + " members to guild " + guild.id, Logger::LogLevel::Debug);
+	Logger::write("Loaded " + std::to_string(channels_added) + " channels, " + std::to_string(roles_added)  + " roles and " 
+		+ std::to_string(members_added) + " members (with " + std::to_string(presences_added) + " presences) to guild " + guild.id, Logger::LogLevel::Debug);
 }
 
 void GatewayHandler::on_event_guild_update(json data) {
@@ -204,37 +287,41 @@ void GatewayHandler::on_event_guild_member_add(json data) {
 	}
 	users[user_id].guilds.push_back(guild_id);
 
-	DiscordObjects::GuildMember guild_member(data, &users[user_id]);
+	DiscordObjects::GuildMember *guild_member = new DiscordObjects::GuildMember(data, &users[user_id]);
 	for (std::string role_id : data["roles"]) {
-		guild_member.roles.push_back(&roles[role_id]);
+		guild_member->roles.push_back(&roles[role_id]);
 	}
 
-	guilds[guild_id].members[user_id] = guild_member;
+	guilds[guild_id].members.push_back(guild_member);
 
-	Logger::write("Added new member " + guild_member.user->id + " to guild " + guild_id, Logger::LogLevel::Debug);
+	Logger::write("Added new member " + guild_member->user->id + " to guild " + guild_id, Logger::LogLevel::Debug);
 }
 
 void GatewayHandler::on_event_guild_member_update(json data) {
 	std::string user_id = data["user"]["id"];
 	DiscordObjects::Guild &guild = guilds[data["guild_id"]];
 
-	auto it = guild.members.find(user_id);
+	auto it = std::find_if(guild.members.begin(), guild.members.end(), [user_id](DiscordObjects::GuildMember *member) {
+		return user_id == member->user->id;
+	});
 	if (it != guild.members.end()) {
 		bool nick_changed = false;
 		size_t roles_change = 0;
 
+		DiscordObjects::GuildMember *member = (*it);
+
 		std::string nick = data.value("nick", "null");
-		if (it->second.nick != nick) {
-			it->second.nick = nick;
+		if (member->nick != nick) {
+			member->nick = nick;
 			nick_changed = true;
 		}
 
-		roles_change = it->second.roles.size();
-		it->second.roles.clear(); // reset and re-fill, changing the differences is probably more expensive anyway.
+		roles_change = member->roles.size();
+		member->roles.clear(); // reset and re-fill, changing the differences is probably more expensive anyway.
 		for (std::string role_id : data["roles"]) {
-			it->second.roles.push_back(&roles[role_id]);
+			member->roles.push_back(&roles[role_id]);
 		}
-		roles_change = it->second.roles.size() - roles_change;
+		roles_change = member->roles.size() - roles_change;
 		
 		std::string debug_string = "Updated member " + user_id + " of guild " + guild.id;
 		if (nick_changed) debug_string += ". Nick changed to " + nick;
@@ -252,14 +339,16 @@ void GatewayHandler::on_event_guild_member_remove(json data) {
 	DiscordObjects::Guild &guild = guilds[data["guild_id"]];
 	std::string user_id = data["user"]["id"];
 
-	auto it = guild.members.find(user_id);
-	if (it != guilds[guild.id].members.end()) {
+	auto it = std::find_if(guild.members.begin(), guild.members.end(), [user_id](DiscordObjects::GuildMember *member) {
+		return user_id == member->user->id;
+	});
+	if (it != guild.members.end()) {
+		delete (*it);
 		guild.members.erase(it);
 		
-		DiscordObjects::User &user = users[user_id];
-		user.guilds.erase(std::remove(user.guilds.begin(), user.guilds.end(), guild.id));
+		users[user_id].guilds.erase(std::remove(users[user_id].guilds.begin(), users[user_id].guilds.end(), guild.id));
 
-		if (user.guilds.size() == 0) {
+		if (users[user_id].guilds.size() == 0) {
 			users.erase(users.find(user_id));
 			Logger::write("User " + user_id + " removed from guild " + guild.id + " and no longer visible, deleted.", Logger::LogLevel::Debug);
 		}
@@ -327,8 +416,6 @@ void GatewayHandler::on_event_channel_create(json data) {
 }
 
 void GatewayHandler::on_event_channel_update(json data) {
-	std::cout << "Update: " << data.dump(4) << std::endl;
-
 	std::string channel_id = data["id"];
 
 	auto it = channels.find(channel_id);
@@ -342,8 +429,6 @@ void GatewayHandler::on_event_channel_update(json data) {
 }
 
 void GatewayHandler::on_event_channel_delete(json data) {
-	std::cout << "Delete: " << data.dump(4) << std::endl;
-
 	std::string channel_id = data["id"];
 	std::string guild_id = data["guild_id"];
 
@@ -369,19 +454,19 @@ void GatewayHandler::on_event_message_create(json data) {
 
 	DiscordObjects::Channel &channel = channels[data["channel_id"]];
 	DiscordObjects::Guild &guild = guilds[channel.guild_id];
-	DiscordObjects::GuildMember &sender = guild.members[data["author"]["id"]];
+	DiscordObjects::User &sender = users[data["author"]["id"]];
 
-	if (sender.user->bot) return; // ignore bots to prevent looping
+	if (sender.bot) return;
 
 	std::vector<std::string> words;
 	boost::split(words, message, boost::is_any_of(" "));
-	Command custom_command;
+	CommandHelper::Command custom_command;
 	if (words[0] == "`trivia" || words[0] == "`t") {
 		int questions = 10;
 		int delay = 8;
 
 		if (words.size() > 3) {
-			ah->send_message(channel.id, ":exclamation: Invalid arguments!");
+			DiscordAPI::send_message(channel.id, ":exclamation: Invalid arguments!");
 			return;
 		}
 		else  if (words.size() > 1) {
@@ -391,7 +476,7 @@ void GatewayHandler::on_event_message_create(json data) {
 				help += "\\`trivia **stop**: stops the ongoing game.\n";
 				help += "\\`trivia **help**: prints this message\n";
 
-				ah->send_message(channel.id, help);
+				DiscordAPI::send_message(channel.id, help);
 				return;
 			}
 			else if (words[1] == "stop" || words[1] == "s") {
@@ -408,13 +493,13 @@ void GatewayHandler::on_event_message_create(json data) {
 					}
 				}
 				catch (std::invalid_argument e) {
-					ah->send_message(channel.id, ":exclamation: Invalid arguments!");
+					DiscordAPI::send_message(channel.id, ":exclamation: Invalid arguments!");
 					return;
 				}
 			}
 		}
 
-		games[channel.id] = std::make_unique<TriviaGame>(this, ah, channel.id, questions, delay);
+		games[channel.id] = std::make_unique<TriviaGame>(this, channel.id, questions, delay);
 		games[channel.id]->start();
 	}
 	else if (words[0] == "`guilds") {
@@ -422,56 +507,59 @@ void GatewayHandler::on_event_message_create(json data) {
 		for (auto &gu : guilds) {
 			m += "> " + gu.second.name + " (" + gu.second.id + ") Channels: " + std::to_string(gu.second.channels.size()) + "\n";
 		}
-		ah->send_message(channel.id, m);
+		DiscordAPI::send_message(channel.id, m);
 	}
 	else if (words[0] == "`info") {
-		ah->send_message(channel.id, ":information_source: trivia-bot by Jack. <http://github.com/jackb-p/TriviaDiscord>");
+		DiscordAPI::send_message(channel.id, ":information_source: trivia-bot by Jack. <http://github.com/jackb-p/TriviaDiscord>");
 	}
-	else if (words[0] == "~js" && message.length() > 4) {
+	else if (words[0] == "~js" && words.size() > 1) {
+		DiscordObjects::GuildMember *member = *std::find_if(guild.members.begin(), guild.members.end(), [sender](DiscordObjects::GuildMember *m) {
+			return sender.id == m->user->id;
+		});
 		std::string js = message.substr(4);
 		auto it = v8_instances.find(channel.guild_id);
 		if (it != v8_instances.end() && js.length() > 0) {
-			it->second->exec_js(js, &channel, &sender);
+			it->second->exec_js(js, &channel, member);
 		}
 	}
-	else if (words[0] == "~createjs" && message.length() > 8) {
+	else if (words[0] == "~createjs" && words.size() > 1) {
 		std::string args = message.substr(10);
 		size_t seperator_loc = args.find("|");
 		if (seperator_loc != std::string::npos) {
 			std::string command_name = args.substr(0, seperator_loc);
 			std::string script = args.substr(seperator_loc + 1);
-			int result = command_helper->insert_command(channel.guild_id, command_name, script);
+			int result = CommandHelper::insert_command(channel.guild_id, command_name, script);
 			switch (result) {
 			case 0:
-				ah->send_message(channel.id, ":warning: Error!"); break;
+				DiscordAPI::send_message(channel.id, ":warning: Error!"); break;
 			case 1:
-				ah->send_message(channel.id, ":new: Command `" + command_name + "` successfully created."); break;
+				DiscordAPI::send_message(channel.id, ":new: Command `" + command_name + "` successfully created."); break;
 			case 2:
-				ah->send_message(channel.id, ":arrow_heading_up: Command `" + command_name + "` successfully updated."); break;
+				DiscordAPI::send_message(channel.id, ":arrow_heading_up: Command `" + command_name + "` successfully updated."); break;
 			}
 		}
 	}
-	else if (words[0] == "`shutdown" && sender.user->id == "82232146579689472") { // it me
-		ah->send_message(channel.id, ":zzz: Goodbye!");
+	else if (words[0] == "`shutdown" && sender.id == "82232146579689472") { // it me
+		DiscordAPI::send_message(channel.id, ":zzz: Goodbye!");
 		// TODO: without needing c, hdl - c.close(hdl, websocketpp::close::status::going_away, "`shutdown command used.");
 	}
 	else if (words[0] == "`debug") {
 		if (words[1] == "channel" && words.size() == 3) {
 			auto it = channels.find(words[2]);
 			if (it != channels.end()) {
-				ah->send_message(channel.id, it->second.to_debug_string());
+				DiscordAPI::send_message(channel.id, it->second.to_debug_string());
 			}
 			else {
-				ah->send_message(channel.id, ":question: Unrecognised channel.");
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised channel.");
 			}
 		}
 		else if (words[1] == "guild" && words.size() == 3) {
 			auto it = guilds.find(words[2]);
 			if (it != guilds.end()) {
-				ah->send_message(channel.id, it->second.to_debug_string());
+				DiscordAPI::send_message(channel.id, it->second.to_debug_string());
 			}
 			else {
-				ah->send_message(channel.id, ":question: Unrecognised guild.");
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised guild.");
 			}
 		}
 		else if (words[1] == "member" && words.size() == 4) {
@@ -479,25 +567,27 @@ void GatewayHandler::on_event_message_create(json data) {
 			if (it != guilds.end()) {
 				std::string user_id = words[3];
 
-				auto it2 = it->second.members.find(user_id);
+				auto it2 = std::find_if(it->second.members.begin(), it->second.members.end(), [user_id](DiscordObjects::GuildMember *member) {
+					return user_id == member->user->id;
+				});
 				if (it2 != it->second.members.end()) {
-					ah->send_message(channel.id, it2->second.to_debug_string());
+					DiscordAPI::send_message(channel.id, (*it2)->to_debug_string());
 				}
 				else {
-					ah->send_message(channel.id, ":question: Unrecognised user.");
+					DiscordAPI::send_message(channel.id, ":question: Unrecognised user.");
 				}
 			}
 			else {
-				ah->send_message(channel.id, ":question: Unrecognised guild.");
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised guild.");
 			}
 		}
 		else if (words[1] == "role" && words.size() == 3) {
 			auto it = roles.find(words[2]);
 			if (it != roles.end()) {
-				ah->send_message(channel.id, it->second.to_debug_string());
+				DiscordAPI::send_message(channel.id, it->second.to_debug_string());
 			}
 			else {
-				ah->send_message(channel.id, ":question: Unrecognised role.");
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised role.");
 			}
 		}
 		else if (words[1] == "role" && words.size() == 4) {
@@ -511,21 +601,21 @@ void GatewayHandler::on_event_message_create(json data) {
 
 				auto it2 = std::find_if(it->second.roles.begin(), it->second.roles.end(), check_lambda);
 				if (it2 != it->second.roles.end()) {
-					ah->send_message(channel.id, (*it2)->to_debug_string());
+					DiscordAPI::send_message(channel.id, (*it2)->to_debug_string());
 				}
 				else {
-					ah->send_message(channel.id, ":question: Unrecognised role.");
+					DiscordAPI::send_message(channel.id, ":question: Unrecognised role.");
 				}
 			}
 			else {
-				ah->send_message(channel.id, ":question: Unrecognised guild.");
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised guild.");
 			}
 		}
 		else {
-			ah->send_message(channel.id, ":question: Unknown parameters.");
+			DiscordAPI::send_message(channel.id, ":question: Unknown parameters.");
 		}
 	}
-	else if (command_helper->get_command(channel.guild_id, words[0], custom_command)) {
+	else if (CommandHelper::get_command(channel.guild_id, words[0], custom_command)) {
 		std::string args = "";
 		if (message.length() > (words[0].length() + 1)) {
 			args = message.substr(words[0].length() + 1);
@@ -533,35 +623,17 @@ void GatewayHandler::on_event_message_create(json data) {
 
 		auto it = v8_instances.find(channel.guild_id);
 		if (it != v8_instances.end() && custom_command.script.length() > 0) {
-			it->second->exec_js(custom_command.script, &channel, &sender, args);
+			DiscordObjects::GuildMember *member = *std::find_if(guild.members.begin(), guild.members.end(), [sender](DiscordObjects::GuildMember *m) {
+				return sender.id == m->user->id;
+			});
+			it->second->exec_js(custom_command.script, &channel, member, args);
 		}
 	}
 	else if (games.find(channel.id) != games.end()) { // message received in channel with ongoing game
-		games[channel.id]->handle_answer(message, *sender.user);
+		games[channel.id]->handle_answer(message, sender);
 	}
 }
 
-void GatewayHandler::identify(client &c, websocketpp::connection_hdl &hdl) {
-	json identify = {
-		{ "op", 2 },
-		{ "d", {
-			{ "token", bot_token },
-			{ "properties", {
-				{ "$browser", "Microsoft Windows 10" },
-				{ "$device", "TriviaBot-0.0" },
-				{ "$referrer", "" },
-				{ "$referring_domain", "" }
-			} },
-			{ "compress", false },
-			{ "large_threshold", 250 },
-			{ "shard", { 0, 1 } }
-		} }
-	};
-
-	c.send(hdl, identify.dump(), websocketpp::frame::opcode::text);
-	Logger::write("Sent identify payload", Logger::LogLevel::Debug);
-}
-
 void GatewayHandler::delete_game(std::string channel_id) {
 	auto it = games.find(channel_id);
 
diff --git a/TriviaBot/bot/GatewayHandler.hpp b/TriviaBot/bot/GatewayHandler.hpp
index 19d579c..f0c8732 100644
--- a/TriviaBot/bot/GatewayHandler.hpp
+++ b/TriviaBot/bot/GatewayHandler.hpp
@@ -45,21 +45,24 @@ public:
 
 	void handle_data(std::string data, client &c, websocketpp::connection_hdl &hdl);
 
-	void heartbeat(client *c, websocketpp::connection_hdl hdl, int interval);
-
-	void on_hello(json decoded, client &c, websocketpp::connection_hdl &hdl);
-
-	void on_dispatch(json decoded, client &c, websocketpp::connection_hdl &hdl);
-
-	void identify(client &c, websocketpp::connection_hdl &hdl);
-
 	void delete_game(std::string channel_id);
 
 private:
 	int last_seq;
 	int heartbeat_interval;
 
-	void on_event_ready(json data);
+	/* payload dispatchers */
+	void send_heartbeat(client *c, websocketpp::connection_hdl hdl, int interval);
+	void send_identify(client &c, websocketpp::connection_hdl &hdl);
+	void send_request_guild_members(client &c, websocketpp::connection_hdl &hdl, std::string guild_id); // not sure if required atm
+
+	/* payload handlers */
+	void on_hello(json decoded, client &c, websocketpp::connection_hdl &hdl);
+	void on_dispatch(json decoded, client &c, websocketpp::connection_hdl &hdl);
+
+	/* misc events */
+	void on_event_ready(json data); // https://discordapp.com/developers/docs/topics/gateway#ready
+	void on_event_presence_update(json data); // https://discordapp.com/developers/docs/topics/gateway#presence-update
 
 	/* guild events */
 	void on_event_guild_create(json data); // https://discordapp.com/developers/docs/topics/gateway#guild-create
@@ -85,8 +88,6 @@ private:
 	// bot's user obj
 	DiscordObjects::User user_object;
 
-	std::unique_ptr<CommandHelper> command_helper;
-
 	/* <id, obj> */
 	std::map<std::string, DiscordObjects::Guild> guilds;
 	std::map<std::string, DiscordObjects::Channel> channels;
@@ -99,8 +100,6 @@ private:
 	std::map<std::string, std::unique_ptr<V8Instance>> v8_instances;
 
 	std::unique_ptr<boost::thread> heartbeat_thread;
-
-	std::shared_ptr<APIHelper> ah;
 };
 
 #endif
\ No newline at end of file
diff --git a/TriviaBot/bot/TriviaBot.cpp b/TriviaBot/bot/TriviaBot.cpp
index 1a22042..f2d970c 100644
--- a/TriviaBot/bot/TriviaBot.cpp
+++ b/TriviaBot/bot/TriviaBot.cpp
@@ -4,6 +4,7 @@
 
 #include "ClientConnection.hpp"
 #include "Logger.hpp"
+#include "DiscordAPI.hpp"
 
 std::string bot_token;
 
@@ -26,21 +27,26 @@ int main(int argc, char *argv[]) {
 		std::cin >> bot_token;
 	}
 
-	// todo: get this using API
-	std::string uri = "wss://gateway.discord.gg/?v=5&encoding=json";
+	std::string args = "/?v=5&encoding=json";
+	std::string url = DiscordAPI::get_gateway().value("url", "wss://gateway.discord.gg");
 
-	try {
-		ClientConnection conn;
-		conn.start(uri);
-	}
-	catch (const std::exception &e) {
-		Logger::write("std exception: " + std::string(e.what()), Logger::LogLevel::Severe);
-	}
-	catch (websocketpp::lib::error_code e) {
-		Logger::write("websocketpp exception: " + e.message(), Logger::LogLevel::Severe);
-	}
-	catch (...) {
-		Logger::write("other exception.", Logger::LogLevel::Severe);
+	bool retry = true;
+	while (retry) {
+		try {
+			ClientConnection conn;
+			conn.start(url + args);
+		}
+		catch (const std::exception &e) {
+			Logger::write("std exception: " + std::string(e.what()), Logger::LogLevel::Severe);
+			retry = false;
+		}
+		catch (websocketpp::lib::error_code e) {
+			Logger::write("websocketpp exception: " + e.message(), Logger::LogLevel::Severe);
+		}
+		catch (...) {
+			Logger::write("other exception.", Logger::LogLevel::Severe);
+			retry = false;
+		}
 	}
 
 	v8::V8::Dispose();
diff --git a/TriviaBot/bot/TriviaGame.cpp b/TriviaBot/bot/TriviaGame.cpp
index 275aa92..7d62884 100644
--- a/TriviaBot/bot/TriviaGame.cpp
+++ b/TriviaBot/bot/TriviaGame.cpp
@@ -10,13 +10,12 @@
 #include <boost/regex.hpp>
 
 #include "GatewayHandler.hpp"
-#include "APIHelper.hpp"
+#include "DiscordAPI.hpp"
 #include "data_structures/User.hpp"
 #include "Logger.hpp"
 
-TriviaGame::TriviaGame(GatewayHandler *gh, std::shared_ptr<APIHelper> ah, std::string channel_id, int total_questions, int delay) : interval(delay) {
+TriviaGame::TriviaGame(GatewayHandler *gh, std::string channel_id, int total_questions, int delay) : interval(delay) {
 	this->gh = gh;
-	this->ah = ah;
 	this->channel_id = channel_id;
 
 	this->total_questions = total_questions;
@@ -27,7 +26,7 @@ TriviaGame::~TriviaGame() {
 	current_thread.reset();
 
 	if (scores.size() == 0) {
-		ah->send_message(channel_id, ":red_circle: Game cancelled!");
+		DiscordAPI::send_message(channel_id, ":red_circle: Game cancelled!");
 		return;
 	}
 
@@ -51,7 +50,7 @@ TriviaGame::~TriviaGame() {
 		average_time.pop_back(); average_time.pop_back(); average_time.pop_back();
 		message += ":small_blue_diamond: <@!" + p.first + ">: " + std::to_string(p.second) + " (Avg: " + average_time + " seconds)\n";
 	}
-	ah->send_message(channel_id, message);
+	DiscordAPI::send_message(channel_id, message);
 
 	sqlite3 *db; int rc; std::string sql;
 
@@ -214,7 +213,7 @@ void TriviaGame::question() {
 		sqlite3_close(db);
 
 		questions_asked++;
-		ah->send_message(channel_id, ":question: **(" + std::to_string(questions_asked) + "/" + std::to_string(total_questions) + ")** " + current_question);
+		DiscordAPI::send_message(channel_id, ":question: **(" + std::to_string(questions_asked) + "/" + std::to_string(total_questions) + ")** " + current_question);
 		question_start = boost::posix_time::microsec_clock::universal_time();
 
 		give_hint(0, "");
@@ -281,11 +280,11 @@ void TriviaGame::give_hint(int hints_given, std::string hint) {
 		hints_given++; // now equal to the amount of [hide_char]s that need to be present in each word
 	
 		if (print) {
-			ah->send_message(channel_id, ":small_orange_diamond: Hint: **`" + hint + "`**");
+			DiscordAPI::send_message(channel_id, ":small_orange_diamond: Hint: **`" + hint + "`**");
 		}
 	}
 	boost::this_thread::sleep(interval);
-	ah->send_message(channel_id, ":exclamation: Question failed. Answer: ** `" + *current_answers.begin() + "` **");
+	DiscordAPI::send_message(channel_id, ":exclamation: Question failed. Answer: ** `" + *current_answers.begin() + "` **");
 }
 
 void TriviaGame::handle_answer(std::string answer, DiscordObjects::User sender) {
@@ -300,7 +299,7 @@ void TriviaGame::handle_answer(std::string answer, DiscordObjects::User sender)
 		// remove the last three 0s
 		time_taken.pop_back(); time_taken.pop_back(); time_taken.pop_back();
 
-		ah->send_message(channel_id, ":heavy_check_mark: <@!" + sender.id + "> You got it! (" + time_taken + " seconds)");
+		DiscordAPI::send_message(channel_id, ":heavy_check_mark: <@!" + sender.id + "> You got it! (" + time_taken + " seconds)");
 
 		increase_score(sender.id);
 		update_average_time(sender.id, diff.total_milliseconds());
diff --git a/TriviaBot/bot/TriviaGame.hpp b/TriviaBot/bot/TriviaGame.hpp
index 4031c1d..89b326f 100644
--- a/TriviaBot/bot/TriviaGame.hpp
+++ b/TriviaBot/bot/TriviaGame.hpp
@@ -11,7 +11,6 @@
 #include <boost/date_time/posix_time/posix_time.hpp>
 
 class GatewayHandler;
-class APIHelper;
 namespace DiscordObjects {
 	class User;
 }
@@ -19,7 +18,7 @@ namespace DiscordObjects {
 
 class TriviaGame {
 public:
-	TriviaGame(GatewayHandler *gh, std::shared_ptr<APIHelper> ah, std::string channel_id, int total_questions, int delay);
+	TriviaGame(GatewayHandler *gh, std::string channel_id, int total_questions, int delay);
 	~TriviaGame();
 
 	void start();
@@ -38,7 +37,6 @@ private:
 
 	std::string channel_id;
 	GatewayHandler *gh;
-	std::shared_ptr<APIHelper> ah;
 
 	const char hide_char = '#';
 
diff --git a/TriviaBot/bot/data_structures/Channel.hpp b/TriviaBot/bot/data_structures/Channel.hpp
index 1529db3..068d0c0 100644
--- a/TriviaBot/bot/data_structures/Channel.hpp
+++ b/TriviaBot/bot/data_structures/Channel.hpp
@@ -57,7 +57,7 @@ namespace DiscordObjects {
 		type = "text";
 	}
 
-	inline Channel::Channel(json data) {
+	inline Channel::Channel(json data) : Channel() {
 		load_from_json(data);
 	}
 
diff --git a/TriviaBot/bot/data_structures/Guild.hpp b/TriviaBot/bot/data_structures/Guild.hpp
index aa90a44..82b7169 100644
--- a/TriviaBot/bot/data_structures/Guild.hpp
+++ b/TriviaBot/bot/data_structures/Guild.hpp
@@ -73,7 +73,7 @@ namespace DiscordObjects {
 		bool unavailable;
 
 		std::vector<Channel *> channels;
-		std::map<std::string, GuildMember> members;
+		std::vector<GuildMember *> members;
 		std::vector<Role *> roles;
 		//std::vector<std::unique_ptr<DiscordObjects::User>>    users;
 	};
@@ -83,13 +83,11 @@ namespace DiscordObjects {
 		afk_timeout = verification_level = -1;
 	}
 
-	inline Guild::Guild(json data) {
+	inline Guild::Guild(json data) : Guild() {
 		load_from_json(data);
 	}
 
 	inline void Guild::load_from_json(json data) {
-		Guild();
-
 		id = data.value("id", "null");
 		name = data.value("name", "null");
 		icon = data.value("icon", "null");
diff --git a/TriviaBot/bot/data_structures/GuildMember.hpp b/TriviaBot/bot/data_structures/GuildMember.hpp
index 0997c21..3c7a06b 100644
--- a/TriviaBot/bot/data_structures/GuildMember.hpp
+++ b/TriviaBot/bot/data_structures/GuildMember.hpp
@@ -30,13 +30,12 @@ namespace DiscordObjects {
 
 	inline GuildMember::GuildMember() {
 		user = nullptr;
-		nick = "null";
-		joined_at = "null";
+		nick = joined_at = "null";
 		deaf = false;
 		mute = false;
 	}
 
-	inline GuildMember::GuildMember(json data, User *user) {
+	inline GuildMember::GuildMember(json data, User *user) : GuildMember() {
 		this->user = user;
 		load_from_json(data);
 	}
@@ -54,6 +53,8 @@ namespace DiscordObjects {
 			+ "\n**bot:** " + std::to_string(user->bot)
 			+ "\n**mfa_enabled:** " + std::to_string(user->mfa_enabled)
 			+ "\n**avatar:** " + user->avatar
+			+ "\n**status:** " + user->status
+			+ "\n**game name:** " + user->game
 			+ "\n**nick:** " + nick
 			+ "\n**joined_at:** " + joined_at
 			+ "\n**deaf:** " + std::to_string(deaf)
diff --git a/TriviaBot/bot/data_structures/Role.hpp b/TriviaBot/bot/data_structures/Role.hpp
index 1e88a72..6de6080 100644
--- a/TriviaBot/bot/data_structures/Role.hpp
+++ b/TriviaBot/bot/data_structures/Role.hpp
@@ -42,7 +42,7 @@ namespace DiscordObjects {
 		mentionable = false;
 	}
 
-	inline Role::Role(json data) {
+	inline Role::Role(json data) : Role() {
 		load_from_json(data);
 	}
 
diff --git a/TriviaBot/bot/data_structures/User.hpp b/TriviaBot/bot/data_structures/User.hpp
index 546a1fc..8e39f44 100644
--- a/TriviaBot/bot/data_structures/User.hpp
+++ b/TriviaBot/bot/data_structures/User.hpp
@@ -39,15 +39,20 @@ namespace DiscordObjects {
 		bool bot;
 		bool mfa_enabled;
 
+		// presence
+		std::string game;
+		std::string status;
+
 		std::vector<std::string> guilds;
 	};
 
 	inline User::User() {
-		id = username = discriminator = avatar = "null";
+		id = username = discriminator = avatar = game = "null";
+		status = "offline";
 		bot = mfa_enabled = false;
 	}
 
-	inline User::User(json data) {
+	inline User::User(json data) : User() {
 		load_from_json(data);
 	}
 
diff --git a/TriviaBot/bot/http/HTTPHelper.cpp b/TriviaBot/bot/http/HTTPHelper.cpp
index 5c76703..d1e98ee 100644
--- a/TriviaBot/bot/http/HTTPHelper.cpp
+++ b/TriviaBot/bot/http/HTTPHelper.cpp
@@ -8,52 +8,97 @@ extern std::string bot_token;
 *  Warning: (Awful) C Code
 */
 
-std::string HTTPHelper::post_request(std::string url, std::string content_type, std::string data, long *response_code) {
-	CURL *curl;
-	CURLcode res;
-	std::string read_buffer;
-	struct curl_slist *headers = nullptr;
-
-	curl = curl_easy_init();
-	if (curl) {
-		curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
-
-		// Now with real HTTPS!
-		curl_easy_setopt(curl, CURLOPT_CAINFO, "bot/http/DiscordCA.crt");
-
-		std::string header_arr[3];
-		header_arr[0] = "Content-Type: " + content_type;
-		header_arr[1] = "Authorization: Bot " + bot_token;
-		header_arr[2] = "User-Agent: DiscordBot(http://github.com/jackb-p/triviadiscord, 1.0)";
-
-		for (std::string h : header_arr) {
-			headers = curl_slist_append(headers, h.c_str());
-		}
-
-		curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
-
-		curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data.c_str());
-
-		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
-		curl_easy_setopt(curl, CURLOPT_WRITEDATA, &read_buffer);
-
-		res = curl_easy_perform(curl);
-
-		if (res == CURLE_OK) {
-			curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, response_code);
-		} else {
-			Logger::write("curl error", Logger::LogLevel::Warning);
-			return "";
-		}
-
-		curl_easy_cleanup(curl);
-		curl_slist_free_all(headers);
+namespace HTTP {
+	size_t write_callback(void *contents, size_t size, size_t nmemb, void *read_buffer) {
+		static_cast<std::string *>(read_buffer)->append(static_cast<char *>(contents), size * nmemb);
+		return size * nmemb;
 	}
 
-	return read_buffer;
-}
+	std::string post_request(std::string url, std::string content_type, std::string data, long *response_code) {
+		CURL *curl;
+		CURLcode res;
+		std::string read_buffer;
+		struct curl_slist *headers = nullptr;
 
-size_t HTTPHelper::write_callback(void *contents, size_t size, size_t nmemb, void *userp) {
-	((std::string *) userp)->append((char *) contents, size * nmemb);
-	return size * nmemb;
+		curl = curl_easy_init();
+		if (curl) {
+			curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+
+			// Now with real HTTPS!
+			curl_easy_setopt(curl, CURLOPT_CAINFO, "bot/http/DiscordCA.crt");
+
+			std::string header_arr[3];
+			header_arr[0] = "Content-Type: " + content_type;
+			header_arr[1] = "Authorization: Bot " + bot_token;
+			header_arr[2] = "User-Agent: DiscordBot(http://github.com/jackb-p/triviadiscord, 1.0)";
+
+			for (std::string h : header_arr) {
+				headers = curl_slist_append(headers, h.c_str());
+			}
+
+			curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+
+			curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data.c_str());
+
+			curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
+			curl_easy_setopt(curl, CURLOPT_WRITEDATA, &read_buffer);
+
+			res = curl_easy_perform(curl);
+
+			if (res == CURLE_OK) {
+				curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, response_code);
+			}
+			else {
+				return "";
+			}
+
+			curl_easy_cleanup(curl);
+			curl_slist_free_all(headers);
+		}
+
+		return read_buffer;
+	}
+
+	std::string get_request(std::string url, long *response_code) {
+		CURL *curl;
+		CURLcode res;
+		std::string read_buffer;
+		struct curl_slist *headers = nullptr;
+
+		curl = curl_easy_init();
+		if (curl) {
+			curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+
+			// Now with real HTTPS!
+			curl_easy_setopt(curl, CURLOPT_CAINFO, "bot/http/DiscordCA.crt");
+
+			std::string header_arr[2];
+			header_arr[0] = "Authorization: Bot " + bot_token;
+			header_arr[1] = "User-Agent: DiscordBot (http://github.com/jackb-p/triviadiscord, 1.0)";
+
+			for (std::string h : header_arr) {
+				headers = curl_slist_append(headers, h.c_str());
+			}
+
+			curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+
+			curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &HTTP::write_callback);
+			curl_easy_setopt(curl, CURLOPT_WRITEDATA, &read_buffer);
+
+			res = curl_easy_perform(curl);
+
+			if (res == CURLE_OK) {
+				curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, response_code);
+			}
+			else {
+				Logger::write("curl error: " + std::string(curl_easy_strerror(res)), Logger::LogLevel::Warning);
+				return read_buffer;
+			}
+
+			curl_easy_cleanup(curl);
+			curl_slist_free_all(headers);
+		}
+
+		return read_buffer;
+	}
 }
\ No newline at end of file
diff --git a/TriviaBot/bot/http/HTTPHelper.hpp b/TriviaBot/bot/http/HTTPHelper.hpp
index 3010eff..1acc725 100644
--- a/TriviaBot/bot/http/HTTPHelper.hpp
+++ b/TriviaBot/bot/http/HTTPHelper.hpp
@@ -5,12 +5,9 @@
 
 #include <curl/curl.h>
 
-class HTTPHelper {
-public:
+namespace HTTP {
 	std::string post_request(std::string url, std::string content_type, std::string data, long *response_code);
-
-private:
-	static size_t write_callback(void *contents, size_t size, size_t nmemb, void *userp);
-};
+	std::string get_request(std::string url, long *response_code);
+}
 
 #endif
\ No newline at end of file
diff --git a/TriviaBot/bot/js/CommandHelper.cpp b/TriviaBot/bot/js/CommandHelper.cpp
index 4722632..afd8c2e 100644
--- a/TriviaBot/bot/js/CommandHelper.cpp
+++ b/TriviaBot/bot/js/CommandHelper.cpp
@@ -7,150 +7,158 @@
 
 #include "../Logger.hpp"
 
-CommandHelper::CommandHelper() {
-	sqlite3 *db; int return_code;
-	return_code = sqlite3_open("bot/db/trivia.db", &db);
+namespace CommandHelper {
+	std::vector<Command> commands;
 
-	std::string sql = "SELECT * FROM CustomJS";
+	void init() {
+		sqlite3 *db; int return_code;
+		return_code = sqlite3_open("bot/db/trivia.db", &db);
 
-	sqlite3_stmt *stmt;
-	return_code = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
+		std::string sql = "SELECT * FROM CustomJS";
+
+		sqlite3_stmt *stmt;
+		return_code = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
 
 
-	while (return_code != SQLITE_DONE) {
-		return_code = sqlite3_step(stmt);
+		while (return_code != SQLITE_DONE) {
+			return_code = sqlite3_step(stmt);
 
-		if (return_code == SQLITE_ROW) {
-			std::string guild_id = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0));
-			std::string command_name = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 1));
-			std::string script = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 2));
+			if (return_code == SQLITE_ROW) {
+				std::string guild_id = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 0));
+				std::string command_name = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 1));
+				std::string script = reinterpret_cast<const char *>(sqlite3_column_text(stmt, 2));
 
-			commands.push_back({ guild_id, command_name, script });
-		}
-		else if (return_code != SQLITE_DONE) {
-			sqlite3_finalize(stmt);
-			std::cerr << "SQLite error." << std::endl;
-			return;
-		}
-	}
-
-	Logger::write(std::to_string(commands.size()) + " custom command(s) loaded", Logger::LogLevel::Info);
-
-	sqlite3_finalize(stmt);
-	sqlite3_close(db);
-}
-
-bool CommandHelper::get_command(std::string guild_id, std::string command_name, Command &command) {
-	auto check_lambda = [guild_id, command_name](const Command &c) {
-		return guild_id == c.guild_id && command_name == c.command_name;
-	};
-
-	auto it = std::find_if(commands.begin(), commands.end(), check_lambda);
-	if (it == commands.end()) {
-		command = {};
-		return false;
-	} else {
-		command = { it->guild_id, it->command_name, it->script };
-	}
-}
-
-// returns: 0 error, 1 inserted, 2 updated
-int CommandHelper::insert_command(std::string guild_id, std::string command_name, std::string script) {
-	// TODO: if script empty, delete command
-
-	Command command { guild_id, command_name, script };
-
-	int ret_value;
-	std::string sql;
-	if (command_in_db(guild_id, command_name)) {
-		sql = "UPDATE CustomJS SET Script=?1 WHERE GuildID=?2 AND CommandName=?3;";
-		std::cout << "Command already exists, updating." << std::endl;
-		ret_value = 2;
-	} else {
-		sql = "INSERT INTO CustomJS(Script, GuildID, CommandName) VALUES (?1, ?2, ?3);";
-		std::cout << "Inserting new command." << std::endl;
-		ret_value = 1;
-	}
-
-	sqlite3 *db; int return_code;
-	return_code = sqlite3_open("bot/db/trivia.db", &db);
-	if (!return_code_ok(return_code)) return 0;
-
-	sqlite3_stmt *stmt;
-	return_code = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
-	if (!return_code_ok(return_code)) return 0;
-
-	return_code = sqlite3_bind_text(stmt, 1, script.c_str(), -1, (sqlite3_destructor_type)-1);
-	if (!return_code_ok(return_code)) return 0;
-
-	return_code = sqlite3_bind_text(stmt, 2, guild_id.c_str(), -1, (sqlite3_destructor_type)-1);
-	if (!return_code_ok(return_code)) return 0;
-
-	return_code = sqlite3_bind_text(stmt, 3, command_name.c_str(), -1, (sqlite3_destructor_type)-1);
-	if (!return_code_ok(return_code)) return 0;
-
-	return_code = sqlite3_step(stmt);
-	bool success = return_code == SQLITE_DONE;
-
-	sqlite3_finalize(stmt);
-	sqlite3_close(db);
-
-	if (success) {
-		if (ret_value == 1) {
-			commands.push_back({ guild_id, command_name, script });
-		}
-		if (ret_value == 2) {
-			// update command, don't add
-			auto check_lambda = [guild_id, command_name](const Command &c) {
-				return guild_id == c.guild_id && command_name == c.command_name;
-			};
-
-			auto it = std::find_if(commands.begin(), commands.end(), check_lambda);
-			if (it == commands.end()) {
-				return 0;
-			} else {
-				it->script = script;
+				commands.push_back({ guild_id, command_name, script });
+			}
+			else if (return_code != SQLITE_DONE) {
+				sqlite3_finalize(stmt);
+				std::cerr << "SQLite error." << std::endl;
+				return;
 			}
 		}
 
-		return ret_value;
+		Logger::write(std::to_string(commands.size()) + " custom command(s) loaded", Logger::LogLevel::Info);
+
+		sqlite3_finalize(stmt);
+		sqlite3_close(db);
 	}
 
-	return 0;
-}
-
-bool CommandHelper::command_in_db(std::string guild_id, std::string command_name) {
-	sqlite3 *db; int return_code;
-	return_code = sqlite3_open("bot/db/trivia.db", &db);
-	if (!return_code_ok(return_code)) return false;
-
-	std::string sql = "SELECT EXISTS(SELECT 1 FROM CustomJS WHERE GuildID=?1 AND CommandName=?2);";
-
-	sqlite3_stmt *stmt;
-	return_code = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
-	if (!return_code_ok(return_code)) return false;
-
-	return_code = sqlite3_bind_text(stmt, 1, guild_id.c_str(), -1, (sqlite3_destructor_type) -1);
-	if (!return_code_ok(return_code)) return false;
-
-	return_code = sqlite3_bind_text(stmt, 2, command_name.c_str(), -1, (sqlite3_destructor_type) -1);
-	if (!return_code_ok(return_code)) return false;
-
-	sqlite3_step(stmt);
-
-	bool exists = sqlite3_column_int(stmt, 0) == 1; // returns 1 (true) if exists
-
-	sqlite3_finalize(stmt);
-	sqlite3_close(db);
-
-	return exists;
-}
-
-bool CommandHelper::return_code_ok(int return_code) {
-	// TODO: NotLikeThis
-	if (return_code != SQLITE_OK) {
-		Logger::write("SQLite error", Logger::LogLevel::Severe);
-		return false;
+	bool return_code_ok(int return_code) {
+		// TODO: NotLikeThis
+		if (return_code != SQLITE_OK) {
+			Logger::write("SQLite error", Logger::LogLevel::Severe);
+			return false;
+		}
+		return true;
+	}
+
+	bool get_command(std::string guild_id, std::string command_name, Command &command) {
+		auto check_lambda = [guild_id, command_name](const Command &c) {
+			return guild_id == c.guild_id && command_name == c.command_name;
+		};
+
+		auto it = std::find_if(commands.begin(), commands.end(), check_lambda);
+		if (it == commands.end()) {
+			command = {};
+			return false;
+		}
+		else {
+			command = { it->guild_id, it->command_name, it->script };
+			return true;
+		}
+	}
+
+	// returns: 0 error, 1 inserted, 2 updated
+	int insert_command(std::string guild_id, std::string command_name, std::string script) {
+		// TODO: if script empty, delete command
+
+		Command command{ guild_id, command_name, script };
+
+		int ret_value;
+		std::string sql;
+		if (command_in_db(guild_id, command_name)) {
+			sql = "UPDATE CustomJS SET Script=?1 WHERE GuildID=?2 AND CommandName=?3;";
+			Logger::write("Command already exists, updating.", Logger::LogLevel::Debug);
+			ret_value = 2;
+		}
+		else {
+			sql = "INSERT INTO CustomJS(Script, GuildID, CommandName) VALUES (?1, ?2, ?3);";
+			Logger::write("Inserting new command.", Logger::LogLevel::Debug);
+			ret_value = 1;
+		}
+
+		sqlite3 *db; int return_code;
+		return_code = sqlite3_open("bot/db/trivia.db", &db);
+		if (!return_code_ok(return_code)) return 0;
+
+		sqlite3_stmt *stmt;
+		return_code = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
+		if (!return_code_ok(return_code)) return 0;
+
+		return_code = sqlite3_bind_text(stmt, 1, script.c_str(), -1, (sqlite3_destructor_type)-1);
+		if (!return_code_ok(return_code)) return 0;
+
+		return_code = sqlite3_bind_text(stmt, 2, guild_id.c_str(), -1, (sqlite3_destructor_type)-1);
+		if (!return_code_ok(return_code)) return 0;
+
+		return_code = sqlite3_bind_text(stmt, 3, command_name.c_str(), -1, (sqlite3_destructor_type)-1);
+		if (!return_code_ok(return_code)) return 0;
+
+		return_code = sqlite3_step(stmt);
+		bool success = return_code == SQLITE_DONE;
+
+		sqlite3_finalize(stmt);
+		sqlite3_close(db);
+
+		if (success) {
+			if (ret_value == 1) {
+				commands.push_back({ guild_id, command_name, script });
+			}
+			if (ret_value == 2) {
+				// update command, don't add
+				auto check_lambda = [guild_id, command_name](const Command &c) {
+					return guild_id == c.guild_id && command_name == c.command_name;
+				};
+
+				auto it = std::find_if(commands.begin(), commands.end(), check_lambda);
+				if (it == commands.end()) {
+					return 0;
+				}
+				else {
+					it->script = script;
+				}
+			}
+
+			return ret_value;
+		}
+
+		return 0;
+	}
+
+	bool command_in_db(std::string guild_id, std::string command_name) {
+		sqlite3 *db; int return_code;
+		return_code = sqlite3_open("bot/db/trivia.db", &db);
+		if (!return_code_ok(return_code)) return false;
+
+		std::string sql = "SELECT EXISTS(SELECT 1 FROM CustomJS WHERE GuildID=?1 AND CommandName=?2);";
+
+		sqlite3_stmt *stmt;
+		return_code = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
+		if (!return_code_ok(return_code)) return false;
+
+		return_code = sqlite3_bind_text(stmt, 1, guild_id.c_str(), -1, (sqlite3_destructor_type)-1);
+		if (!return_code_ok(return_code)) return false;
+
+		return_code = sqlite3_bind_text(stmt, 2, command_name.c_str(), -1, (sqlite3_destructor_type)-1);
+		if (!return_code_ok(return_code)) return false;
+
+		sqlite3_step(stmt);
+
+		bool exists = sqlite3_column_int(stmt, 0) == 1; // returns 1 (true) if exists
+
+		sqlite3_finalize(stmt);
+		sqlite3_close(db);
+
+		return exists;
 	}
-	return true;
 }
\ No newline at end of file
diff --git a/TriviaBot/bot/js/CommandHelper.hpp b/TriviaBot/bot/js/CommandHelper.hpp
index 2f95fd9..a34d6c8 100644
--- a/TriviaBot/bot/js/CommandHelper.hpp
+++ b/TriviaBot/bot/js/CommandHelper.hpp
@@ -3,23 +3,17 @@
 
 #include <vector>
 
-struct Command {
-	std::string guild_id;
-	std::string command_name;
-	std::string script;
-};
+namespace CommandHelper {
+	struct Command {
+		std::string guild_id;
+		std::string command_name;
+		std::string script;
+	};
 
-class CommandHelper {
-public:
-	CommandHelper();
+	void init();
 	int insert_command(std::string guild_id, std::string command_name, std::string script);
 	bool get_command(std::string guild_id, std::string name, Command &command);
-
-private:
 	bool command_in_db(std::string guild_id, std::string command_name);
-	bool return_code_ok(int return_code);
-
-	std::vector<Command> commands;
-};
+}
 
 #endif
\ No newline at end of file
diff --git a/TriviaBot/bot/js/V8Instance.cpp b/TriviaBot/bot/js/V8Instance.cpp
index 04ed7c3..6a6f9b1 100644
--- a/TriviaBot/bot/js/V8Instance.cpp
+++ b/TriviaBot/bot/js/V8Instance.cpp
@@ -1,15 +1,17 @@
 #include <iostream>
 #include <string>
+#include <chrono>
+#include <algorithm>
 
 #include "V8Instance.hpp"
-#include "../APIHelper.hpp"
+#include "../DiscordAPI.hpp"
 #include "../Logger.hpp"
 
-V8Instance::V8Instance(std::string guild_id, std::shared_ptr<APIHelper> ah, std::map<std::string, DiscordObjects::Guild> *guilds, std::map<std::string, DiscordObjects::Channel> *channels,
+V8Instance::V8Instance(std::string guild_id, std::map<std::string, DiscordObjects::Guild> *guilds, std::map<std::string, DiscordObjects::Channel> *channels,
 	std::map<std::string, DiscordObjects::User> *users, std::map<std::string, DiscordObjects::Role> *roles) {
 
+	rng = std::mt19937(std::random_device()());
 	this->guild_id = guild_id;
-	this->ah = ah;
 	this->guilds = guilds;
 	this->channels = channels;
 	this->users = users;
@@ -35,96 +37,645 @@ void V8Instance::create() {
 
 	// set global context
 	Local<Context> context = create_context();
-	context->Enter();
+	context_.Reset(isolate, context);
 	Context::Scope context_scope(context);
+
+	initialise(context);
+
 	Logger::write("[v8] Created context and context scope", Logger::LogLevel::Debug);
 }
 
+void V8Instance::initialise(Local<Context> context) {
+	HandleScope handle_scope(isolate);
+
+	Local<Object> opts_obj = wrap_server(&(*guilds)[guild_id]);
+	
+	context->Global()->Set(
+		context, 
+		String::NewFromUtf8(isolate, "server", NewStringType::kNormal).ToLocalChecked(), 
+		opts_obj
+	).FromJust();
+
+	Logger::write("[v8] Bound server template", Logger::LogLevel::Debug);
+}
+
 v8::Local<v8::Context> V8Instance::create_context() {
 	Local<ObjectTemplate> global = ObjectTemplate::New(isolate);
-	// bind print() function
-	Local<External> self = External::New(isolate, (void *) this);
 
+	Local<External> self = External::New(isolate, (void *) this);
 	global->Set(
-		String::NewFromUtf8(isolate, "print", NewStringType::kNormal).ToLocalChecked(),
+		String::NewFromUtf8(isolate, "print", NewStringType::kNormal).ToLocalChecked(), 
 		FunctionTemplate::New(isolate, V8Instance::js_print, self)
 	);
-	global->SetAccessor(
-		String::NewFromUtf8(isolate, "server", NewStringType::kNormal).ToLocalChecked(), 
-		V8Instance::js_get_server, 
-		(AccessorSetterCallback) 0, 
-		self
+	global->Set(
+		String::NewFromUtf8(isolate, "random", NewStringType::kNormal).ToLocalChecked(),
+		FunctionTemplate::New(isolate, V8Instance::js_random, self)
 	);
-	global->SetAccessor(
-		String::NewFromUtf8(isolate, "channel", NewStringType::kNormal).ToLocalChecked(), 
-		V8Instance::js_get_channel, 
-		(AccessorSetterCallback) 0, 
-		self
-	); 
-	global->SetAccessor(
-		String::NewFromUtf8(isolate, "user", NewStringType::kNormal).ToLocalChecked(), 
-		V8Instance::js_get_user,
-		(AccessorSetterCallback) 0, 
-		self
-	); 
-	global->SetAccessor(
-		String::NewFromUtf8(isolate, "input", NewStringType::kNormal).ToLocalChecked(), 
-		V8Instance::js_get_input, 
-		(AccessorSetterCallback) 0, 
-		self
+	global->Set(
+		String::NewFromUtf8(isolate, "shuffle", NewStringType::kNormal).ToLocalChecked(),
+		FunctionTemplate::New(isolate, V8Instance::js_shuffle, self)
 	);
 
-	Logger::write("[v8] Created global obj, linked data and functions", Logger::LogLevel::Debug);
+	Logger::write("[v8] Created global context, added print function", Logger::LogLevel::Debug);
 
 	return Context::New(isolate, NULL, global);
 }
 
-void V8Instance::js_get_server(Local<String> property, const PropertyCallbackInfo<Value> &info) {
-	auto data = info.Data().As<External>();
-	V8Instance *self = static_cast<V8Instance *>(data->Value());
+/* server */
+Local<ObjectTemplate> V8Instance::make_server_template() {
+	EscapableHandleScope handle_scope(isolate);
 
-	Local<Object> obj = Object::New(info.GetIsolate());
-	self->add_to_obj(obj, (*self->guilds)[self->guild_id]);
-	info.GetReturnValue().Set(obj);
+	Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+	templ->SetInternalFieldCount(1);
+	templ->SetHandler(
+		NamedPropertyHandlerConfiguration(
+			V8Instance::js_get_server,
+			(GenericNamedPropertySetterCallback) 0,
+			(GenericNamedPropertyQueryCallback) 0,
+			(GenericNamedPropertyDeleterCallback) 0,
+			(GenericNamedPropertyEnumeratorCallback) 0,
+			External::New(isolate, (void *) this)
+		)
+	);
+
+	return handle_scope.Escape(templ);
 }
 
-void V8Instance::js_get_channel(Local<String> property, const PropertyCallbackInfo<Value> &info) {
-	auto data = info.Data().As<External>();
-	V8Instance *self = static_cast<V8Instance *>(data->Value());
+Local<Object> V8Instance::wrap_server(DiscordObjects::Guild *guild) {
+	EscapableHandleScope handle_scope(isolate);
 
-	if (!self->current_channel) {
-		Logger::write("[v8] current_channel is null pointer", Logger::LogLevel::Severe);
-		info.GetReturnValue().SetNull();
-		return;
+	if (server_template.IsEmpty()) {
+		Local<ObjectTemplate> raw_template = make_server_template();
+		server_template.Reset(isolate, raw_template);
 	}
 
-	Local<Object> obj = Object::New(info.GetIsolate());
-	self->add_to_obj(obj, (*self->current_channel));
-	info.GetReturnValue().Set(obj);
+	Local<ObjectTemplate> templ = Local<ObjectTemplate>::New(isolate, server_template);
+	Local<Object> result = templ->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
+
+	Local<External> guild_ptr = External::New(isolate, guild);
+	result->SetInternalField(0, guild_ptr);
+
+	return handle_scope.Escape(result);
 }
 
-void V8Instance::js_get_user(Local<String> property, const PropertyCallbackInfo<Value> &info) {
-	auto data = info.Data().As<External>();
-	V8Instance *self = static_cast<V8Instance *>(data->Value());
-
-	if (!self->current_sender) {
-		Logger::write("[v8] current_sender is null pointer", Logger::LogLevel::Severe);
-		info.GetReturnValue().SetNull();
+void V8Instance::js_get_server(Local<Name> property, const PropertyCallbackInfo<Value> &info) {
+	void *self_v = info.Data().As<External>()->Value();
+	if (!self_v) {
+		Logger::write("[v8] [js_get_server] Class pointer empty", Logger::LogLevel::Warning);
 		return;
 	}
+	V8Instance *self = static_cast<V8Instance *>(self_v);
 
-	Local<Object> obj = Object::New(info.GetIsolate());
-	self->add_to_obj(obj, (*self->current_sender));
-	info.GetReturnValue().Set(obj);
+	void *guild_v = info.Holder()->GetInternalField(0).As<External>()->Value();
+	if (!guild_v) {
+		Logger::write("[v8] [js_get_server] Guild pointer empty", Logger::LogLevel::Warning);
+		return;
+	}
+	DiscordObjects::Guild *guild = static_cast<DiscordObjects::Guild *>(guild_v);
+
+	if (!property->IsString()) {
+		return;
+	}
+	std::string property_s = *String::Utf8Value(property);
+
+	if (property_s == "Id") {
+		info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), guild->id.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else if (property_s == "Name") {
+		info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), guild->name.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else if (property_s == "IconUrl") {
+		std::string icon_url = "https://discordapp.com/api/guilds/" + guild->id + "/icons/" + guild->icon + ".jpg";
+		info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), icon_url.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else if (property_s == "Owner") {
+		std::string owner_id = guild->owner_id;
+		DiscordObjects::GuildMember *owner = *std::find_if(guild->members.begin(), guild->members.end(), [owner_id](DiscordObjects::GuildMember *m) {
+			return owner_id == m->user->id;
+		});
+		Local<Object> owner_obj = self->wrap_user(owner);
+		info.GetReturnValue().Set(owner_obj);
+	}
+	else if (property_s == "Roles") {
+		Local<Object> roles_obj = self->wrap_role_list(&guild->roles);
+		info.GetReturnValue().Set(roles_obj);
+	}
+	else if (property_s == "Channels") {
+		Local<Object> channels_obj = self->wrap_channel_list(&guild->channels);
+		info.GetReturnValue().Set(channels_obj);
+	}
+	else if (property_s == "Users") {
+		Local<Object> users_obj = self->wrap_user_list(&guild->members);
+		info.GetReturnValue().Set(users_obj);
+	}
 }
 
-void V8Instance::js_get_input(Local<String> property, const PropertyCallbackInfo<Value> &info) {
-	auto data = info.Data().As<External>();
+
+/* channel */
+Local<ObjectTemplate> V8Instance::make_channel_template() {
+	EscapableHandleScope handle_scope(isolate);
+
+	Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+	templ->SetInternalFieldCount(1);
+	templ->SetHandler(
+		NamedPropertyHandlerConfiguration(
+			V8Instance::js_get_channel,
+			(GenericNamedPropertySetterCallback) 0,
+			(GenericNamedPropertyQueryCallback) 0,
+			(GenericNamedPropertyDeleterCallback) 0,
+			(GenericNamedPropertyEnumeratorCallback) 0,
+			External::New(isolate, (void *) this)
+		)
+	);
+
+	return handle_scope.Escape(templ);
+}
+
+Local<Object> V8Instance::wrap_channel(DiscordObjects::Channel *channel) {
+	EscapableHandleScope handle_scope(isolate);
+
+	if (role_template.IsEmpty()) {
+		Local<ObjectTemplate> raw_template = make_channel_template();
+		channel_template.Reset(isolate, raw_template);
+	}
+
+	Local<ObjectTemplate> templ = Local<ObjectTemplate>::New(isolate, channel_template);
+	Local<Object> result = templ->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
+
+	Local<External> channel_ptr = External::New(isolate, channel);
+	result->SetInternalField(0, channel_ptr);
+
+	return handle_scope.Escape(result);
+}
+
+void V8Instance::js_get_channel(Local<Name> property, const PropertyCallbackInfo<Value> &info) {
+	void *self_v = info.Data().As<External>()->Value();
+	if (!self_v) {
+		Logger::write("[v8] [js_get_channel] Class pointer empty", Logger::LogLevel::Warning);
+		return;
+	}
+	V8Instance *self = static_cast<V8Instance *>(self_v);
+
+	void *channel_v = info.Holder()->GetInternalField(0).As<External>()->Value();
+	if (!channel_v) {
+		Logger::write("[v8] [js_get_channel] Channel pointer empty", Logger::LogLevel::Warning);
+		return;
+	}
+	DiscordObjects::Channel *channel = static_cast<DiscordObjects::Channel *>(channel_v);
+
+	if (!property->IsString()) {
+		return;
+	}
+	std::string property_s = *String::Utf8Value(property);
+
+	if (property_s == "Id") {
+		info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), channel->id.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else if (property_s == "Name") {
+		info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), channel->name.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else if (property_s == "Topic") {
+		info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), channel->topic.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else if (property_s == "IsVoice") {
+		info.GetReturnValue().Set(Boolean::New(info.GetIsolate(), channel->type == "voice"));
+	}
+	else if (property_s == "Users") {
+		info.GetIsolate()->ThrowException(String::NewFromUtf8(info.GetIsolate(), "Channel.Users not implemented.", NewStringType::kNormal).ToLocalChecked());
+	}
+}
+
+/* channel list */
+Local<ObjectTemplate> V8Instance::make_channel_list_template() {
+	EscapableHandleScope handle_scope(isolate);
+
+	Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+	templ->SetInternalFieldCount(1);
+	templ->SetHandler(
+		IndexedPropertyHandlerConfiguration(
+			V8Instance::js_get_channel_list,
+			(IndexedPropertySetterCallback) 0,
+			(IndexedPropertyQueryCallback) 0,
+			(IndexedPropertyDeleterCallback) 0,
+			(IndexedPropertyEnumeratorCallback) 0,
+			External::New(isolate, (void *) this)
+		)
+	);
+
+	return handle_scope.Escape(templ);
+}
+
+Local<Object> V8Instance::wrap_channel_list(std::vector<DiscordObjects::Channel *> *channel_list) {
+	EscapableHandleScope handle_scope(isolate);
+
+	if (channel_list_template.IsEmpty()) {
+		Local<ObjectTemplate> raw_template = make_channel_list_template();
+		channel_list_template.Reset(isolate, raw_template);
+	}
+
+	Local<ObjectTemplate> templ = Local<ObjectTemplate>::New(isolate, channel_list_template);
+	Local<Object> result = templ->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
+
+	// imitate an array
+	result->Set(String::NewFromUtf8(isolate, "length", NewStringType::kNormal).ToLocalChecked(), Integer::New(isolate, (*channel_list).size()));
+	result->SetPrototype(Array::New(isolate)->GetPrototype());
+
+	Local<External> channel_list_ptr = External::New(isolate, channel_list);
+	result->SetInternalField(0, channel_list_ptr);
+
+	return handle_scope.Escape(result);
+}
+
+void V8Instance::js_get_channel_list(uint32_t index, const PropertyCallbackInfo<Value> &info) {
+	void *self_v = info.Data().As<External>()->Value();
+	if (!self_v) {
+		Logger::write("[v8] [js_get_channel_list] Class pointer empty", Logger::LogLevel::Warning);
+		return;
+	}
+	V8Instance *self = static_cast<V8Instance *>(self_v);
+
+	void *channel_list_v = info.Holder()->GetInternalField(0).As<External>()->Value();
+	if (!channel_list_v) {
+		Logger::write("[v8] [js_get_channel_list] Channel List pointer empty", Logger::LogLevel::Warning);
+		return;
+	}
+	std::vector<DiscordObjects::Channel *> *channel_list = static_cast<std::vector<DiscordObjects::Channel *> *>(channel_list_v);
+
+
+	if (index < (*channel_list).size()) {
+		Local<Object> channel_obj = self->wrap_channel((*channel_list)[index]);
+		info.GetReturnValue().Set(channel_obj);
+	}
+	else {
+		info.GetReturnValue().SetUndefined();
+	}
+}
+
+
+/* user */
+Local<ObjectTemplate> V8Instance::make_user_template() {
+	EscapableHandleScope handle_scope(isolate);
+
+	Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+	templ->SetInternalFieldCount(1);
+	templ->SetHandler(
+		NamedPropertyHandlerConfiguration(
+			V8Instance::js_get_user,
+			(GenericNamedPropertySetterCallback)0,
+			(GenericNamedPropertyQueryCallback)0,
+			(GenericNamedPropertyDeleterCallback)0,
+			(GenericNamedPropertyEnumeratorCallback)0,
+			External::New(isolate, (void *) this)
+		)
+	);
+
+	return handle_scope.Escape(templ);
+}
+
+Local<Object> V8Instance::wrap_user(DiscordObjects::GuildMember *member) {
+	EscapableHandleScope handle_scope(isolate);
+
+	if (user_template.IsEmpty()) {
+		Local<ObjectTemplate> raw_template = make_user_template();
+		user_template.Reset(isolate, raw_template);
+	}
+
+	Local<ObjectTemplate> templ = Local<ObjectTemplate>::New(isolate, user_template);
+	Local<Object> result = templ->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
+
+	Local<External> member_ptr = External::New(isolate, member);
+	result->SetInternalField(0, member_ptr);
+
+	return handle_scope.Escape(result);
+}
+
+void V8Instance::js_get_user(Local<Name> property, const PropertyCallbackInfo<Value> &info) {
+	void *self_v = info.Data().As<External>()->Value();
+	if (!self_v) {
+		Logger::write("[v8] [js_get_user] Class pointer empty", Logger::LogLevel::Warning);
+		return;
+	}
+	V8Instance *self = static_cast<V8Instance *>(self_v);
+
+	void *member_v = info.Holder()->GetInternalField(0).As<External>()->Value();
+	if (!member_v) {
+		Logger::write("[v8] [js_get_user] GuildMember pointer empty", Logger::LogLevel::Warning);
+		return;
+	}
+	DiscordObjects::GuildMember *member = static_cast<DiscordObjects::GuildMember *>(member_v);
+
+	if (!property->IsString()) {
+		return;
+	}
+	std::string property_s = *String::Utf8Value(property);
+
+	if (property_s == "Id") {
+		info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), member->user->id.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else if (property_s == "Name") {
+		std::string name = member->nick == "null" ? member->user->username : member->nick;
+		info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), name.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else if (property_s == "Mention") {
+		std::string mention = "<@" + member->user->id + ">";
+		info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), mention.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else if (property_s == "AvatarUrl") {
+		std::string avatar_url = "https://discordapp.com/api/users/" + member->user->id + "/avatars/" + member->user->avatar + ".jpg";
+		info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), avatar_url.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else if (property_s == "Roles") {
+		Local<Object> roles_obj = self->wrap_role_list(&member->roles);
+		info.GetReturnValue().Set(roles_obj);
+	}
+	else if (property_s == "State") {
+		info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), member->user->status.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else if (property_s == "CurrentGame") {
+		if (member->user->game == "null") {
+			info.GetReturnValue().SetNull();
+		} else {
+			info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), member->user->game.c_str(), NewStringType::kNormal).ToLocalChecked());
+		}
+	}
+}
+
+/* user list */
+Local<ObjectTemplate> V8Instance::make_user_list_template() {
+	EscapableHandleScope handle_scope(isolate);
+
+	Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+	templ->SetInternalFieldCount(1);
+	templ->SetHandler(
+		IndexedPropertyHandlerConfiguration(
+			V8Instance::js_get_user_list,
+			(IndexedPropertySetterCallback) 0,
+			(IndexedPropertyQueryCallback) 0,
+			(IndexedPropertyDeleterCallback) 0,
+			(IndexedPropertyEnumeratorCallback) 0,
+			External::New(isolate, (void *) this)
+		)
+	);
+
+	return handle_scope.Escape(templ);
+}
+
+Local<Object> V8Instance::wrap_user_list(std::vector<DiscordObjects::GuildMember *> *user_list) {
+	EscapableHandleScope handle_scope(isolate);
+
+	if (user_list_template.IsEmpty()) {
+		Local<ObjectTemplate> raw_template = make_user_list_template();
+		user_list_template.Reset(isolate, raw_template);
+	}
+
+	Local<ObjectTemplate> templ = Local<ObjectTemplate>::New(isolate, user_list_template);
+	Local<Object> result = templ->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
+
+	// imitate an array
+	result->Set(String::NewFromUtf8(isolate, "length", NewStringType::kNormal).ToLocalChecked(), Integer::New(isolate, (*user_list).size()));
+	result->SetPrototype(Array::New(isolate)->GetPrototype());
+
+	Local<External> user_list_ptr = External::New(isolate, user_list);
+	result->SetInternalField(0, user_list_ptr);
+
+	return handle_scope.Escape(result);
+}
+
+void V8Instance::js_get_user_list(uint32_t index, const PropertyCallbackInfo<Value> &info) {
+	void *self_v = info.Data().As<External>()->Value();
+	if (!self_v) {
+		Logger::write("[v8] [js_get_user_list] Class pointer empty", Logger::LogLevel::Warning);
+		return;
+	}
+	V8Instance *self = static_cast<V8Instance *>(self_v);
+
+	void *user_list_v = info.Holder()->GetInternalField(0).As<External>()->Value();
+	if (!user_list_v) {
+		Logger::write("[v8] [js_get_user_list] GuildMember List pointer empty", Logger::LogLevel::Warning);
+		return;
+	}
+	std::vector<DiscordObjects::GuildMember *> *user_list = static_cast<std::vector<DiscordObjects::GuildMember *> *>(user_list_v);
+
+	if (index < (*user_list).size()) {
+		Local<Object> role_obj = self->wrap_user((*user_list)[index]);
+		info.GetReturnValue().Set(role_obj);
+	}
+	else {
+		info.GetReturnValue().SetUndefined();
+	}
+}
+
+
+/* role */
+Local<ObjectTemplate> V8Instance::make_role_template() {
+	EscapableHandleScope handle_scope(isolate);
+
+	Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+	templ->SetInternalFieldCount(1);
+	templ->SetHandler(
+		NamedPropertyHandlerConfiguration(
+			V8Instance::js_get_role,
+			(GenericNamedPropertySetterCallback)0,
+			(GenericNamedPropertyQueryCallback)0,
+			(GenericNamedPropertyDeleterCallback)0,
+			(GenericNamedPropertyEnumeratorCallback)0,
+			External::New(isolate, (void *) this)
+		)
+	);
+
+	return handle_scope.Escape(templ);
+}
+
+Local<Object> V8Instance::wrap_role(DiscordObjects::Role *role) {
+	EscapableHandleScope handle_scope(isolate);
+
+	if (role_template.IsEmpty()) {
+		Local<ObjectTemplate> raw_template = make_role_template();
+		role_template.Reset(isolate, raw_template);
+	}
+
+	Local<ObjectTemplate> templ = Local<ObjectTemplate>::New(isolate, role_template);
+	Local<Object> result = templ->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
+
+	Local<External> role_ptr = External::New(isolate, role);
+	result->SetInternalField(0, role_ptr);
+
+	return handle_scope.Escape(result);
+}
+
+void V8Instance::js_get_role(Local<Name> property, const PropertyCallbackInfo<Value> &info) {
+	void *self_v = info.Data().As<External>()->Value();
+	if (!self_v) {
+		Logger::write("[v8] [js_get_role] Class pointer empty", Logger::LogLevel::Warning);
+		return;
+	}
+	V8Instance *self = static_cast<V8Instance *>(self_v);
+
+	void *role_v = info.Holder()->GetInternalField(0).As<External>()->Value();
+	if (!role_v) {
+		Logger::write("[v8] [js_get_role] Role pointer empty", Logger::LogLevel::Warning);
+		return;
+	}
+	DiscordObjects::Role *role = static_cast<DiscordObjects::Role *>(role_v);
+
+	if (!property->IsString()) {
+		return;
+	}
+	std::string property_s = *String::Utf8Value(property);
+
+	if (property_s == "Id") {
+		info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), role->id.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else if (property_s == "Name") {
+		info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), role->name.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else if (property_s == "Position") {
+		info.GetReturnValue().Set(Integer::New(info.GetIsolate(), role->position));
+	}
+	else if (property_s == "Red" || property_s == "Green" || property_s == "Blue") {
+		info.GetIsolate()->ThrowException(String::NewFromUtf8(info.GetIsolate(), "Role.[Colour] not implemented.", NewStringType::kNormal).ToLocalChecked());
+	}
+}
+
+/* role list */
+Local<ObjectTemplate> V8Instance::make_role_list_template() {
+	EscapableHandleScope handle_scope(isolate);
+
+	Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+	templ->SetInternalFieldCount(1);
+	templ->SetHandler(
+		IndexedPropertyHandlerConfiguration(
+			V8Instance::js_get_role_list,
+			(IndexedPropertySetterCallback) 0,
+			(IndexedPropertyQueryCallback) 0,
+			(IndexedPropertyDeleterCallback) 0,
+			(IndexedPropertyEnumeratorCallback) 0,
+			External::New(isolate, (void *) this)
+		)
+	);
+
+	return handle_scope.Escape(templ);
+}
+
+Local<Object> V8Instance::wrap_role_list(std::vector<DiscordObjects::Role *> *role_list) {
+	EscapableHandleScope handle_scope(isolate);
+
+	if (role_list_template.IsEmpty()) {
+		Local<ObjectTemplate> raw_template = make_role_list_template();
+		role_list_template.Reset(isolate, raw_template);
+	}
+
+	Local<ObjectTemplate> templ = Local<ObjectTemplate>::New(isolate, role_list_template);
+	Local<Object> result = templ->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
+
+	// imitate an array
+	result->Set(String::NewFromUtf8(isolate, "length", NewStringType::kNormal).ToLocalChecked(), Integer::New(isolate, (*role_list).size()));
+	result->SetPrototype(Array::New(isolate)->GetPrototype());
+
+	Local<External> role_list_ptr = External::New(isolate, role_list);
+	result->SetInternalField(0, role_list_ptr);
+
+	return handle_scope.Escape(result);
+}
+
+void V8Instance::js_get_role_list(uint32_t index, const PropertyCallbackInfo<Value> &info) {
+	void *self_v = info.Data().As<External>()->Value();
+	if (!self_v) {
+		Logger::write("[v8] [js_get_role_list] Class pointer empty", Logger::LogLevel::Warning);
+		return;
+	}
+	V8Instance *self = static_cast<V8Instance *>(self_v);
+
+	void *role_list_v = info.Holder()->GetInternalField(0).As<External>()->Value();
+	if (!role_list_v) {
+		Logger::write("[v8] [js_get_role_list] Role List pointer empty", Logger::LogLevel::Warning);
+		return;
+	}
+	std::vector<DiscordObjects::Role *> *role_list = static_cast<std::vector<DiscordObjects::Role *> *>(role_list_v);
+
+
+	if (index < (*role_list).size()) {
+		Local<Object> role_obj = self->wrap_role((*role_list)[index]);
+		info.GetReturnValue().Set(role_obj);
+	}
+	else {
+		info.GetReturnValue().SetUndefined();
+	}
+}
+
+
+/* global functions */
+void V8Instance::js_print(const v8::FunctionCallbackInfo<v8::Value> &args) {
+	auto data = args.Data().As<External>();
 	V8Instance *self = static_cast<V8Instance *>(data->Value());
 
-	info.GetReturnValue().Set(String::NewFromUtf8(info.GetIsolate(), self->current_input.c_str(), NewStringType::kNormal).ToLocalChecked());
+	std::string output = "";
+	for (int i = 0; i < args.Length(); i++) {
+		v8::String::Utf8Value str(args[i]);
+		self->print_text += *str;
+	}
+	self->print_text += "\n";
 }
 
+void V8Instance::js_random(const v8::FunctionCallbackInfo<v8::Value> &args) {
+	auto data = args.Data().As<External>();
+	V8Instance *self = static_cast<V8Instance *>(data->Value());
+
+	int number_args = args.Length();
+
+	if (number_args == 0) {
+		std::uniform_real_distribution<double> dist(0, 1);
+		double random_val = dist(self->rng);
+		args.GetReturnValue().Set(Number::New(args.GetIsolate(), random_val));
+	}
+	else if (number_args == 1) {
+		int64_t max = args[0]->IntegerValue();
+		std::uniform_int_distribution<int> dist(0, max);
+		int random_val = dist(self->rng);
+		args.GetReturnValue().Set(Integer::New(args.GetIsolate(), random_val));
+	}
+	else if (number_args == 2) {
+		int64_t min = args[0]->IntegerValue();
+		int64_t max = args[1]->IntegerValue();
+		std::uniform_int_distribution<int> dist(min, max);
+		int random_val = dist(self->rng);
+		args.GetReturnValue().Set(Integer::New(args.GetIsolate(), random_val));
+	}
+	else {
+		std::string err_msg = "random() requires 0-2 arguments. You gave: " + std::to_string(number_args);
+		args.GetIsolate()->ThrowException(String::NewFromUtf8(args.GetIsolate(), err_msg.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+}
+
+void V8Instance::js_shuffle(const v8::FunctionCallbackInfo<v8::Value> &args) {
+	auto data = args.Data().As<External>();
+	V8Instance *self = static_cast<V8Instance *>(data->Value());
+
+	if (!args[0]->IsArray()) {
+		std::string err_msg = "shuffle() requires an array as it's argument. You gave: " + std::string(*String::Utf8Value(args[0]->TypeOf(args.GetIsolate())));
+		args.GetIsolate()->ThrowException(String::NewFromUtf8(args.GetIsolate(), err_msg.c_str(), NewStringType::kNormal).ToLocalChecked());
+	}
+	else {
+		Local<Array> given_arr = Local<Array>::Cast(args[0]);
+		const int length = given_arr->Length();
+		Local<Array> return_arr = Array::New(args.GetIsolate(), length);
+
+		std::vector<Local<Value>> cpp_arr;
+		for (uint32_t i = 0; i < given_arr->Length(); i++) {
+			cpp_arr.push_back(given_arr->Get(i));
+		}
+
+		std::shuffle(cpp_arr.begin(), cpp_arr.end(), self->rng);
+
+		for (uint32_t i = 0; i < given_arr->Length(); i++) {
+			return_arr->Set(i, cpp_arr[i]);
+		}
+
+		args.GetReturnValue().Set(return_arr);
+	}
+}
+
+
 void V8Instance::clean_up() {
 	Logger::write("[v8] Cleaning up", Logger::LogLevel::Debug);
 	isolate->Exit();
@@ -138,13 +689,29 @@ void V8Instance::reload() {
 
 void V8Instance::exec_js(std::string js, DiscordObjects::Channel *channel, DiscordObjects::GuildMember *sender, std::string args) {
 	HandleScope handle_scope(isolate);
-	Local<Context> context(isolate->GetCurrentContext());
+	Local<Context> context = Local<Context>::New(isolate, context_);
+	Context::Scope context_scope(context);
+
+	context->Global()->Set(
+		String::NewFromUtf8(isolate, "input", NewStringType::kNormal).ToLocalChecked(),
+		String::NewFromUtf8(isolate, args.c_str(), NewStringType::kNormal).ToLocalChecked()
+	);
+	Local<Object> user_obj = wrap_user(sender);
+	context->Global()->Set(
+		String::NewFromUtf8(isolate, "user", NewStringType::kNormal).ToLocalChecked(),
+		user_obj
+	);
+	Local<Object> channel_obj = wrap_user(sender);
+	context->Global()->Set(
+		String::NewFromUtf8(isolate, "user", NewStringType::kNormal).ToLocalChecked(),
+		user_obj
+	);
+	// TODO: 'message' object here too, although it's fairly pointless
 
 	current_sender = sender;
 	current_channel = channel;
-	current_input = args;
 
-	Logger::write("[v8] Preparing JS: " + js, Logger::LogLevel::Debug);
+	Logger::write("[v8] Preparing JS (guild " + (*guilds)[guild_id].id + ", channel " + channel->id + ")", Logger::LogLevel::Debug);
 
 	Local<String> source = String::NewFromUtf8(isolate, js.c_str(), NewStringType::kNormal).ToLocalChecked();
 
@@ -154,12 +721,13 @@ void V8Instance::exec_js(std::string js, DiscordObjects::Channel *channel, Disco
 	TryCatch compile_try_catch(isolate);
 	Local<Script> script;
 
+	auto begin = std::chrono::steady_clock::now();
 	if (!Script::Compile(context, source).ToLocal(&script)) {
 		String::Utf8Value error(compile_try_catch.Exception());
 
 		std::string err_msg = *error;
 		Logger::write("[v8] Compilation error: " + err_msg, Logger::LogLevel::Debug);
-		ah->send_message(channel->id, ":warning: **Compilation error:** `" + err_msg + "`");
+		DiscordAPI::send_message(channel->id, ":warning: **Compilation error:** `" + err_msg + "`");
 
 		return;
 	}
@@ -171,155 +739,18 @@ void V8Instance::exec_js(std::string js, DiscordObjects::Channel *channel, Disco
 
 		std::string err_msg = *error;
 		Logger::write("[v8] Runtime error: " + err_msg, Logger::LogLevel::Debug);
-		ah->send_message(channel->id, ":warning: **Runtime error:** `" + err_msg + "`");
+		DiscordAPI::send_message(channel->id, ":warning: **Runtime error:** `" + err_msg + "`");
 	}
 
-	Logger::write("[v8] Script compiled and run", Logger::LogLevel::Debug);
+	auto end = std::chrono::steady_clock::now();
+	long long time_taken = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count();
+	Logger::write("[v8] Script compiled and run in " + std::to_string(time_taken) + "ms", Logger::LogLevel::Debug);
 
 	current_sender = nullptr;
 	current_channel = nullptr;
-	current_input = "";
 
 	if (print_text != "") {
-		ah->send_message(channel->id, print_text);
+		DiscordAPI::send_message(channel->id, print_text);
 		print_text = "";
 	}
-}
-
-void V8Instance::js_print(const v8::FunctionCallbackInfo<v8::Value> &args) {
-	auto data = args.Data().As<External>();
-	V8Instance *self = static_cast<V8Instance *>(data->Value());
-
-	std::string output = "";
-	for (int i = 0; i < args.Length(); i++) {
-		v8::HandleScope handle_scope(args.GetIsolate());
-		v8::String::Utf8Value str(args[i]);
-		self->print_text += *str;
-	}
-}
-
-void V8Instance::add_to_obj(Local<Object> &object, std::string field_name, std::string value) {
-	add_to_obj(object, field_name, value.c_str());
-}
-
-void V8Instance::add_to_obj(Local<Object> &object, std::string field_name, const char value[]) {
-	if (value == "null") {
-		object->Set(String::NewFromUtf8(isolate, field_name.c_str(), NewStringType::kNormal).ToLocalChecked(), Null(isolate));
-		return;
-	}
-
-	object->Set(String::NewFromUtf8(isolate, field_name.c_str(), NewStringType::kNormal).ToLocalChecked(),
-		String::NewFromUtf8(isolate, value, NewStringType::kNormal).ToLocalChecked());
-}
-
-void V8Instance::add_to_obj(Local<Object> &object, std::string field_name, int32_t value) {
-	object->Set(String::NewFromUtf8(isolate, field_name.c_str(), NewStringType::kNormal).ToLocalChecked(),
-		Integer::New(isolate, value));
-}
-
-void V8Instance::add_to_obj(Local<Object> &object, std::string field_name, bool value) {
-	object->Set(String::NewFromUtf8(isolate, field_name.c_str(), NewStringType::kNormal).ToLocalChecked(),
-		Boolean::New(isolate, value));
-}
-
-void V8Instance::add_to_obj(Local<Object> &object, std::string field_name, Local<Object> value) {
-	object->Set(String::NewFromUtf8(isolate, field_name.c_str(), NewStringType::kNormal).ToLocalChecked(), value);
-}
-
-void V8Instance::add_to_obj(Local<Object> &object, std::string field_name, Local<Array> value) {
-	object->Set(String::NewFromUtf8(isolate, field_name.c_str(), NewStringType::kNormal).ToLocalChecked(), value);
-}
-
-void V8Instance::add_to_obj(Local<Object> &object, DiscordObjects::Guild guild) {
-	/* Boobot fields */
-	add_to_obj(object, "Id", guild.id);
-	add_to_obj(object, "Name", guild.name);
-	add_to_obj(object, "IconUrl", "https://discordapp.com/api/guilds/" + guild.id + "/icons/" + guild.icon + ".jpg");
-
-	Local<Object> owner_obj = Object::New(isolate);
-	DiscordObjects::GuildMember &owner = guild.members[guild.owner_id];
-	add_to_obj(owner_obj, owner);
-	add_to_obj(object, "Owner", owner_obj);
-
-	Local<Array> roles_arr = Array::New(isolate, guild.roles.size());
-	for (uint32_t i = 0; i < guild.roles.size(); i++) {
-		Local<Object> obj = Object::New(isolate);
-		DiscordObjects::Role &role = *guild.roles[i];
-		add_to_obj(obj, role);
-
-		roles_arr->Set(i, obj);
-	}
-	add_to_obj(object, "Roles", roles_arr);
-
-	Local<Array> members_arr = Array::New(isolate, guild.members.size());
-	int i = 0;
-	for (auto it : guild.members) {
-		Local<Object> obj = Object::New(isolate);
-		DiscordObjects::GuildMember &member = it.second;
-		add_to_obj(obj, member);
-
-		members_arr->Set(i, obj);
-		i++;
-	}
-	add_to_obj(object, "Users", members_arr);
-}
-
-void V8Instance::add_to_obj(Local<Object> &object, DiscordObjects::Channel channel) {
-	/* Boobot fields */
-	add_to_obj(object, "Id", channel.id);
-	add_to_obj(object, "Name", channel.name);
-	add_to_obj(object, "Topic", channel.topic);
-	add_to_obj(object, "IsVoice", channel.type == "voice");
-	
-	Local<Array> users = Array::New(isolate, 1);
-	users->Set(0, String::NewFromUtf8(isolate, "NOT IMPLEMENTED", NewStringType::kNormal).ToLocalChecked());
-	add_to_obj(object, "Users", users);
-
-	/* Additional fields */
-	add_to_obj(object, "LastMessageId", channel.last_message_id);
-	add_to_obj(object, "Bitrate", channel.bitrate);
-	add_to_obj(object, "UserLimit", channel.user_limit);
-}
-
-void V8Instance::add_to_obj(Local<Object> &object, DiscordObjects::Role role) {
-	/* Boobot fields */
-	add_to_obj(object, "Id", role.id);
-	add_to_obj(object, "Name", role.name);
-	add_to_obj(object, "Position", role.position);
-	add_to_obj(object, "Red", "NOT IMPLEMENTED");
-	add_to_obj(object, "Blue", "NOT IMPLEMENTED");
-	add_to_obj(object, "Green", "NOT IMPLEMENTED");
-
-	/* Additional fields */
-	add_to_obj(object, "Mentionable", role.mentionable);
-	add_to_obj(object, "Mention", "<@&" + role.id + ">");
-	add_to_obj(object, "Hoist", role.hoist);
-}
-
-void V8Instance::add_to_obj(Local<Object> &object, DiscordObjects::GuildMember member) {
-	/* Boobot fields */
-	add_to_obj(object, "Id", member.user->id);
-	add_to_obj(object, "Name", member.user->username);
-	add_to_obj(object, "Mention", "<@!" + member.user->id + ">");
-	add_to_obj(object, "AvatarUrl", "https://discordapp.com/api/users/" + member.user->id + "/avatars/" + member.user->avatar + ".jpg");
-
-	Local<Array> roles = Array::New(isolate, member.roles.size());
-	int i = 0;
-	for (DiscordObjects::Role *role : member.roles) {
-		Local<Object> role_obj = Object::New(isolate);
-		add_to_obj(role_obj, *role);
-
-		roles->Set(i, role_obj);
-		i++;
-	}
-	add_to_obj(object, "Roles", roles);
-
-	add_to_obj(object, "State", "NOT IMPLEMENTED");
-	add_to_obj(object, "CurrentGame", "NOT IMPLEMENTED");
-
-	/* Additional fields */
-	add_to_obj(object, "Nick", member.nick);
-	add_to_obj(object, "Deaf", member.deaf);
-	add_to_obj(object, "Mute", member.mute);
-	add_to_obj(object, "JoinedAt", member.joined_at);
 }
\ No newline at end of file
diff --git a/TriviaBot/bot/js/V8Instance.hpp b/TriviaBot/bot/js/V8Instance.hpp
index eb7fb3f..0bc6ec2 100644
--- a/TriviaBot/bot/js/V8Instance.hpp
+++ b/TriviaBot/bot/js/V8Instance.hpp
@@ -3,6 +3,7 @@
 
 #include <memory>
 #include <map>
+#include <random>
 
 #include <include/v8.h>
 #include <include/libplatform/libplatform.h>
@@ -19,7 +20,7 @@ using namespace v8;
 
 class V8Instance {
 public:
-	V8Instance(std::string guild_id, std::shared_ptr<APIHelper> ah, std::map<std::string, DiscordObjects::Guild> *guilds,
+	V8Instance(std::string guild_id, std::map<std::string, DiscordObjects::Guild> *guilds,
 		std::map<std::string, DiscordObjects::Channel> *channels, std::map<std::string, DiscordObjects::User> *users, std::map<std::string, DiscordObjects::Role> *roles);
 	~V8Instance();
 	void reload();
@@ -30,23 +31,54 @@ private:
 	void create();
 	Local<Context> create_context();
 
-	void add_to_obj(Local<Object> &object, std::string field_name, std::string value);
-	void add_to_obj(Local<Object> &object, std::string field_name, const char value[]);
-	void add_to_obj(Local<Object> &object, std::string field_name, int32_t value);
-	void add_to_obj(Local<Object> &object, std::string field_name, bool value);
-	void add_to_obj(Local<Object> &object, std::string field_name, Local<Object> value);
-	void add_to_obj(Local<Object> &object, std::string field_name, Local<Array> value);
+	void initialise(Local<Context> context);
 
-	void add_to_obj(Local<Object> &object, DiscordObjects::Guild guild);
-	void add_to_obj(Local<Object> &object, DiscordObjects::Channel channel);
-	void add_to_obj(Local<Object> &object, DiscordObjects::Role role);
-	void add_to_obj(Local<Object> &object, DiscordObjects::GuildMember member);
+	/* server */
+	Global<ObjectTemplate> server_template;
+	Local<ObjectTemplate> make_server_template();
+	Local<Object> wrap_server(DiscordObjects::Guild *guild);
+	static void js_get_server(Local<Name> property, const PropertyCallbackInfo<Value> &info);
 
+
+	/* user */
+	Global<ObjectTemplate> user_template;
+	Local<ObjectTemplate> make_user_template();
+	Local<Object> wrap_user(DiscordObjects::GuildMember *member);
+	static void js_get_user(Local<Name> property, const PropertyCallbackInfo<Value> &info);
+
+	Global<ObjectTemplate> user_list_template;
+	Local<ObjectTemplate> make_user_list_template();
+	Local<Object> wrap_user_list(std::vector<DiscordObjects::GuildMember *> *user_list);
+	static void js_get_user_list(uint32_t index, const PropertyCallbackInfo<Value> &info);
+
+	/* channel */
+	Global<ObjectTemplate> channel_template;
+	Local<ObjectTemplate> make_channel_template();
+	Local<Object> wrap_channel(DiscordObjects::Channel *channel);
+	static void js_get_channel(Local<Name> property, const PropertyCallbackInfo<Value> &info);
+
+	Global<ObjectTemplate> channel_list_template;
+	Local<ObjectTemplate> make_channel_list_template();
+	Local<Object> wrap_channel_list(std::vector<DiscordObjects::Channel *> *channel_list);
+	static void js_get_channel_list(uint32_t index, const PropertyCallbackInfo<Value> &info);
+
+	/* role */
+	Global<ObjectTemplate> role_template;
+	Local<ObjectTemplate> make_role_template();
+	Local<Object> wrap_role(DiscordObjects::Role *role);
+	static void js_get_role(Local<Name> property, const PropertyCallbackInfo<Value> &info);
+
+	Global<ObjectTemplate> role_list_template;
+	Local<ObjectTemplate> make_role_list_template();
+	Local<Object> wrap_role_list(std::vector<DiscordObjects::Role *> *role_list);
+	static void js_get_role_list(uint32_t index, const PropertyCallbackInfo<Value> &info);
+
+	/* print function */
 	static void js_print(const FunctionCallbackInfo<Value> &args);
-	static void js_get_server(Local<String> property, const PropertyCallbackInfo<Value> &info);
-	static void js_get_channel(Local<String> property, const PropertyCallbackInfo<Value> &info);
-	static void js_get_user(Local<String> property, const PropertyCallbackInfo<Value> &info);
-	static void js_get_input(Local<String> property, const PropertyCallbackInfo<Value> &info);
+	
+	/* randomness functions */
+	static void js_random(const FunctionCallbackInfo<Value> &args);
+	static void js_shuffle(const FunctionCallbackInfo<Value> &args);
 
 	std::map<std::string, DiscordObjects::Guild> *guilds;
 	std::map<std::string, DiscordObjects::Channel> *channels;
@@ -55,11 +87,14 @@ private:
 
 	std::string guild_id;
 	Isolate *isolate;
-	std::shared_ptr<APIHelper> ah;
+
+	Global<Context> context_;
+
+	/* random generating variables */
+	std::mt19937 rng;
 
 	/* variables which change when a new command is executed */
 	std::string print_text;
-	std::string current_input;
 	DiscordObjects::Channel *current_channel;
 	DiscordObjects::GuildMember *current_sender;
 };

From ec19b784b37b233c3fed4463600537df8a3027ef Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Thu, 11 Aug 2016 20:21:46 +0100
Subject: [PATCH 10/15] Fix some warnings

---
 TriviaBot/bot/GatewayHandler.cpp     | 3 +--
 TriviaBot/bot/Logger.cpp             | 2 ++
 TriviaBot/bot/TriviaGame.cpp         | 6 +++---
 TriviaBot/bot/js/V8Instance.cpp      | 7 -------
 TriviaBot/data_management/LoadDB.cpp | 9 ---------
 5 files changed, 6 insertions(+), 21 deletions(-)

diff --git a/TriviaBot/bot/GatewayHandler.cpp b/TriviaBot/bot/GatewayHandler.cpp
index d14792e..a31b6ad 100644
--- a/TriviaBot/bot/GatewayHandler.cpp
+++ b/TriviaBot/bot/GatewayHandler.cpp
@@ -100,7 +100,7 @@ void GatewayHandler::on_hello(json decoded, client &c, websocketpp::connection_h
 	send_identify(c, hdl);
 }
 
-void GatewayHandler::on_dispatch(json decoded, client &c, websocketpp::connection_hdl &hdl) {
+void GatewayHandler::on_dispatch(json decoded, client &, websocketpp::connection_hdl &) {
 	last_seq = decoded["s"];
 	std::string event_name = decoded["t"];
 	json data = decoded["d"];
@@ -382,7 +382,6 @@ void GatewayHandler::on_event_guild_role_delete(json data) {
 	auto it = roles.find(role_id);
 
 	if (it != roles.end()) {
-		DiscordObjects::Role &role = roles[role_id];
 		DiscordObjects::Guild &guild = guilds[data["guild_id"]];
 
 		auto check_lambda = [role_id](const DiscordObjects::Role *r) {
diff --git a/TriviaBot/bot/Logger.cpp b/TriviaBot/bot/Logger.cpp
index e42b5ad..6d2a626 100644
--- a/TriviaBot/bot/Logger.cpp
+++ b/TriviaBot/bot/Logger.cpp
@@ -28,6 +28,8 @@ namespace Logger {
 		case LogLevel::Warning:
 			return std::cerr;
 		}
+
+		return std::cerr;
 	}
 
 	void write(std::string text, LogLevel log_level) {
diff --git a/TriviaBot/bot/TriviaGame.cpp b/TriviaBot/bot/TriviaGame.cpp
index 7d62884..a9914ca 100644
--- a/TriviaBot/bot/TriviaGame.cpp
+++ b/TriviaBot/bot/TriviaGame.cpp
@@ -105,7 +105,7 @@ TriviaGame::~TriviaGame() {
 
 	std::string update_sql;
 	if (data.size() < scores.size()) { // some users dont have entries yet
-		std::string sql = "INSERT INTO TotalScores (User, TotalScore, AverageTime) VALUES ";
+		sql = "INSERT INTO TotalScores (User, TotalScore, AverageTime) VALUES ";
 		for (auto &i : scores) {
 			if (data.find(i.first) == data.end()) {
 				sql += "(?, ?, ?),";
@@ -252,8 +252,8 @@ void TriviaGame::give_hint(int hints_given, std::string hint) {
 
 				// count number of *s
 				int length = 0;
-				for (unsigned int i = 0; i < word.length(); i++) {
-					if (word[i] == hide_char) {
+				for (unsigned int j = 0; j < word.length(); j++) {
+					if (word[j] == hide_char) {
 						length++;
 					}
 				}
diff --git a/TriviaBot/bot/js/V8Instance.cpp b/TriviaBot/bot/js/V8Instance.cpp
index 6a6f9b1..d372c6b 100644
--- a/TriviaBot/bot/js/V8Instance.cpp
+++ b/TriviaBot/bot/js/V8Instance.cpp
@@ -504,13 +504,6 @@ Local<Object> V8Instance::wrap_role(DiscordObjects::Role *role) {
 }
 
 void V8Instance::js_get_role(Local<Name> property, const PropertyCallbackInfo<Value> &info) {
-	void *self_v = info.Data().As<External>()->Value();
-	if (!self_v) {
-		Logger::write("[v8] [js_get_role] Class pointer empty", Logger::LogLevel::Warning);
-		return;
-	}
-	V8Instance *self = static_cast<V8Instance *>(self_v);
-
 	void *role_v = info.Holder()->GetInternalField(0).As<External>()->Value();
 	if (!role_v) {
 		Logger::write("[v8] [js_get_role] Role pointer empty", Logger::LogLevel::Warning);
diff --git a/TriviaBot/data_management/LoadDB.cpp b/TriviaBot/data_management/LoadDB.cpp
index bd4fca6..dcc790f 100644
--- a/TriviaBot/data_management/LoadDB.cpp
+++ b/TriviaBot/data_management/LoadDB.cpp
@@ -16,17 +16,8 @@
 / Hideous code, but only needs to be run one time.
 **/
 
-static int callback(void *x, int argc, char **argv, char **azColName) {
-	int i;
-	for (i = 0; i<argc; i++) {
-		std::cout << azColName[i] << " = " << (argv[i] ? argv[i] : "NULL") << std::endl;
-	}
-	return 0;
-}
-
 int load_questions() {
 	sqlite3 *db;
-	char *zErrMsg = 0;
 	int rc;
 
 	rc = sqlite3_open("bot/db/trivia.db", &db);

From 77394046460813cc828abea786cc88191c0b3ee2 Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Fri, 12 Aug 2016 15:30:47 +0100
Subject: [PATCH 11/15] Compatability for g++ 4.9

---
 TriviaBot/bot/Logger.cpp | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/TriviaBot/bot/Logger.cpp b/TriviaBot/bot/Logger.cpp
index 6d2a626..ea09cd6 100644
--- a/TriviaBot/bot/Logger.cpp
+++ b/TriviaBot/bot/Logger.cpp
@@ -1,7 +1,6 @@
 #include "Logger.hpp"
 
 #include <iostream>
-#include <iomanip>
 #include <ctime>
 
 namespace Logger {
@@ -33,9 +32,16 @@ namespace Logger {
 	}
 
 	void write(std::string text, LogLevel log_level) {
-		auto t = std::time(nullptr);
-		auto tm = *std::localtime(&t);
+		time_t rawtime;
+		struct tm *timeinfo;
+	  char buffer[80];
 
-		get_ostream(log_level) << "[" << std::put_time(&tm, "%Y-%m-%d %H:%M:%S") << "] [" << log_level << "] " << text << std::endl;
+	  time(&rawtime);
+	  timeinfo = localtime(&rawtime);
+
+	  strftime(buffer, 80, "%Y-%m-%d %H:%M:%S", timeinfo);
+	  std::string time_str(buffer);
+
+		get_ostream(log_level) << "[" << time_str << "] [" << log_level << "] " << text << std::endl;
 	}
-}
\ No newline at end of file
+}

From 8ebe6c2c4eb6faf6448a8d3bce58dbe2cc5515a5 Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Fri, 12 Aug 2016 15:42:03 +0100
Subject: [PATCH 12/15] Squash some bugs and fix some warnings. Update
 CMakeLists

---
 TriviaBot/CMakeLists.txt           | 13 +++++-
 TriviaBot/bot/TriviaBot.cpp        |  2 +-
 TriviaBot/bot/TriviaBot.cpp.save   | 64 ++++++++++++++++++++++++++++++
 TriviaBot/bot/js/CommandHelper.hpp |  3 +-
 TriviaBot/bot/js/V8Instance.cpp    | 27 +++++--------
 TriviaBot/bot/js/V8Instance.hpp    |  4 +-
 6 files changed, 90 insertions(+), 23 deletions(-)
 create mode 100644 TriviaBot/bot/TriviaBot.cpp.save

diff --git a/TriviaBot/CMakeLists.txt b/TriviaBot/CMakeLists.txt
index 001e4ac..2d7ba87 100644
--- a/TriviaBot/CMakeLists.txt
+++ b/TriviaBot/CMakeLists.txt
@@ -7,6 +7,8 @@ project(TriviaBot)
 
 file(GLOB_RECURSE sources bot/*.cpp bot/*.hpp ../lib/sqlite3/sqlite3.c)
 
+link_directories(../lib/v8/lib)
+
 ###############################################################################
 ## target definitions #########################################################
 ###############################################################################
@@ -29,8 +31,14 @@ target_link_libraries(TriviaBot PUBLIC
   ${Boost_LIBRARIES}
   ${OPENSSL_LIBRARIES}
   ${CURL_LIBRARIES}
-  pthread
+  v8
+  v8_libplatform
+  v8_libbase
+  icui18n
+  icuuc
+  rt
   dl
+  pthread
 )
 
 include_directories(
@@ -39,7 +47,8 @@ include_directories(
   ${CURL_INCLUDE_DIR}
   ../lib/websocketpp
   ../lib/sqlite3
+  ../lib/v8
 )
 
 # don't know if necessary, too scared to remove
-add_definitions(-D_WEBSOCKETPP_CPP11_STL_)
\ No newline at end of file
+add_definitions(-D_WEBSOCKETPP_CPP11_STL_)
diff --git a/TriviaBot/bot/TriviaBot.cpp b/TriviaBot/bot/TriviaBot.cpp
index f2d970c..150738c 100644
--- a/TriviaBot/bot/TriviaBot.cpp
+++ b/TriviaBot/bot/TriviaBot.cpp
@@ -61,4 +61,4 @@ int main(int argc, char *argv[]) {
 	std::getchar();
 
 	return 0;
-}
\ No newline at end of file
+}
diff --git a/TriviaBot/bot/TriviaBot.cpp.save b/TriviaBot/bot/TriviaBot.cpp.save
new file mode 100644
index 0000000..5ebbefd
--- /dev/null
+++ b/TriviaBot/bot/TriviaBot.cpp.save
@@ -0,0 +1,64 @@
+#include <curl/curl.h>
+#include <include/libplatform/libplatform.>
+#include <include/v8.h>
+
+#include "ClientConnection.hpp"
+#include "Logger.hpp"
+#include "DiscordAPI.hpp"
+
+std::string bot_token;
+
+int main(int argc, char *argv[]) {
+	curl_global_init(CURL_GLOBAL_DEFAULT);
+
+	v8::V8::InitializeICUDefaultLocation(argv[0]);
+	v8::V8::InitializeExternalStartupData(argv[0]);
+	v8::Platform* platform = v8::platform::CreateDefaultPlatform();
+	v8::V8::InitializePlatform(platform);
+	v8::V8::Initialize();
+
+	Logger::write("Initialised V8 and curl", Logger::LogLevel::Debug);
+
+	if (argc == 2) {
+		bot_token = argv[1];
+	}
+	else {
+		std::cout << "Please enter your bot token: " << std::endl;
+		std::cin >> bot_token;
+	}
+
+	std::string args = "/?v=5&encoding=json";
+	std::string url = DiscordAPI::get_gateway().value("url", "wss://gateway.discord.gg");
+
+	bool retry = true;
+	while (retry) {
+		try {
+			ClientConnection conn;
+			conn.start(url + args);
+		}
+		catch (const std::exception &e) {
+			Logger::write("std exception: " + std::string(e.what()), Logger::LogLevel::Severe);
+			retry = false;
+		}
+		catch (websocketpp::lib::error_code e) {
+			Logger::write("websocketpp exception: " + e.message(), Logger::LogLevel::Severe);
+		}
+		catch (...) {
+			Logger::write("other exception.", Logger::LogLevel::Severe);
+			retry = false;
+		}
+	}
+
+	v8::V8::Dispose();
+	v8::V8::ShutdownPlatform();
+	delete platform;
+
+	curl_global_cleanup();
+
+	Logger::write("Cleaned up", Logger::LogLevel::Info);
+
+	std::cout << "Press enter to exit" << std::endl;
+	std::getchar();
+
+	return 0;
+}
diff --git a/TriviaBot/bot/js/CommandHelper.hpp b/TriviaBot/bot/js/CommandHelper.hpp
index a34d6c8..e10aed8 100644
--- a/TriviaBot/bot/js/CommandHelper.hpp
+++ b/TriviaBot/bot/js/CommandHelper.hpp
@@ -1,6 +1,7 @@
 #ifndef BOT_JS_COMMANDHELPER
 #define BOT_JS_COMMANDHELPER
 
+#include <string>
 #include <vector>
 
 namespace CommandHelper {
@@ -16,4 +17,4 @@ namespace CommandHelper {
 	bool command_in_db(std::string guild_id, std::string command_name);
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/TriviaBot/bot/js/V8Instance.cpp b/TriviaBot/bot/js/V8Instance.cpp
index d372c6b..0d52a38 100644
--- a/TriviaBot/bot/js/V8Instance.cpp
+++ b/TriviaBot/bot/js/V8Instance.cpp
@@ -48,12 +48,12 @@ void V8Instance::create() {
 void V8Instance::initialise(Local<Context> context) {
 	HandleScope handle_scope(isolate);
 
-	Local<Object> opts_obj = wrap_server(&(*guilds)[guild_id]);
-	
+	Local<Object> server_obj = wrap_server(&(*guilds)[guild_id]);
+
 	context->Global()->Set(
-		context, 
-		String::NewFromUtf8(isolate, "server", NewStringType::kNormal).ToLocalChecked(), 
-		opts_obj
+		context,
+		String::NewFromUtf8(isolate, "server", NewStringType::kNormal).ToLocalChecked(),
+		server_obj
 	).FromJust();
 
 	Logger::write("[v8] Bound server template", Logger::LogLevel::Debug);
@@ -64,7 +64,7 @@ v8::Local<v8::Context> V8Instance::create_context() {
 
 	Local<External> self = External::New(isolate, (void *) this);
 	global->Set(
-		String::NewFromUtf8(isolate, "print", NewStringType::kNormal).ToLocalChecked(), 
+		String::NewFromUtf8(isolate, "print", NewStringType::kNormal).ToLocalChecked(),
 		FunctionTemplate::New(isolate, V8Instance::js_print, self)
 	);
 	global->Set(
@@ -209,13 +209,6 @@ Local<Object> V8Instance::wrap_channel(DiscordObjects::Channel *channel) {
 }
 
 void V8Instance::js_get_channel(Local<Name> property, const PropertyCallbackInfo<Value> &info) {
-	void *self_v = info.Data().As<External>()->Value();
-	if (!self_v) {
-		Logger::write("[v8] [js_get_channel] Class pointer empty", Logger::LogLevel::Warning);
-		return;
-	}
-	V8Instance *self = static_cast<V8Instance *>(self_v);
-
 	void *channel_v = info.Holder()->GetInternalField(0).As<External>()->Value();
 	if (!channel_v) {
 		Logger::write("[v8] [js_get_channel] Channel pointer empty", Logger::LogLevel::Warning);
@@ -694,10 +687,10 @@ void V8Instance::exec_js(std::string js, DiscordObjects::Channel *channel, Disco
 		String::NewFromUtf8(isolate, "user", NewStringType::kNormal).ToLocalChecked(),
 		user_obj
 	);
-	Local<Object> channel_obj = wrap_user(sender);
+	Local<Object> channel_obj = wrap_channel(channel);
 	context->Global()->Set(
-		String::NewFromUtf8(isolate, "user", NewStringType::kNormal).ToLocalChecked(),
-		user_obj
+		String::NewFromUtf8(isolate, "channel", NewStringType::kNormal).ToLocalChecked(),
+		channel_obj
 	);
 	// TODO: 'message' object here too, although it's fairly pointless
 
@@ -746,4 +739,4 @@ void V8Instance::exec_js(std::string js, DiscordObjects::Channel *channel, Disco
 		DiscordAPI::send_message(channel->id, print_text);
 		print_text = "";
 	}
-}
\ No newline at end of file
+}
diff --git a/TriviaBot/bot/js/V8Instance.hpp b/TriviaBot/bot/js/V8Instance.hpp
index 0bc6ec2..c0966dc 100644
--- a/TriviaBot/bot/js/V8Instance.hpp
+++ b/TriviaBot/bot/js/V8Instance.hpp
@@ -75,7 +75,7 @@ private:
 
 	/* print function */
 	static void js_print(const FunctionCallbackInfo<Value> &args);
-	
+
 	/* randomness functions */
 	static void js_random(const FunctionCallbackInfo<Value> &args);
 	static void js_shuffle(const FunctionCallbackInfo<Value> &args);
@@ -99,4 +99,4 @@ private:
 	DiscordObjects::GuildMember *current_sender;
 };
 
-#endif
\ No newline at end of file
+#endif

From da93eda0beffe2c4c67e9e262002407aa99ac38f Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Sun, 14 Aug 2016 17:46:29 +0100
Subject: [PATCH 13/15] Fix shutting down, other minor cleanups

---
 TriviaBot/bot/ClientConnection.cpp |   3 +
 TriviaBot/bot/GatewayHandler.cpp   | 134 +++++++++++++++++------------
 TriviaBot/bot/GatewayHandler.hpp   |   2 +-
 TriviaBot/bot/Logger.cpp           |  10 +--
 TriviaBot/bot/TriviaBot.cpp        |  17 ++--
 TriviaBot/bot/js/V8Instance.cpp    |  17 ----
 TriviaBot/bot/js/V8Instance.hpp    |   3 -
 7 files changed, 98 insertions(+), 88 deletions(-)

diff --git a/TriviaBot/bot/ClientConnection.cpp b/TriviaBot/bot/ClientConnection.cpp
index 0037dc7..94f35bb 100644
--- a/TriviaBot/bot/ClientConnection.cpp
+++ b/TriviaBot/bot/ClientConnection.cpp
@@ -66,6 +66,8 @@ void ClientConnection::start(std::string uri) {
 	// Open the connection
 	c.connect(con);
 	c.run();
+
+	Logger::write("Finished running", Logger::LogLevel::Debug);
 }
 
 // Event handlers
@@ -120,4 +122,5 @@ void ClientConnection::on_message(websocketpp::connection_hdl hdl, message_ptr m
 
 void ClientConnection::on_close(websocketpp::connection_hdl) {
 	Logger::write("Connection closed", Logger::LogLevel::Info);
+	c.stop();
 }
\ No newline at end of file
diff --git a/TriviaBot/bot/GatewayHandler.cpp b/TriviaBot/bot/GatewayHandler.cpp
index a31b6ad..26c79d1 100644
--- a/TriviaBot/bot/GatewayHandler.cpp
+++ b/TriviaBot/bot/GatewayHandler.cpp
@@ -100,7 +100,7 @@ void GatewayHandler::on_hello(json decoded, client &c, websocketpp::connection_h
 	send_identify(c, hdl);
 }
 
-void GatewayHandler::on_dispatch(json decoded, client &, websocketpp::connection_hdl &) {
+void GatewayHandler::on_dispatch(json decoded, client &c, websocketpp::connection_hdl &hdl) {
 	last_seq = decoded["s"];
 	std::string event_name = decoded["t"];
 	json data = decoded["d"];
@@ -145,7 +145,7 @@ void GatewayHandler::on_dispatch(json decoded, client &, websocketpp::connection
 		on_event_channel_delete(data);
 	}
 	else if (event_name == "MESSAGE_CREATE") {
-		on_event_message_create(data);
+		on_event_message_create(data, c, hdl);
 	}
 	else if (event_name == "PRESENCE_UPDATE") {
 		on_event_presence_update(data);
@@ -306,7 +306,7 @@ void GatewayHandler::on_event_guild_member_update(json data) {
 	});
 	if (it != guild.members.end()) {
 		bool nick_changed = false;
-		size_t roles_change = 0;
+		int roles_change = 0;
 
 		DiscordObjects::GuildMember *member = (*it);
 
@@ -448,7 +448,7 @@ void GatewayHandler::on_event_channel_delete(json data) {
 	}
 }
 
-void GatewayHandler::on_event_message_create(json data) {
+void GatewayHandler::on_event_message_create(json data, client &c, websocketpp::connection_hdl &hdl) {
 	std::string message = data["content"];
 
 	DiscordObjects::Channel &channel = channels[data["channel_id"]];
@@ -481,8 +481,11 @@ void GatewayHandler::on_event_message_create(json data) {
 			else if (words[1] == "stop" || words[1] == "s") {
 				if (games.find(channel.id) != games.end()) {
 					delete_game(channel.id);
-					return;
 				}
+				else {
+					DiscordAPI::send_message(channel.id, ":warning: Couldn't find an ongoing trivia game for this channel.");
+				}
+				return;
 			}
 			else {
 				try {
@@ -502,14 +505,14 @@ void GatewayHandler::on_event_message_create(json data) {
 		games[channel.id]->start();
 	}
 	else if (words[0] == "`guilds") {
-		std::string m = "Guild List:\n";
+		std::string m = "**Guild List:**\n";
 		for (auto &gu : guilds) {
-			m += "> " + gu.second.name + " (" + gu.second.id + ") Channels: " + std::to_string(gu.second.channels.size()) + "\n";
+			m += ":small_orange_diamond: " + gu.second.name + " (" + gu.second.id + ") Channels: " + std::to_string(gu.second.channels.size()) + "\n";
 		}
 		DiscordAPI::send_message(channel.id, m);
 	}
 	else if (words[0] == "`info") {
-		DiscordAPI::send_message(channel.id, ":information_source: trivia-bot by Jack. <http://github.com/jackb-p/TriviaDiscord>");
+		DiscordAPI::send_message(channel.id, ":information_source: **trivia-bot** by Jack. <http://github.com/jackb-p/TriviaDiscord>");
 	}
 	else if (words[0] == "~js" && words.size() > 1) {
 		DiscordObjects::GuildMember *member = *std::find_if(guild.members.begin(), guild.members.end(), [sender](DiscordObjects::GuildMember *m) {
@@ -522,6 +525,16 @@ void GatewayHandler::on_event_message_create(json data) {
 		}
 	}
 	else if (words[0] == "~createjs" && words.size() > 1) {
+		auto &member = *std::find_if(guild.members.begin(), guild.members.end(), [sender](DiscordObjects::GuildMember *m) { return sender.id == m->user->id; });
+		bool allowed = std::find_if(member->roles.begin(), member->roles.end(), [](DiscordObjects::Role *r) { 
+			return r->name == "Admin" || r->name == "Moderator" || r->name == "Coder"; // TODO: customisation here
+		}) == member->roles.end(); // checks if the user has the required roles
+
+		if (!allowed) {
+			DiscordAPI::send_message(channel.id, ":warning: You do not have permission to use this command.");
+			return;
+		}
+
 		std::string args = message.substr(10);
 		size_t seperator_loc = args.find("|");
 		if (seperator_loc != std::string::npos) {
@@ -540,75 +553,76 @@ void GatewayHandler::on_event_message_create(json data) {
 	}
 	else if (words[0] == "`shutdown" && sender.id == "82232146579689472") { // it me
 		DiscordAPI::send_message(channel.id, ":zzz: Goodbye!");
-		// TODO: without needing c, hdl - c.close(hdl, websocketpp::close::status::going_away, "`shutdown command used.");
+		for (auto &game : games) {
+			delete_game(game.first);
+		}
+		v8_instances.clear();
+		c.close(hdl, websocketpp::close::status::going_away, "");
 	}
 	else if (words[0] == "`debug") {
 		if (words[1] == "channel" && words.size() == 3) {
 			auto it = channels.find(words[2]);
-			if (it != channels.end()) {
-				DiscordAPI::send_message(channel.id, it->second.to_debug_string());
-			}
-			else {
+			if (it == channels.end()) {
 				DiscordAPI::send_message(channel.id, ":question: Unrecognised channel.");
+				return;
 			}
+
+			DiscordAPI::send_message(channel.id, it->second.to_debug_string());
 		}
 		else if (words[1] == "guild" && words.size() == 3) {
 			auto it = guilds.find(words[2]);
-			if (it != guilds.end()) {
-				DiscordAPI::send_message(channel.id, it->second.to_debug_string());
-			}
-			else {
+			if (it == guilds.end()) {
 				DiscordAPI::send_message(channel.id, ":question: Unrecognised guild.");
+				return;
 			}
+
+			DiscordAPI::send_message(channel.id, it->second.to_debug_string());
 		}
 		else if (words[1] == "member" && words.size() == 4) {
 			auto it = guilds.find(words[2]);
-			if (it != guilds.end()) {
-				std::string user_id = words[3];
-
-				auto it2 = std::find_if(it->second.members.begin(), it->second.members.end(), [user_id](DiscordObjects::GuildMember *member) {
-					return user_id == member->user->id;
-				});
-				if (it2 != it->second.members.end()) {
-					DiscordAPI::send_message(channel.id, (*it2)->to_debug_string());
-				}
-				else {
-					DiscordAPI::send_message(channel.id, ":question: Unrecognised user.");
-				}
-			}
-			else {
+			if (it == guilds.end()) {
 				DiscordAPI::send_message(channel.id, ":question: Unrecognised guild.");
+				return;
 			}
+
+			std::string user_id = words[3];
+			auto it2 = std::find_if(it->second.members.begin(), it->second.members.end(), [user_id](DiscordObjects::GuildMember *member) {
+				return user_id == member->user->id;
+			});
+			if (it2 == it->second.members.end()) {
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised user.");
+				return;
+			}
+
+			DiscordAPI::send_message(channel.id, (*it2)->to_debug_string());
 		}
 		else if (words[1] == "role" && words.size() == 3) {
 			auto it = roles.find(words[2]);
-			if (it != roles.end()) {
-				DiscordAPI::send_message(channel.id, it->second.to_debug_string());
-			}
-			else {
+			if (it == roles.end()) {
 				DiscordAPI::send_message(channel.id, ":question: Unrecognised role.");
+				return;
 			}
+
+			DiscordAPI::send_message(channel.id, it->second.to_debug_string());
 		}
 		else if (words[1] == "role" && words.size() == 4) {
 			std::string role_name = words[3];
 
 			auto it = guilds.find(words[2]);
-			if (it != guilds.end()) {
-				auto check_lambda = [role_name](DiscordObjects::Role *r) {
-					return role_name == r->name;
-				};
-
-				auto it2 = std::find_if(it->second.roles.begin(), it->second.roles.end(), check_lambda);
-				if (it2 != it->second.roles.end()) {
-					DiscordAPI::send_message(channel.id, (*it2)->to_debug_string());
-				}
-				else {
-					DiscordAPI::send_message(channel.id, ":question: Unrecognised role.");
-				}
-			}
-			else {
+			if (it == guilds.end()) {
 				DiscordAPI::send_message(channel.id, ":question: Unrecognised guild.");
+				return;
 			}
+
+			auto it2 = std::find_if(it->second.roles.begin(), it->second.roles.end(), [role_name](DiscordObjects::Role *r) {
+				return role_name == r->name;
+			});
+			if (it2 == it->second.roles.end()) {
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised role.");
+				return;
+			}
+			
+			DiscordAPI::send_message(channel.id, (*it2)->to_debug_string());
 		}
 		else {
 			DiscordAPI::send_message(channel.id, ":question: Unknown parameters.");
@@ -620,15 +634,23 @@ void GatewayHandler::on_event_message_create(json data) {
 			args = message.substr(words[0].length() + 1);
 		}
 
-		auto it = v8_instances.find(channel.guild_id);
-		if (it != v8_instances.end() && custom_command.script.length() > 0) {
-			DiscordObjects::GuildMember *member = *std::find_if(guild.members.begin(), guild.members.end(), [sender](DiscordObjects::GuildMember *m) {
-				return sender.id == m->user->id;
-			});
-			it->second->exec_js(custom_command.script, &channel, member, args);
+		if (custom_command.script.length() == 0) {
+			DiscordAPI::send_message(channel.id, ":warning: Script has 0 length.");
+			return;
 		}
+
+		auto it = v8_instances.find(channel.guild_id);
+		if (it == v8_instances.end()) {
+			DiscordAPI::send_message(channel.id, ":warning: No V8 instance exists for this server - it's our fault not yours!");
+			return;
+		}
+
+		DiscordObjects::GuildMember *member = *std::find_if(guild.members.begin(), guild.members.end(), [sender](DiscordObjects::GuildMember *m) {
+			return sender.id == m->user->id;
+		});
+		it->second->exec_js(custom_command.script, &channel, member, args);
 	}
-	else if (games.find(channel.id) != games.end()) { // message received in channel with ongoing game
+	else if (games.find(channel.id) != games.end()) { // message received in channel with ongoing trivia game
 		games[channel.id]->handle_answer(message, sender);
 	}
 }
diff --git a/TriviaBot/bot/GatewayHandler.hpp b/TriviaBot/bot/GatewayHandler.hpp
index f0c8732..4146428 100644
--- a/TriviaBot/bot/GatewayHandler.hpp
+++ b/TriviaBot/bot/GatewayHandler.hpp
@@ -81,7 +81,7 @@ private:
 	void on_event_channel_delete(json data); // https://discordapp.com/developers/docs/topics/gateway#channel-delete
 
 	/* message events */
-	void on_event_message_create(json data); // https://discordapp.com/developers/docs/topics/gateway#message-create
+	void on_event_message_create(json data, client &c, websocketpp::connection_hdl &hdl); // https://discordapp.com/developers/docs/topics/gateway#message-create
 
 	const int protocol_version = 5;
 
diff --git a/TriviaBot/bot/Logger.cpp b/TriviaBot/bot/Logger.cpp
index ea09cd6..525b6bd 100644
--- a/TriviaBot/bot/Logger.cpp
+++ b/TriviaBot/bot/Logger.cpp
@@ -34,13 +34,13 @@ namespace Logger {
 	void write(std::string text, LogLevel log_level) {
 		time_t rawtime;
 		struct tm *timeinfo;
-	  char buffer[80];
+		char buffer[80];
 
-	  time(&rawtime);
-	  timeinfo = localtime(&rawtime);
+		time(&rawtime);
+		timeinfo = localtime(&rawtime);
 
-	  strftime(buffer, 80, "%Y-%m-%d %H:%M:%S", timeinfo);
-	  std::string time_str(buffer);
+		strftime(buffer, 80, "%Y-%m-%d %H:%M:%S", timeinfo);
+		std::string time_str(buffer);
 
 		get_ostream(log_level) << "[" << time_str << "] [" << log_level << "] " << text << std::endl;
 	}
diff --git a/TriviaBot/bot/TriviaBot.cpp b/TriviaBot/bot/TriviaBot.cpp
index 150738c..7090e45 100644
--- a/TriviaBot/bot/TriviaBot.cpp
+++ b/TriviaBot/bot/TriviaBot.cpp
@@ -1,3 +1,6 @@
+#include <thread>
+#include <chrono>
+
 #include <curl/curl.h>
 #include <include/libplatform/libplatform.h>
 #include <include/v8.h>
@@ -31,21 +34,26 @@ int main(int argc, char *argv[]) {
 	std::string url = DiscordAPI::get_gateway().value("url", "wss://gateway.discord.gg");
 
 	bool retry = true;
+	int exit_code = 0;
 	while (retry) {
+		retry = false;
+
 		try {
 			ClientConnection conn;
 			conn.start(url + args);
 		}
 		catch (const std::exception &e) {
 			Logger::write("std exception: " + std::string(e.what()), Logger::LogLevel::Severe);
-			retry = false;
+			exit_code = 1;
 		}
 		catch (websocketpp::lib::error_code e) {
 			Logger::write("websocketpp exception: " + e.message(), Logger::LogLevel::Severe);
+			std::this_thread::sleep_for(std::chrono::seconds(10));
+			retry = true; // should just be an occasional connection issue
 		}
 		catch (...) {
 			Logger::write("other exception.", Logger::LogLevel::Severe);
-			retry = false;
+			exit_code = 2;
 		}
 	}
 
@@ -57,8 +65,5 @@ int main(int argc, char *argv[]) {
 
 	Logger::write("Cleaned up", Logger::LogLevel::Info);
 
-	std::cout << "Press enter to exit" << std::endl;
-	std::getchar();
-
-	return 0;
+	return exit_code;
 }
diff --git a/TriviaBot/bot/js/V8Instance.cpp b/TriviaBot/bot/js/V8Instance.cpp
index 0d52a38..6ca2cf4 100644
--- a/TriviaBot/bot/js/V8Instance.cpp
+++ b/TriviaBot/bot/js/V8Instance.cpp
@@ -20,16 +20,11 @@ V8Instance::V8Instance(std::string guild_id, std::map<std::string, DiscordObject
 	create();
 }
 
-V8Instance::~V8Instance() {
-	clean_up();
-}
-
 void V8Instance::create() {
 	Isolate::CreateParams create_params;
 	create_params.array_buffer_allocator = ArrayBuffer::Allocator::NewDefaultAllocator();
 
 	isolate = Isolate::New(create_params);
-	isolate->Enter();
 	Logger::write("[v8] Created isolate", Logger::LogLevel::Debug);
 
 	Isolate::Scope isolate_scope(isolate);
@@ -661,18 +656,6 @@ void V8Instance::js_shuffle(const v8::FunctionCallbackInfo<v8::Value> &args) {
 	}
 }
 
-
-void V8Instance::clean_up() {
-	Logger::write("[v8] Cleaning up", Logger::LogLevel::Debug);
-	isolate->Exit();
-	isolate->Dispose();
-}
-
-void V8Instance::reload() {
-	clean_up();
-	create();
-}
-
 void V8Instance::exec_js(std::string js, DiscordObjects::Channel *channel, DiscordObjects::GuildMember *sender, std::string args) {
 	HandleScope handle_scope(isolate);
 	Local<Context> context = Local<Context>::New(isolate, context_);
diff --git a/TriviaBot/bot/js/V8Instance.hpp b/TriviaBot/bot/js/V8Instance.hpp
index c0966dc..00e99b8 100644
--- a/TriviaBot/bot/js/V8Instance.hpp
+++ b/TriviaBot/bot/js/V8Instance.hpp
@@ -22,12 +22,9 @@ class V8Instance {
 public:
 	V8Instance(std::string guild_id, std::map<std::string, DiscordObjects::Guild> *guilds,
 		std::map<std::string, DiscordObjects::Channel> *channels, std::map<std::string, DiscordObjects::User> *users, std::map<std::string, DiscordObjects::Role> *roles);
-	~V8Instance();
-	void reload();
 	void exec_js(std::string js, DiscordObjects::Channel *channel, DiscordObjects::GuildMember *sender, std::string args = "");
 
 private:
-	void clean_up();
 	void create();
 	Local<Context> create_context();
 

From 4b2d0ee50ac38460d446556e685fa072ecb8be5b Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Mon, 15 Aug 2016 17:47:34 +0100
Subject: [PATCH 14/15] Add config, neaten up some things

---
 .gitignore                                    |  3 +
 TriviaBot/bot/BotConfig.cpp                   | 60 ++++++++++++++
 TriviaBot/bot/BotConfig.hpp                   | 23 ++++++
 TriviaBot/bot/ClientConnection.cpp            | 38 +++++----
 TriviaBot/bot/ClientConnection.hpp            | 15 ++--
 TriviaBot/bot/DiscordAPI.cpp                  | 18 ++---
 TriviaBot/bot/DiscordAPI.hpp                  |  6 +-
 TriviaBot/bot/GatewayHandler.cpp              | 70 ++++++++--------
 TriviaBot/bot/GatewayHandler.hpp              |  6 +-
 TriviaBot/bot/TriviaBot.cpp                   | 22 +++--
 TriviaBot/bot/TriviaGame.cpp                  | 16 ++--
 TriviaBot/bot/TriviaGame.hpp                  |  6 +-
 .../bot/http/{HTTPHelper.cpp => HTTP.cpp}     | 18 ++---
 TriviaBot/bot/http/HTTP.hpp                   | 15 ++++
 TriviaBot/bot/http/HTTPHelper.hpp             | 13 ---
 TriviaBot/bot/js/V8Instance.cpp               | 14 ++--
 TriviaBot/bot/js/V8Instance.hpp               | 80 +++++++++----------
 17 files changed, 259 insertions(+), 164 deletions(-)
 create mode 100644 TriviaBot/bot/BotConfig.cpp
 create mode 100644 TriviaBot/bot/BotConfig.hpp
 rename TriviaBot/bot/http/{HTTPHelper.cpp => HTTP.cpp} (83%)
 create mode 100644 TriviaBot/bot/http/HTTP.hpp
 delete mode 100644 TriviaBot/bot/http/HTTPHelper.hpp

diff --git a/.gitignore b/.gitignore
index e155f43..5861706 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,5 +10,8 @@
 /TriviaBot/data_management/questions
 /TriviaBot/bot/db/trivia.db
 
+# Config file
+config.json
+
 # Compiled sqlite file
 sqlite3.obj
\ No newline at end of file
diff --git a/TriviaBot/bot/BotConfig.cpp b/TriviaBot/bot/BotConfig.cpp
new file mode 100644
index 0000000..ed55ad5
--- /dev/null
+++ b/TriviaBot/bot/BotConfig.cpp
@@ -0,0 +1,60 @@
+#include "BotConfig.hpp"
+
+#include <sstream>
+#include <fstream>
+#include <ostream>
+
+#include "json/json.hpp"
+
+#include "Logger.hpp"
+
+using json = nlohmann::json;
+
+BotConfig::BotConfig() {
+	is_new_config = false;
+	std::stringstream ss;
+
+	std::ifstream config_file("config.json");
+	if(!config_file) {
+		config_file.close();
+		create_new_file();
+		return;
+	}
+
+	ss << config_file.rdbuf();
+	config_file.close();
+	std::string config = ss.str();
+	load_from_json(config);
+}
+
+void BotConfig::load_from_json(std::string data) {
+	json parsed = json::parse(data);
+
+	token = parsed.value("bot_token", "");
+	owner_id = parsed.value("owner_id", "");
+	cert_location = parsed.value("api_cert_file", "bot/http/DiscordCA.crt");
+
+	createjs_roles = parsed["v8"].value("createjs_allowed_roles", std::unordered_set<std::string> { "Admin", "Coder" });
+
+	Logger::write("config.json file loaded", Logger::LogLevel::Info);
+}
+
+void BotConfig::create_new_file() {
+	std::string config = json {
+		{ "bot_token", "" },
+		{ "owner_id", "" },
+		{ "api_cert_file", "bot/http/DiscordCA.crt" },
+		{ "v8", {
+			{ "createjs_allowed_roles", {
+				"Admin", "Coder", "Bot Commander"
+			} }
+		} }
+	}.dump(4);
+
+	std::ofstream config_file("config.json");
+	config_file << config;
+	config_file.close();
+
+	Logger::write("Created new config.json file", Logger::LogLevel::Info);
+	is_new_config = true;
+}
\ No newline at end of file
diff --git a/TriviaBot/bot/BotConfig.hpp b/TriviaBot/bot/BotConfig.hpp
new file mode 100644
index 0000000..23dc842
--- /dev/null
+++ b/TriviaBot/bot/BotConfig.hpp
@@ -0,0 +1,23 @@
+#ifndef BOT_BOTCONFIG
+#define BOT_BOTCONFIG
+
+#include <string>
+#include <unordered_set>
+
+class BotConfig {
+public:
+	BotConfig();
+
+	bool is_new_config;
+
+	std::string token;
+	std::string owner_id;
+	std::string cert_location;
+	std::unordered_set<std::string> createjs_roles;
+
+private:
+	void load_from_json(std::string data);
+	void create_new_file();
+};
+
+#endif
diff --git a/TriviaBot/bot/ClientConnection.cpp b/TriviaBot/bot/ClientConnection.cpp
index 94f35bb..b148d4b 100644
--- a/TriviaBot/bot/ClientConnection.cpp
+++ b/TriviaBot/bot/ClientConnection.cpp
@@ -3,60 +3,58 @@
 #include <cstdio>
 #include <iostream>
 
-#include "GatewayHandler.hpp"
 #include "Logger.hpp"
+#include "BotConfig.hpp"
 
-ClientConnection::ClientConnection() {
+ClientConnection::ClientConnection(BotConfig &c) : config(c), gh(config) {
 	// Reset the log channels
-	c.clear_access_channels(websocketpp::log::alevel::all);
+	cli.clear_access_channels(websocketpp::log::alevel::all);
 
 	// Only want application logging, logging from the initial connection stages or any error logging
-	c.set_access_channels(websocketpp::log::alevel::app | websocketpp::log::alevel::connect);
-	c.set_error_channels(websocketpp::log::elevel::all);
+	cli.set_access_channels(websocketpp::log::alevel::app | websocketpp::log::alevel::connect);
+	cli.set_error_channels(websocketpp::log::elevel::all);
 
 	// Initialize ASIO
-	c.init_asio();
+	cli.init_asio();
 
 	// Bind handlers
-	c.set_socket_init_handler(bind(
+	cli.set_socket_init_handler(bind(
 		&ClientConnection::on_socket_init,
 		this,
 		websocketpp::lib::placeholders::_1
 	));
-	c.set_tls_init_handler(bind<context_ptr>(
+	cli.set_tls_init_handler(bind<context_ptr>(
 		&ClientConnection::on_tls_init,
 		this,
 		websocketpp::lib::placeholders::_1
 		));
-	c.set_message_handler(bind(
+	cli.set_message_handler(bind(
 		&ClientConnection::on_message,
 		this,
 		websocketpp::lib::placeholders::_1,
 		websocketpp::lib::placeholders::_2
 	));
-	c.set_open_handler(bind(
+	cli.set_open_handler(bind(
 		&ClientConnection::on_open,
 		this,
 		websocketpp::lib::placeholders::_1
 	));
-	c.set_close_handler(bind(
+	cli.set_close_handler(bind(
 		&ClientConnection::on_close,
 		this,
 		websocketpp::lib::placeholders::_1
 	));
-	c.set_fail_handler(bind(
+	cli.set_fail_handler(bind(
 		&ClientConnection::on_fail,
 		this,
 		websocketpp::lib::placeholders::_1
 	));
-
-	gh = std::make_unique<GatewayHandler>();
 }
 
 // Open a connection to the URI provided
 void ClientConnection::start(std::string uri) {
 	websocketpp::lib::error_code ec;
-	client::connection_ptr con = c.get_connection(uri, ec);
+	client::connection_ptr con = cli.get_connection(uri, ec);
 
 	if (ec) { // failed to create connection
 		Logger::write("Failed to create connection: " + ec.message(), Logger::LogLevel::Severe);
@@ -64,8 +62,8 @@ void ClientConnection::start(std::string uri) {
 	}
 
 	// Open the connection
-	c.connect(con);
-	c.run();
+	cli.connect(con);
+	cli.run();
 
 	Logger::write("Finished running", Logger::LogLevel::Debug);
 }
@@ -91,7 +89,7 @@ context_ptr ClientConnection::on_tls_init(websocketpp::connection_hdl) {
 }
 
 void ClientConnection::on_fail(websocketpp::connection_hdl hdl) {
-	client::connection_ptr con = c.get_con_from_hdl(hdl);
+	client::connection_ptr con = cli.get_con_from_hdl(hdl);
 
 	// Print as much information as possible
 	Logger::write("Fail handler: \n" +
@@ -117,10 +115,10 @@ void ClientConnection::on_message(websocketpp::connection_hdl hdl, message_ptr m
 
 
 	// Pass the message to the gateway handler
-	gh->handle_data(message->get_payload(), c, hdl);
+	gh.handle_data(message->get_payload(), cli, hdl);
 }
 
 void ClientConnection::on_close(websocketpp::connection_hdl) {
 	Logger::write("Connection closed", Logger::LogLevel::Info);
-	c.stop();
+	cli.stop();
 }
\ No newline at end of file
diff --git a/TriviaBot/bot/ClientConnection.hpp b/TriviaBot/bot/ClientConnection.hpp
index 546ae7f..67faa80 100644
--- a/TriviaBot/bot/ClientConnection.hpp
+++ b/TriviaBot/bot/ClientConnection.hpp
@@ -5,6 +5,8 @@
 #include <websocketpp/config/asio_client.hpp>
 #include "json/json.hpp"
 
+#include "GatewayHandler.hpp"
+
 typedef websocketpp::client<websocketpp::config::asio_tls_client> client;
 
 using websocketpp::lib::bind;
@@ -14,15 +16,20 @@ typedef websocketpp::config::asio_tls_client::message_type::ptr message_ptr;
 typedef websocketpp::lib::shared_ptr<boost::asio::ssl::context> context_ptr;
 typedef client::connection_ptr connection_ptr;
 
-#include "GatewayHandler.hpp"
+class BotConfig;
 
 class ClientConnection {
 public:
-	ClientConnection();
+	ClientConnection(BotConfig &c);
 
 	// Open a connection to the URI provided
 	void start(std::string uri);
 
+private:
+	client cli;
+	BotConfig &config;
+	GatewayHandler gh;
+
 	// Event handlers
 	void on_socket_init(websocketpp::connection_hdl);
 	context_ptr on_tls_init(websocketpp::connection_hdl);
@@ -30,10 +37,6 @@ public:
 	void on_open(websocketpp::connection_hdl hdl);
 	void on_message(websocketpp::connection_hdl hdl, message_ptr message);
 	void on_close(websocketpp::connection_hdl);
-
-private:
-	client c;
-	std::unique_ptr<GatewayHandler> gh;
 };
 
 #endif
\ No newline at end of file
diff --git a/TriviaBot/bot/DiscordAPI.cpp b/TriviaBot/bot/DiscordAPI.cpp
index 3bb582a..6bbbfc7 100644
--- a/TriviaBot/bot/DiscordAPI.cpp
+++ b/TriviaBot/bot/DiscordAPI.cpp
@@ -4,7 +4,7 @@
 #include <thread>
 #include <chrono>
 
-#include "http/HTTPHelper.hpp"
+#include "http/HTTP.hpp"
 #include "Logger.hpp"
 
 using namespace std::chrono_literals;
@@ -16,7 +16,7 @@ namespace DiscordAPI {
 
 	const std::string json_mime_type = "application/json";
 
-	void send_message(std::string channel_id, std::string message) {
+	void send_message(std::string channel_id, std::string message, std::string token, std::string ca_location) {
 		if (message == "") {
 			Logger::write("[API] [send_message] Tried to send empty message", Logger::LogLevel::Warning);
 			return;
@@ -31,9 +31,9 @@ namespace DiscordAPI {
 
 			std::string first = message.substr(0, 2000);
 			std::string second = message.substr(2000);
-			send_message(channel_id, first);
+			send_message(channel_id, first, token, ca_location);
 			std::this_thread::sleep_for(50ms);
-			send_message(channel_id, second);
+			send_message(channel_id, second, token, ca_location);
 			return;
 		}
 
@@ -44,14 +44,14 @@ namespace DiscordAPI {
 
 		std::string response;
 		long response_code = 0;
-		response = HTTP::post_request(url, json_mime_type, data.dump(), &response_code);
+		response = HTTP::post_request(url, json_mime_type, data.dump(), &response_code, token, ca_location);
 
 		int retries = 0;
 		while (response_code != 200 && retries < 2) {
 			Logger::write("[API] [send_message] Got non-200 response code, retrying", Logger::LogLevel::Warning);
 			std::this_thread::sleep_for(100ms);
 			// try 3 times. usually enough to prevent 502 bad gateway issues
-			response = HTTP::post_request(url, json_mime_type, data.dump(), &response_code);
+			response = HTTP::post_request(url, json_mime_type, data.dump(), &response_code, token, ca_location);
 			retries++;
 		}
 
@@ -60,17 +60,17 @@ namespace DiscordAPI {
 		}
 	}
 
-	json get_gateway() {
+	json get_gateway(std::string ca_location) {
 		std::string response;
 		long response_code;
-		response = HTTP::get_request(gateway_url, &response_code);
+		response = HTTP::get_request(gateway_url, &response_code, "", ca_location);
 
 		int retries = 0;
 		while (response_code != 200 && retries < 4) {
 			Logger::write("[API] [get_gateway] Got non-200 response code, retrying", Logger::LogLevel::Warning);
 			std::this_thread::sleep_for(100ms);
 			// try 3 times. usually enough to prevent 502 bad gateway issues
-			response = HTTP::get_request(gateway_url, &response_code);
+			response = HTTP::get_request(gateway_url, &response_code, "", ca_location);
 			retries++;
 		}
 
diff --git a/TriviaBot/bot/DiscordAPI.hpp b/TriviaBot/bot/DiscordAPI.hpp
index 2c389d7..a5005fe 100644
--- a/TriviaBot/bot/DiscordAPI.hpp
+++ b/TriviaBot/bot/DiscordAPI.hpp
@@ -7,11 +7,11 @@
 
 using json = nlohmann::json;
 
-class HTTPHelper;
+class BotConfig;
 
 namespace DiscordAPI {
-	json get_gateway();
-	void send_message(std::string channel_id, std::string message);
+	json get_gateway(std::string ca_location);
+	void send_message(std::string channel_id, std::string message, std::string token, std::string ca_location);
 }
 
 #endif
\ No newline at end of file
diff --git a/TriviaBot/bot/GatewayHandler.cpp b/TriviaBot/bot/GatewayHandler.cpp
index 26c79d1..9a1d0e4 100644
--- a/TriviaBot/bot/GatewayHandler.cpp
+++ b/TriviaBot/bot/GatewayHandler.cpp
@@ -5,10 +5,9 @@
 #include "DiscordAPI.hpp"
 #include "Logger.hpp"
 #include "data_structures/GuildMember.hpp"
+#include "BotConfig.hpp"
 
-extern std::string bot_token;
-
-GatewayHandler::GatewayHandler() {
+GatewayHandler::GatewayHandler(BotConfig &c) : config(c) {
 	last_seq = 0;
 
 	CommandHelper::init();
@@ -59,7 +58,7 @@ void GatewayHandler::send_identify(client &c, websocketpp::connection_hdl &hdl)
 	json identify = {
 		{ "op", 2 },
 		{ "d", {
-			{ "token", bot_token },
+			{ "token", config.token },
 			{ "properties",{
 				{ "$browser", "Microsoft Windows 10" },
 				{ "$device", "TriviaBot-0.0" },
@@ -239,7 +238,7 @@ void GatewayHandler::on_event_guild_create(json data) {
 	}
 
 	if (v8_instances.count(guild.id) == 0) {
-		v8_instances[guild.id] = std::make_unique<V8Instance>(guild.id, &guilds, &channels, &users, &roles);
+		v8_instances[guild.id] = std::make_unique<V8Instance>(config, guild.id, &guilds, &channels, &users, &roles);
 		Logger::write("Created v8 instance for guild " + guild.id, Logger::LogLevel::Debug);
 	}
 
@@ -465,7 +464,7 @@ void GatewayHandler::on_event_message_create(json data, client &c, websocketpp::
 		int delay = 8;
 
 		if (words.size() > 3) {
-			DiscordAPI::send_message(channel.id, ":exclamation: Invalid arguments!");
+			DiscordAPI::send_message(channel.id, ":exclamation: Invalid arguments!", config.token, config.cert_location);
 			return;
 		}
 		else  if (words.size() > 1) {
@@ -475,7 +474,7 @@ void GatewayHandler::on_event_message_create(json data, client &c, websocketpp::
 				help += "\\`trivia **stop**: stops the ongoing game.\n";
 				help += "\\`trivia **help**: prints this message\n";
 
-				DiscordAPI::send_message(channel.id, help);
+				DiscordAPI::send_message(channel.id, help, config.token, config.cert_location);
 				return;
 			}
 			else if (words[1] == "stop" || words[1] == "s") {
@@ -483,7 +482,7 @@ void GatewayHandler::on_event_message_create(json data, client &c, websocketpp::
 					delete_game(channel.id);
 				}
 				else {
-					DiscordAPI::send_message(channel.id, ":warning: Couldn't find an ongoing trivia game for this channel.");
+					DiscordAPI::send_message(channel.id, ":warning: Couldn't find an ongoing trivia game for this channel.", config.token, config.cert_location);
 				}
 				return;
 			}
@@ -495,13 +494,13 @@ void GatewayHandler::on_event_message_create(json data, client &c, websocketpp::
 					}
 				}
 				catch (std::invalid_argument e) {
-					DiscordAPI::send_message(channel.id, ":exclamation: Invalid arguments!");
+					DiscordAPI::send_message(channel.id, ":exclamation: Invalid arguments!", config.token, config.cert_location);
 					return;
 				}
 			}
 		}
 
-		games[channel.id] = std::make_unique<TriviaGame>(this, channel.id, questions, delay);
+		games[channel.id] = std::make_unique<TriviaGame>(config, this, channel.id, questions, delay);
 		games[channel.id]->start();
 	}
 	else if (words[0] == "`guilds") {
@@ -509,10 +508,10 @@ void GatewayHandler::on_event_message_create(json data, client &c, websocketpp::
 		for (auto &gu : guilds) {
 			m += ":small_orange_diamond: " + gu.second.name + " (" + gu.second.id + ") Channels: " + std::to_string(gu.second.channels.size()) + "\n";
 		}
-		DiscordAPI::send_message(channel.id, m);
+		DiscordAPI::send_message(channel.id, m, config.token, config.cert_location);
 	}
 	else if (words[0] == "`info") {
-		DiscordAPI::send_message(channel.id, ":information_source: **trivia-bot** by Jack. <http://github.com/jackb-p/TriviaDiscord>");
+		DiscordAPI::send_message(channel.id, ":information_source: **trivia-bot** by Jack. <http://github.com/jackb-p/TriviaDiscord>", config.token, config.cert_location);
 	}
 	else if (words[0] == "~js" && words.size() > 1) {
 		DiscordObjects::GuildMember *member = *std::find_if(guild.members.begin(), guild.members.end(), [sender](DiscordObjects::GuildMember *m) {
@@ -526,12 +525,13 @@ void GatewayHandler::on_event_message_create(json data, client &c, websocketpp::
 	}
 	else if (words[0] == "~createjs" && words.size() > 1) {
 		auto &member = *std::find_if(guild.members.begin(), guild.members.end(), [sender](DiscordObjects::GuildMember *m) { return sender.id == m->user->id; });
-		bool allowed = std::find_if(member->roles.begin(), member->roles.end(), [](DiscordObjects::Role *r) { 
-			return r->name == "Admin" || r->name == "Moderator" || r->name == "Coder"; // TODO: customisation here
+		BotConfig &conf = config;
+		bool disallowed = std::find_if(member->roles.begin(), member->roles.end(), [conf](DiscordObjects::Role *r) -> bool { 
+			return conf.createjs_roles.count(r->name);
 		}) == member->roles.end(); // checks if the user has the required roles
 
-		if (!allowed) {
-			DiscordAPI::send_message(channel.id, ":warning: You do not have permission to use this command.");
+		if (disallowed) {
+			DiscordAPI::send_message(channel.id, ":warning: You do not have permission to use this command.", config.token, config.cert_location);
 			return;
 		}
 
@@ -543,16 +543,16 @@ void GatewayHandler::on_event_message_create(json data, client &c, websocketpp::
 			int result = CommandHelper::insert_command(channel.guild_id, command_name, script);
 			switch (result) {
 			case 0:
-				DiscordAPI::send_message(channel.id, ":warning: Error!"); break;
+				DiscordAPI::send_message(channel.id, ":warning: Error!", config.token, config.cert_location); break;
 			case 1:
-				DiscordAPI::send_message(channel.id, ":new: Command `" + command_name + "` successfully created."); break;
+				DiscordAPI::send_message(channel.id, ":new: Command `" + command_name + "` successfully created.", config.token, config.cert_location); break;
 			case 2:
-				DiscordAPI::send_message(channel.id, ":arrow_heading_up: Command `" + command_name + "` successfully updated."); break;
+				DiscordAPI::send_message(channel.id, ":arrow_heading_up: Command `" + command_name + "` successfully updated.", config.token, config.cert_location); break;
 			}
 		}
 	}
 	else if (words[0] == "`shutdown" && sender.id == "82232146579689472") { // it me
-		DiscordAPI::send_message(channel.id, ":zzz: Goodbye!");
+		DiscordAPI::send_message(channel.id, ":zzz: Goodbye!", config.token, config.cert_location);
 		for (auto &game : games) {
 			delete_game(game.first);
 		}
@@ -563,25 +563,25 @@ void GatewayHandler::on_event_message_create(json data, client &c, websocketpp::
 		if (words[1] == "channel" && words.size() == 3) {
 			auto it = channels.find(words[2]);
 			if (it == channels.end()) {
-				DiscordAPI::send_message(channel.id, ":question: Unrecognised channel.");
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised channel.", config.token, config.cert_location);
 				return;
 			}
 
-			DiscordAPI::send_message(channel.id, it->second.to_debug_string());
+			DiscordAPI::send_message(channel.id, it->second.to_debug_string(), config.token, config.cert_location);
 		}
 		else if (words[1] == "guild" && words.size() == 3) {
 			auto it = guilds.find(words[2]);
 			if (it == guilds.end()) {
-				DiscordAPI::send_message(channel.id, ":question: Unrecognised guild.");
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised guild.", config.token, config.cert_location);
 				return;
 			}
 
-			DiscordAPI::send_message(channel.id, it->second.to_debug_string());
+			DiscordAPI::send_message(channel.id, it->second.to_debug_string(), config.token, config.cert_location);
 		}
 		else if (words[1] == "member" && words.size() == 4) {
 			auto it = guilds.find(words[2]);
 			if (it == guilds.end()) {
-				DiscordAPI::send_message(channel.id, ":question: Unrecognised guild.");
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised guild.", config.token, config.cert_location);
 				return;
 			}
 
@@ -590,27 +590,27 @@ void GatewayHandler::on_event_message_create(json data, client &c, websocketpp::
 				return user_id == member->user->id;
 			});
 			if (it2 == it->second.members.end()) {
-				DiscordAPI::send_message(channel.id, ":question: Unrecognised user.");
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised user.", config.token, config.cert_location);
 				return;
 			}
 
-			DiscordAPI::send_message(channel.id, (*it2)->to_debug_string());
+			DiscordAPI::send_message(channel.id, (*it2)->to_debug_string(), config.token, config.cert_location);
 		}
 		else if (words[1] == "role" && words.size() == 3) {
 			auto it = roles.find(words[2]);
 			if (it == roles.end()) {
-				DiscordAPI::send_message(channel.id, ":question: Unrecognised role.");
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised role.", config.token, config.cert_location);
 				return;
 			}
 
-			DiscordAPI::send_message(channel.id, it->second.to_debug_string());
+			DiscordAPI::send_message(channel.id, it->second.to_debug_string(), config.token, config.cert_location);
 		}
 		else if (words[1] == "role" && words.size() == 4) {
 			std::string role_name = words[3];
 
 			auto it = guilds.find(words[2]);
 			if (it == guilds.end()) {
-				DiscordAPI::send_message(channel.id, ":question: Unrecognised guild.");
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised guild.", config.token, config.cert_location);
 				return;
 			}
 
@@ -618,14 +618,14 @@ void GatewayHandler::on_event_message_create(json data, client &c, websocketpp::
 				return role_name == r->name;
 			});
 			if (it2 == it->second.roles.end()) {
-				DiscordAPI::send_message(channel.id, ":question: Unrecognised role.");
+				DiscordAPI::send_message(channel.id, ":question: Unrecognised role.", config.token, config.cert_location);
 				return;
 			}
 			
-			DiscordAPI::send_message(channel.id, (*it2)->to_debug_string());
+			DiscordAPI::send_message(channel.id, (*it2)->to_debug_string(), config.token, config.cert_location);
 		}
 		else {
-			DiscordAPI::send_message(channel.id, ":question: Unknown parameters.");
+			DiscordAPI::send_message(channel.id, ":question: Unknown parameters.", config.token, config.cert_location);
 		}
 	}
 	else if (CommandHelper::get_command(channel.guild_id, words[0], custom_command)) {
@@ -635,13 +635,13 @@ void GatewayHandler::on_event_message_create(json data, client &c, websocketpp::
 		}
 
 		if (custom_command.script.length() == 0) {
-			DiscordAPI::send_message(channel.id, ":warning: Script has 0 length.");
+			DiscordAPI::send_message(channel.id, ":warning: Script has 0 length.", config.token, config.cert_location);
 			return;
 		}
 
 		auto it = v8_instances.find(channel.guild_id);
 		if (it == v8_instances.end()) {
-			DiscordAPI::send_message(channel.id, ":warning: No V8 instance exists for this server - it's our fault not yours!");
+			DiscordAPI::send_message(channel.id, ":warning: No V8 instance exists for this server - it's our fault not yours!", config.token, config.cert_location);
 			return;
 		}
 
diff --git a/TriviaBot/bot/GatewayHandler.hpp b/TriviaBot/bot/GatewayHandler.hpp
index 4146428..3be7ca3 100644
--- a/TriviaBot/bot/GatewayHandler.hpp
+++ b/TriviaBot/bot/GatewayHandler.hpp
@@ -37,17 +37,19 @@ using json = nlohmann::json;
 *****************************************************************************************************************************/
 
 class TriviaGame;
-class APIHelper;
+class BotConfig;
 
 class GatewayHandler {
 public:
-	GatewayHandler();
+	GatewayHandler(BotConfig &c);
 
 	void handle_data(std::string data, client &c, websocketpp::connection_hdl &hdl);
 
 	void delete_game(std::string channel_id);
 
 private:
+	BotConfig &config;
+
 	int last_seq;
 	int heartbeat_interval;
 
diff --git a/TriviaBot/bot/TriviaBot.cpp b/TriviaBot/bot/TriviaBot.cpp
index 7090e45..5e57aca 100644
--- a/TriviaBot/bot/TriviaBot.cpp
+++ b/TriviaBot/bot/TriviaBot.cpp
@@ -8,10 +8,15 @@
 #include "ClientConnection.hpp"
 #include "Logger.hpp"
 #include "DiscordAPI.hpp"
-
-std::string bot_token;
+#include "BotConfig.hpp"
 
 int main(int argc, char *argv[]) {
+	BotConfig config;
+	if (config.is_new_config) {
+		Logger::write("Since the config.json file is newly generated, the program will exit now to allow you to edit it.", Logger::LogLevel::Info);
+		return 0;
+	}
+
 	curl_global_init(CURL_GLOBAL_DEFAULT);
 
 	v8::V8::InitializeICUDefaultLocation(argv[0]);
@@ -22,16 +27,8 @@ int main(int argc, char *argv[]) {
 
 	Logger::write("Initialised V8 and curl", Logger::LogLevel::Debug);
 
-	if (argc == 2) {
-		bot_token = argv[1];
-	}
-	else {
-		std::cout << "Please enter your bot token: " << std::endl;
-		std::cin >> bot_token;
-	}
-
 	std::string args = "/?v=5&encoding=json";
-	std::string url = DiscordAPI::get_gateway().value("url", "wss://gateway.discord.gg");
+	std::string url = DiscordAPI::get_gateway(config.cert_location).value("url", "wss://gateway.discord.gg");
 
 	bool retry = true;
 	int exit_code = 0;
@@ -39,7 +36,7 @@ int main(int argc, char *argv[]) {
 		retry = false;
 
 		try {
-			ClientConnection conn;
+			ClientConnection conn(config);
 			conn.start(url + args);
 		}
 		catch (const std::exception &e) {
@@ -65,5 +62,6 @@ int main(int argc, char *argv[]) {
 
 	Logger::write("Cleaned up", Logger::LogLevel::Info);
 
+	std::getchar();
 	return exit_code;
 }
diff --git a/TriviaBot/bot/TriviaGame.cpp b/TriviaBot/bot/TriviaGame.cpp
index a9914ca..b440b14 100644
--- a/TriviaBot/bot/TriviaGame.cpp
+++ b/TriviaBot/bot/TriviaGame.cpp
@@ -13,8 +13,9 @@
 #include "DiscordAPI.hpp"
 #include "data_structures/User.hpp"
 #include "Logger.hpp"
+#include "BotConfig.hpp"
 
-TriviaGame::TriviaGame(GatewayHandler *gh, std::string channel_id, int total_questions, int delay) : interval(delay) {
+TriviaGame::TriviaGame(BotConfig &c, GatewayHandler *gh, std::string channel_id, int total_questions, int delay) : interval(delay), config(c) {
 	this->gh = gh;
 	this->channel_id = channel_id;
 
@@ -26,7 +27,7 @@ TriviaGame::~TriviaGame() {
 	current_thread.reset();
 
 	if (scores.size() == 0) {
-		DiscordAPI::send_message(channel_id, ":red_circle: Game cancelled!");
+		DiscordAPI::send_message(channel_id, ":red_circle: Game cancelled!", config.token, config.cert_location);
 		return;
 	}
 
@@ -50,7 +51,7 @@ TriviaGame::~TriviaGame() {
 		average_time.pop_back(); average_time.pop_back(); average_time.pop_back();
 		message += ":small_blue_diamond: <@!" + p.first + ">: " + std::to_string(p.second) + " (Avg: " + average_time + " seconds)\n";
 	}
-	DiscordAPI::send_message(channel_id, message);
+	DiscordAPI::send_message(channel_id, message, config.token, config.cert_location);
 
 	sqlite3 *db; int rc; std::string sql;
 
@@ -213,7 +214,8 @@ void TriviaGame::question() {
 		sqlite3_close(db);
 
 		questions_asked++;
-		DiscordAPI::send_message(channel_id, ":question: **(" + std::to_string(questions_asked) + "/" + std::to_string(total_questions) + ")** " + current_question);
+		DiscordAPI::send_message(channel_id, ":question: **(" + std::to_string(questions_asked) + "/" + std::to_string(total_questions) + ")** " + current_question,
+			config.token, config.cert_location);
 		question_start = boost::posix_time::microsec_clock::universal_time();
 
 		give_hint(0, "");
@@ -280,11 +282,11 @@ void TriviaGame::give_hint(int hints_given, std::string hint) {
 		hints_given++; // now equal to the amount of [hide_char]s that need to be present in each word
 	
 		if (print) {
-			DiscordAPI::send_message(channel_id, ":small_orange_diamond: Hint: **`" + hint + "`**");
+			DiscordAPI::send_message(channel_id, ":small_orange_diamond: Hint: **`" + hint + "`**", config.token, config.cert_location);
 		}
 	}
 	boost::this_thread::sleep(interval);
-	DiscordAPI::send_message(channel_id, ":exclamation: Question failed. Answer: ** `" + *current_answers.begin() + "` **");
+	DiscordAPI::send_message(channel_id, ":exclamation: Question failed. Answer: ** `" + *current_answers.begin() + "` **", config.token, config.cert_location);
 }
 
 void TriviaGame::handle_answer(std::string answer, DiscordObjects::User sender) {
@@ -299,7 +301,7 @@ void TriviaGame::handle_answer(std::string answer, DiscordObjects::User sender)
 		// remove the last three 0s
 		time_taken.pop_back(); time_taken.pop_back(); time_taken.pop_back();
 
-		DiscordAPI::send_message(channel_id, ":heavy_check_mark: <@!" + sender.id + "> You got it! (" + time_taken + " seconds)");
+		DiscordAPI::send_message(channel_id, ":heavy_check_mark: <@!" + sender.id + "> You got it! (" + time_taken + " seconds)", config.token, config.cert_location);
 
 		increase_score(sender.id);
 		update_average_time(sender.id, diff.total_milliseconds());
diff --git a/TriviaBot/bot/TriviaGame.hpp b/TriviaBot/bot/TriviaGame.hpp
index 89b326f..477c7f1 100644
--- a/TriviaBot/bot/TriviaGame.hpp
+++ b/TriviaBot/bot/TriviaGame.hpp
@@ -11,14 +11,14 @@
 #include <boost/date_time/posix_time/posix_time.hpp>
 
 class GatewayHandler;
+class BotConfig;
 namespace DiscordObjects {
 	class User;
 }
 
-
 class TriviaGame {
 public:
-	TriviaGame(GatewayHandler *gh, std::string channel_id, int total_questions, int delay);
+	TriviaGame(BotConfig &c, GatewayHandler *gh, std::string channel_id, int total_questions, int delay);
 	~TriviaGame();
 
 	void start();
@@ -26,6 +26,8 @@ public:
 	void handle_answer(std::string answer, DiscordObjects::User sender);
 
 private:
+	BotConfig &config;
+
 	int questions_asked;
 	int total_questions;
 	boost::posix_time::seconds interval;
diff --git a/TriviaBot/bot/http/HTTPHelper.cpp b/TriviaBot/bot/http/HTTP.cpp
similarity index 83%
rename from TriviaBot/bot/http/HTTPHelper.cpp
rename to TriviaBot/bot/http/HTTP.cpp
index d1e98ee..fa28ec4 100644
--- a/TriviaBot/bot/http/HTTPHelper.cpp
+++ b/TriviaBot/bot/http/HTTP.cpp
@@ -1,20 +1,18 @@
-#include "HTTPHelper.hpp"
+#include "HTTP.hpp"
 
 #include "../Logger.hpp"
-
-extern std::string bot_token;
+#include "../BotConfig.hpp"
 
 /*
 *  Warning: (Awful) C Code
 */
-
 namespace HTTP {
 	size_t write_callback(void *contents, size_t size, size_t nmemb, void *read_buffer) {
 		static_cast<std::string *>(read_buffer)->append(static_cast<char *>(contents), size * nmemb);
 		return size * nmemb;
 	}
 
-	std::string post_request(std::string url, std::string content_type, std::string data, long *response_code) {
+	std::string post_request(std::string url, std::string content_type, std::string data, long *response_code, std::string token, std::string ca_location) {
 		CURL *curl;
 		CURLcode res;
 		std::string read_buffer;
@@ -25,11 +23,11 @@ namespace HTTP {
 			curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
 
 			// Now with real HTTPS!
-			curl_easy_setopt(curl, CURLOPT_CAINFO, "bot/http/DiscordCA.crt");
+			curl_easy_setopt(curl, CURLOPT_CAINFO, ca_location.c_str());
 
 			std::string header_arr[3];
 			header_arr[0] = "Content-Type: " + content_type;
-			header_arr[1] = "Authorization: Bot " + bot_token;
+			header_arr[1] = "Authorization: Bot " + token;
 			header_arr[2] = "User-Agent: DiscordBot(http://github.com/jackb-p/triviadiscord, 1.0)";
 
 			for (std::string h : header_arr) {
@@ -59,7 +57,7 @@ namespace HTTP {
 		return read_buffer;
 	}
 
-	std::string get_request(std::string url, long *response_code) {
+	std::string get_request(std::string url, long *response_code, std::string token, std::string ca_location) {
 		CURL *curl;
 		CURLcode res;
 		std::string read_buffer;
@@ -70,10 +68,10 @@ namespace HTTP {
 			curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
 
 			// Now with real HTTPS!
-			curl_easy_setopt(curl, CURLOPT_CAINFO, "bot/http/DiscordCA.crt");
+			curl_easy_setopt(curl, CURLOPT_CAINFO, ca_location.c_str());
 
 			std::string header_arr[2];
-			header_arr[0] = "Authorization: Bot " + bot_token;
+			header_arr[0] = "Authorization: Bot " + token;
 			header_arr[1] = "User-Agent: DiscordBot (http://github.com/jackb-p/triviadiscord, 1.0)";
 
 			for (std::string h : header_arr) {
diff --git a/TriviaBot/bot/http/HTTP.hpp b/TriviaBot/bot/http/HTTP.hpp
new file mode 100644
index 0000000..1f84f7d
--- /dev/null
+++ b/TriviaBot/bot/http/HTTP.hpp
@@ -0,0 +1,15 @@
+#ifndef BOT_HTTP_HTTP
+#define BOT_HTTP_HTTP
+
+#include <iostream>
+
+#include <curl/curl.h>
+
+class BotConfig;
+
+namespace HTTP {
+	std::string post_request(std::string url, std::string content_type, std::string data, long *response_code, std::string token, std::string ca_location);
+	std::string get_request(std::string url, long *response_code, std::string token, std::string ca_location);
+}
+
+#endif
\ No newline at end of file
diff --git a/TriviaBot/bot/http/HTTPHelper.hpp b/TriviaBot/bot/http/HTTPHelper.hpp
deleted file mode 100644
index 1acc725..0000000
--- a/TriviaBot/bot/http/HTTPHelper.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef BOT_HTTP_HTTPHELPER
-#define BOT_HTTP_HTTPHELPER
-
-#include <iostream>
-
-#include <curl/curl.h>
-
-namespace HTTP {
-	std::string post_request(std::string url, std::string content_type, std::string data, long *response_code);
-	std::string get_request(std::string url, long *response_code);
-}
-
-#endif
\ No newline at end of file
diff --git a/TriviaBot/bot/js/V8Instance.cpp b/TriviaBot/bot/js/V8Instance.cpp
index 6ca2cf4..6769c31 100644
--- a/TriviaBot/bot/js/V8Instance.cpp
+++ b/TriviaBot/bot/js/V8Instance.cpp
@@ -6,9 +6,12 @@
 #include "V8Instance.hpp"
 #include "../DiscordAPI.hpp"
 #include "../Logger.hpp"
+#include "../BotConfig.hpp"
 
-V8Instance::V8Instance(std::string guild_id, std::map<std::string, DiscordObjects::Guild> *guilds, std::map<std::string, DiscordObjects::Channel> *channels,
-	std::map<std::string, DiscordObjects::User> *users, std::map<std::string, DiscordObjects::Role> *roles) {
+using namespace v8;
+
+V8Instance::V8Instance(BotConfig &c, std::string guild_id, std::map<std::string, DiscordObjects::Guild> *guilds, std::map<std::string, DiscordObjects::Channel> *channels,
+	std::map<std::string, DiscordObjects::User> *users, std::map<std::string, DiscordObjects::Role> *roles) : config(c) {
 
 	rng = std::mt19937(std::random_device()());
 	this->guild_id = guild_id;
@@ -25,6 +28,7 @@ void V8Instance::create() {
 	create_params.array_buffer_allocator = ArrayBuffer::Allocator::NewDefaultAllocator();
 
 	isolate = Isolate::New(create_params);
+	isolate->Enter();
 	Logger::write("[v8] Created isolate", Logger::LogLevel::Debug);
 
 	Isolate::Scope isolate_scope(isolate);
@@ -696,7 +700,7 @@ void V8Instance::exec_js(std::string js, DiscordObjects::Channel *channel, Disco
 
 		std::string err_msg = *error;
 		Logger::write("[v8] Compilation error: " + err_msg, Logger::LogLevel::Debug);
-		DiscordAPI::send_message(channel->id, ":warning: **Compilation error:** `" + err_msg + "`");
+		DiscordAPI::send_message(channel->id, ":warning: **Compilation error:** `" + err_msg + "`", config.token, config.cert_location);
 
 		return;
 	}
@@ -708,7 +712,7 @@ void V8Instance::exec_js(std::string js, DiscordObjects::Channel *channel, Disco
 
 		std::string err_msg = *error;
 		Logger::write("[v8] Runtime error: " + err_msg, Logger::LogLevel::Debug);
-		DiscordAPI::send_message(channel->id, ":warning: **Runtime error:** `" + err_msg + "`");
+		DiscordAPI::send_message(channel->id, ":warning: **Runtime error:** `" + err_msg + "`", config.token, config.cert_location);
 	}
 
 	auto end = std::chrono::steady_clock::now();
@@ -719,7 +723,7 @@ void V8Instance::exec_js(std::string js, DiscordObjects::Channel *channel, Disco
 	current_channel = nullptr;
 
 	if (print_text != "") {
-		DiscordAPI::send_message(channel->id, print_text);
+		DiscordAPI::send_message(channel->id, print_text, config.token, config.cert_location);
 		print_text = "";
 	}
 }
diff --git a/TriviaBot/bot/js/V8Instance.hpp b/TriviaBot/bot/js/V8Instance.hpp
index 00e99b8..423ec53 100644
--- a/TriviaBot/bot/js/V8Instance.hpp
+++ b/TriviaBot/bot/js/V8Instance.hpp
@@ -14,68 +14,68 @@
 #include "../data_structures/GuildMember.hpp"
 #include "../data_structures/User.hpp"
 
-class APIHelper;
-
-using namespace v8;
+class BotConfig;
 
 class V8Instance {
 public:
-	V8Instance(std::string guild_id, std::map<std::string, DiscordObjects::Guild> *guilds,
+	V8Instance(BotConfig &c, std::string guild_id, std::map<std::string, DiscordObjects::Guild> *guilds,
 		std::map<std::string, DiscordObjects::Channel> *channels, std::map<std::string, DiscordObjects::User> *users, std::map<std::string, DiscordObjects::Role> *roles);
 	void exec_js(std::string js, DiscordObjects::Channel *channel, DiscordObjects::GuildMember *sender, std::string args = "");
 
 private:
-	void create();
-	Local<Context> create_context();
+	BotConfig &config;
 
-	void initialise(Local<Context> context);
+	void create();
+	v8::Local<v8::Context> create_context();
+
+	void initialise(v8::Local<v8::Context> context);
 
 	/* server */
-	Global<ObjectTemplate> server_template;
-	Local<ObjectTemplate> make_server_template();
-	Local<Object> wrap_server(DiscordObjects::Guild *guild);
-	static void js_get_server(Local<Name> property, const PropertyCallbackInfo<Value> &info);
+	v8::Global<v8::ObjectTemplate> server_template;
+	v8::Local<v8::ObjectTemplate> make_server_template();
+	v8::Local<v8::Object> wrap_server(DiscordObjects::Guild *guild);
+	static void js_get_server(v8::Local<v8::Name> property, const v8::PropertyCallbackInfo<v8::Value> &info);
 
 
 	/* user */
-	Global<ObjectTemplate> user_template;
-	Local<ObjectTemplate> make_user_template();
-	Local<Object> wrap_user(DiscordObjects::GuildMember *member);
-	static void js_get_user(Local<Name> property, const PropertyCallbackInfo<Value> &info);
+	v8::Global<v8::ObjectTemplate> user_template;
+	v8::Local<v8::ObjectTemplate> make_user_template();
+	v8::Local<v8::Object> wrap_user(DiscordObjects::GuildMember *member);
+	static void js_get_user(v8::Local<v8::Name> property, const v8::PropertyCallbackInfo<v8::Value> &info);
 
-	Global<ObjectTemplate> user_list_template;
-	Local<ObjectTemplate> make_user_list_template();
-	Local<Object> wrap_user_list(std::vector<DiscordObjects::GuildMember *> *user_list);
-	static void js_get_user_list(uint32_t index, const PropertyCallbackInfo<Value> &info);
+	v8::Global<v8::ObjectTemplate> user_list_template;
+	v8::Local<v8::ObjectTemplate> make_user_list_template();
+	v8::Local<v8::Object> wrap_user_list(std::vector<DiscordObjects::GuildMember *> *user_list);
+	static void js_get_user_list(uint32_t index, const v8::PropertyCallbackInfo<v8::Value> &info);
 
 	/* channel */
-	Global<ObjectTemplate> channel_template;
-	Local<ObjectTemplate> make_channel_template();
-	Local<Object> wrap_channel(DiscordObjects::Channel *channel);
-	static void js_get_channel(Local<Name> property, const PropertyCallbackInfo<Value> &info);
+	v8::Global<v8::ObjectTemplate> channel_template;
+	v8::Local<v8::ObjectTemplate> make_channel_template();
+	v8::Local<v8::Object> wrap_channel(DiscordObjects::Channel *channel);
+	static void js_get_channel(v8::Local<v8::Name> property, const v8::PropertyCallbackInfo<v8::Value> &info);
 
-	Global<ObjectTemplate> channel_list_template;
-	Local<ObjectTemplate> make_channel_list_template();
-	Local<Object> wrap_channel_list(std::vector<DiscordObjects::Channel *> *channel_list);
-	static void js_get_channel_list(uint32_t index, const PropertyCallbackInfo<Value> &info);
+	v8::Global<v8::ObjectTemplate> channel_list_template;
+	v8::Local<v8::ObjectTemplate> make_channel_list_template();
+	v8::Local<v8::Object> wrap_channel_list(std::vector<DiscordObjects::Channel *> *channel_list);
+	static void js_get_channel_list(uint32_t index, const v8::PropertyCallbackInfo<v8::Value> &info);
 
 	/* role */
-	Global<ObjectTemplate> role_template;
-	Local<ObjectTemplate> make_role_template();
-	Local<Object> wrap_role(DiscordObjects::Role *role);
-	static void js_get_role(Local<Name> property, const PropertyCallbackInfo<Value> &info);
+	v8::Global<v8::ObjectTemplate> role_template;
+	v8::Local<v8::ObjectTemplate> make_role_template();
+	v8::Local<v8::Object> wrap_role(DiscordObjects::Role *role);
+	static void js_get_role(v8::Local<v8::Name> property, const v8::PropertyCallbackInfo<v8::Value> &info);
 
-	Global<ObjectTemplate> role_list_template;
-	Local<ObjectTemplate> make_role_list_template();
-	Local<Object> wrap_role_list(std::vector<DiscordObjects::Role *> *role_list);
-	static void js_get_role_list(uint32_t index, const PropertyCallbackInfo<Value> &info);
+	v8::Global<v8::ObjectTemplate> role_list_template;
+	v8::Local<v8::ObjectTemplate> make_role_list_template();
+	v8::Local<v8::Object> wrap_role_list(std::vector<DiscordObjects::Role *> *role_list);
+	static void js_get_role_list(uint32_t index, const v8::PropertyCallbackInfo<v8::Value> &info);
 
 	/* print function */
-	static void js_print(const FunctionCallbackInfo<Value> &args);
+	static void js_print(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 	/* randomness functions */
-	static void js_random(const FunctionCallbackInfo<Value> &args);
-	static void js_shuffle(const FunctionCallbackInfo<Value> &args);
+	static void js_random(const v8::FunctionCallbackInfo<v8::Value> &args);
+	static void js_shuffle(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 	std::map<std::string, DiscordObjects::Guild> *guilds;
 	std::map<std::string, DiscordObjects::Channel> *channels;
@@ -83,9 +83,9 @@ private:
 	std::map<std::string, DiscordObjects::Role> *roles;
 
 	std::string guild_id;
-	Isolate *isolate;
+	v8::Isolate *isolate;
 
-	Global<Context> context_;
+	v8::Global<v8::Context> context_;
 
 	/* random generating variables */
 	std::mt19937 rng;

From 9c7e4f5a6d42e017d735eaf706ebd4ff0cfe491d Mon Sep 17 00:00:00 2001
From: jackb-p <jackbondpreston@outlook.com>
Date: Mon, 15 Aug 2016 21:12:47 +0200
Subject: [PATCH 15/15] Squash bugs and warnings, optimise CMake builds.

---
 .gitignore                         | 8 +++++++-
 TriviaBot/CMakeLists.txt           | 2 ++
 TriviaBot/bot/TriviaBot.cpp        | 1 -
 TriviaBot/bot/TriviaGame.cpp       | 4 ++--
 TriviaBot/bot/js/CommandHelper.cpp | 4 ++--
 5 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/.gitignore b/.gitignore
index 5861706..e9b86b7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,4 +14,10 @@
 config.json
 
 # Compiled sqlite file
-sqlite3.obj
\ No newline at end of file
+sqlite3.obj
+
+# V8 lib
+lib/v8
+
+# Built files
+build/
diff --git a/TriviaBot/CMakeLists.txt b/TriviaBot/CMakeLists.txt
index 2d7ba87..00b718f 100644
--- a/TriviaBot/CMakeLists.txt
+++ b/TriviaBot/CMakeLists.txt
@@ -52,3 +52,5 @@ include_directories(
 
 # don't know if necessary, too scared to remove
 add_definitions(-D_WEBSOCKETPP_CPP11_STL_)
+
+set(CMAKE_BUILD_TYPE Release)
diff --git a/TriviaBot/bot/TriviaBot.cpp b/TriviaBot/bot/TriviaBot.cpp
index 5e57aca..719735c 100644
--- a/TriviaBot/bot/TriviaBot.cpp
+++ b/TriviaBot/bot/TriviaBot.cpp
@@ -62,6 +62,5 @@ int main(int argc, char *argv[]) {
 
 	Logger::write("Cleaned up", Logger::LogLevel::Info);
 
-	std::getchar();
 	return exit_code;
 }
diff --git a/TriviaBot/bot/TriviaGame.cpp b/TriviaBot/bot/TriviaGame.cpp
index b440b14..b2310e4 100644
--- a/TriviaBot/bot/TriviaGame.cpp
+++ b/TriviaBot/bot/TriviaGame.cpp
@@ -15,7 +15,7 @@
 #include "Logger.hpp"
 #include "BotConfig.hpp"
 
-TriviaGame::TriviaGame(BotConfig &c, GatewayHandler *gh, std::string channel_id, int total_questions, int delay) : interval(delay), config(c) {
+TriviaGame::TriviaGame(BotConfig &c, GatewayHandler *gh, std::string channel_id, int total_questions, int delay) : config(c), interval(delay) {
 	this->gh = gh;
 	this->channel_id = channel_id;
 
@@ -339,4 +339,4 @@ void TriviaGame::update_average_time(std::string user_id, int time) {
 		// yeah it probably loses accuracy here, doesn't really matter
 		average_times[user_id] = (int) (total / questions_answered);
 	}
-}
\ No newline at end of file
+}
diff --git a/TriviaBot/bot/js/CommandHelper.cpp b/TriviaBot/bot/js/CommandHelper.cpp
index afd8c2e..31f4bde 100644
--- a/TriviaBot/bot/js/CommandHelper.cpp
+++ b/TriviaBot/bot/js/CommandHelper.cpp
@@ -14,7 +14,7 @@ namespace CommandHelper {
 		sqlite3 *db; int return_code;
 		return_code = sqlite3_open("bot/db/trivia.db", &db);
 
-		std::string sql = "SELECT * FROM CustomJS";
+		std::string sql = "SELECT GuildID, CommandName, Script FROM CustomJS";
 
 		sqlite3_stmt *stmt;
 		return_code = sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0);
@@ -161,4 +161,4 @@ namespace CommandHelper {
 
 		return exists;
 	}
-}
\ No newline at end of file
+}