From 238da3a706448d4c592460684e2a5a2c0eb81a04 Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Sun, 14 Oct 2012 13:56:25 +0200
Subject: [PATCH 01/16] implemented modulo operation for scripts

---
 src/common/Script.h         | 3 +++
 src/common/ScriptRunner.cpp | 6 ++++++
 2 files changed, 9 insertions(+)

diff --git a/src/common/Script.h b/src/common/Script.h
index 93bc531..0dbaf4d 100644
--- a/src/common/Script.h
+++ b/src/common/Script.h
@@ -29,6 +29,9 @@ public:
 		CODE_ADD_V0,
 		CODE_ADD_V1,
 
+		CODE_MOD_I0,
+		CODE_MOD_I1,
+
 		CODE_RAND_I0,
 		CODE_RAND_I1,
 
diff --git a/src/common/ScriptRunner.cpp b/src/common/ScriptRunner.cpp
index 110b702..c1022c4 100644
--- a/src/common/ScriptRunner.cpp
+++ b/src/common/ScriptRunner.cpp
@@ -93,6 +93,12 @@ void ScriptRunner::Exec(unsigned char code) {
 		case Script::CODE_ADD_V1:
 			vector1 += PopVector();
 			break;
+		case Script::CODE_MOD_I0:
+			integer0 %= PopInt();
+			break;
+		case Script::CODE_MOD_I1:
+			integer1 %= PopInt();
+			break;
 		case Script::CODE_RAND_I0:
 			integer0 = std::rand();
 			break;
-- 
2.39.2


From 963ed8ddb873e0638b55b38c5590db75db8254c8 Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Sun, 14 Oct 2012 14:44:38 +0200
Subject: [PATCH 02/16] added new tokens

---
 src/loader/Tokenizer.cpp | 24 ++++++++++++++++++++++--
 src/loader/Tokenizer.h   | 14 +++++++++++++-
 2 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/src/loader/Tokenizer.cpp b/src/loader/Tokenizer.cpp
index 6acda5f..91ad8b9 100644
--- a/src/loader/Tokenizer.cpp
+++ b/src/loader/Tokenizer.cpp
@@ -77,15 +77,35 @@ Tokenizer::Token Tokenizer::ReadToken() {
 	switch (c) {
 		case Token::ANGLE_BRACKET_OPEN:
 		case Token::ANGLE_BRACKET_CLOSE:
-		case Token::CHEVRON_OPEN:
-		case Token::CHEVRON_CLOSE:
 		case Token::COLON:
 		case Token::COMMA:
 		case Token::BRACKET_OPEN:
 		case Token::BRACKET_CLOSE:
 		case Token::PARENTHESIS_OPEN:
 		case Token::PARENTHESIS_CLOSE:
+		case Token::COMMAND:
+		case Token::REGISTER:
 			return Token ((Token::Type) c);
+		case '<': {
+			std::istream::char_type c2;
+			in.get(c2);
+			if (c2 == '<') {
+				return Token(Token::SCRIPT_BEGIN);
+			} else {
+				in.putback(c2);
+				return Token(Token::CHEVRON_OPEN);
+			}
+		}
+		case '>': {
+			std::istream::char_type c2;
+			in.get(c2);
+			if (c2 == '>') {
+				return Token(Token::SCRIPT_END);
+			} else {
+				in.putback(c2);
+				return Token(Token::CHEVRON_CLOSE);
+			}
+		}
 		case '+': case '-':
 		case '0': case '1': case '2': case '3': case '4':
 		case '5': case '6': case '7': case '8': case '9':
diff --git a/src/loader/Tokenizer.h b/src/loader/Tokenizer.h
index dff96fc..864f9d2 100644
--- a/src/loader/Tokenizer.h
+++ b/src/loader/Tokenizer.h
@@ -48,7 +48,11 @@ public:
 			KEYWORD_TRUE = 't',
 			IDENTIFIER = 'x',
 			TYPE_NAME = 'n',
-			COMMENT = 'c'
+			COMMENT = 'c',
+			COMMAND = '$',
+			REGISTER = '%',
+			SCRIPT_BEGIN = 's',
+			SCRIPT_END = 'S',
 		};
 
 		Token() : type(UNKNOWN), number(0) { }
@@ -111,6 +115,8 @@ inline const char *TokenTypeToString(Tokenizer::Token::Type t) {
 			return "COLON";
 		case Tokenizer::Token::COMMA:
 			return "COMMA";
+		case Tokenizer::Token::COMMAND:
+			return "COMMAND";
 		case Tokenizer::Token::BRACKET_OPEN:
 			return "BRACKET_OPEN";
 		case Tokenizer::Token::BRACKET_CLOSE:
@@ -121,6 +127,12 @@ inline const char *TokenTypeToString(Tokenizer::Token::Type t) {
 			return "PARENTHESIS_CLOSE";
 		case Tokenizer::Token::NUMBER:
 			return "NUMBER";
+		case Tokenizer::Token::REGISTER:
+			return "REGISTER";
+		case Tokenizer::Token::SCRIPT_BEGIN:
+			return "SCRIPT_BEGIN";
+		case Tokenizer::Token::SCRIPT_END:
+			return "SCRIPT_END";
 		case Tokenizer::Token::STRING:
 			return "STRING";
 		case Tokenizer::Token::KEYWORD_EXPORT:
-- 
2.39.2


From 3a30342daecdb9ee050ab20fcb50819a599d6343 Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Sun, 14 Oct 2012 15:31:29 +0200
Subject: [PATCH 03/16] parse scripts

---
 src/loader/Interpreter.cpp  |  5 ++-
 src/loader/ParsedSource.cpp | 81 +++++++++++++++++++++++++++++++++++++
 src/loader/ParsedSource.h   | 38 ++++++++++++++++-
 src/loader/Parser.cpp       | 55 ++++++++++++++++++++++++-
 src/loader/Parser.h         |  2 +
 src/loader/fwd.h            |  1 +
 6 files changed, 179 insertions(+), 3 deletions(-)

diff --git a/src/loader/Interpreter.cpp b/src/loader/Interpreter.cpp
index e8d4ec9..8b9b56a 100644
--- a/src/loader/Interpreter.cpp
+++ b/src/loader/Interpreter.cpp
@@ -142,6 +142,8 @@ void Interpreter::ReadLiteral(int typeId, int id, char *object, const Literal &l
 			std::memcpy(object, literal.GetString().c_str(), literal.GetString().size());
 			object[literal.GetString().size()] = '\0';
 			break;
+		case Literal::SCRIPT:
+			throw Error("script compiler not implemented");
 		case Literal::STRING:
 			std::memcpy(object, literal.GetString().c_str(), literal.GetString().size());
 			object[literal.GetString().size()] = '\0';
@@ -151,7 +153,6 @@ void Interpreter::ReadLiteral(int typeId, int id, char *object, const Literal &l
 			break;
 		case Literal::OBJECT:
 			throw Error("illogical branch: read literal object as non-object literal");
-			break;
 	}
 }
 
@@ -213,6 +214,8 @@ void *Interpreter::GetObject(int typeId, const Value &v) {
 						values[typeId].push_back(str);
 					}
 					break;
+				case Literal::SCRIPT:
+					throw Error("script compiler not implemented");
 				case Literal::STRING:
 					{
 						typeId = TypeDescription::GetTypeId("String");
diff --git a/src/loader/ParsedSource.cpp b/src/loader/ParsedSource.cpp
index e1a1d0a..6b2fc80 100644
--- a/src/loader/ParsedSource.cpp
+++ b/src/loader/ParsedSource.cpp
@@ -279,6 +279,16 @@ Literal::Literal(const string &typeName, PropertyList *properties)
 
 }
 
+Literal::Literal(const vector<ScriptToken *> &s)
+: props(0)
+, script(s)
+, i1(0), i2(0)
+, i3(0), i4(0)
+, b(false)
+, type(SCRIPT) {
+
+}
+
 Literal::~Literal() {
 	switch (type) {
 		case ARRAY_VALUES:
@@ -294,6 +304,11 @@ Literal::~Literal() {
 		case OBJECT:
 			delete props;
 			break;
+		case SCRIPT:
+			for (vector<ScriptToken *>::const_iterator i(script.begin()), end(script.end()); i != end; ++i) {
+				delete *i;
+			}
+			break;
 		default:
 			break;
 	}
@@ -400,6 +415,14 @@ const PropertyList *Literal::GetProperties() const {
 	}
 }
 
+const vector<ScriptToken *> &Literal::GetScript() const {
+	if (type == SCRIPT) {
+		return script;
+	} else {
+		throw runtime_error("tried to access script of non-script literal");
+	}
+}
+
 
 Value::~Value() {
 	if (isLiteral) {
@@ -423,6 +446,61 @@ const std::string &Value::GetIdentifier() const {
 	}
 }
 
+
+ScriptToken::ScriptToken(const string &s, Type t)
+: literal(0)
+, str(s)
+, type(t) {
+	if (type == LITERAL) {
+		throw runtime_error("cannot create script literal without literal");
+	}
+}
+
+ScriptToken::ScriptToken(Literal *l)
+: literal(l)
+, str()
+, type(LITERAL) {
+	if (!literal) {
+		throw runtime_error("cannot create script literal without literal");
+	}
+}
+
+ScriptToken::~ScriptToken() {
+	delete literal;
+}
+
+const string &ScriptToken::RegisterName() const {
+	if (type == REGISTER) {
+		return str;
+	} else {
+		throw runtime_error("access to register name of non-register script token");
+	}
+}
+
+const string &ScriptToken::CommandName() const {
+	if (type == COMMAND) {
+		return str;
+	} else {
+		throw runtime_error("access to command name of non-command script token");
+	}
+}
+
+const string &ScriptToken::GetIdentifier() const {
+	if (type == IDENTIFIER) {
+		return str;
+	} else {
+		throw runtime_error("access to identifier of non-identifier script token");
+	}
+}
+
+const Literal *ScriptToken::GetLiteral() const {
+	if (type == LITERAL) {
+		return literal;
+	} else {
+		throw runtime_error("access to literal value of non-literal script token");
+	}
+}
+
 }
 
 
@@ -477,6 +555,9 @@ ostream &operator <<(ostream &out, const loader::Literal &l) {
 		case loader::Literal::OBJECT:
 			out << "object of type " << l.GetTypeName();
 			break;
+		case loader::Literal::SCRIPT:
+			out << "script";
+			break;
 	}
 	return out;
 }
diff --git a/src/loader/ParsedSource.h b/src/loader/ParsedSource.h
index 64baaaa..9ba5297 100644
--- a/src/loader/ParsedSource.h
+++ b/src/loader/ParsedSource.h
@@ -18,6 +18,38 @@
 
 namespace loader {
 
+class ScriptToken {
+
+public:
+	enum Type {
+		COMMAND,
+		REGISTER,
+		IDENTIFIER,
+		LITERAL,
+	};
+
+	ScriptToken(const std::string &, Type);
+	explicit ScriptToken(Literal *);
+	~ScriptToken();
+private:
+	ScriptToken(const ScriptToken &);
+	ScriptToken &operator =(const ScriptToken &);
+
+public:
+	Type GetType() const { return type; }
+	const std::string &RegisterName() const;
+	const std::string &CommandName() const;
+	const std::string &GetIdentifier() const;
+	const Literal *GetLiteral() const;
+
+private:
+	Literal *literal;
+	std::string str;
+	Type type;
+
+};
+
+
 class Literal {
 
 public:
@@ -30,7 +62,8 @@ public:
 		PATH,
 		STRING,
 		VECTOR,
-		OBJECT
+		OBJECT,
+		SCRIPT,
 	};
 
 public:
@@ -43,6 +76,7 @@ public:
 	Literal(const std::string &);
 	Literal(int x, int y);
 	Literal(const std::string &typeName, PropertyList *properties);
+	explicit Literal(const std::vector<ScriptToken *> &);
 	~Literal();
 private:
 	Literal(const Literal &);
@@ -67,12 +101,14 @@ public:
 	int GetY() const;
 	const std::string &GetTypeName() const;
 	const PropertyList *GetProperties() const;
+	const std::vector<ScriptToken *> &GetScript() const;
 
 private:
 	PropertyList *props;
 	std::string typeName, str;
 	std::vector<Value *> values;
 	std::vector<PropertyList *> propertyLists;
+	std::vector<ScriptToken *> script;
 	int i1, i2, i3, i4;
 	bool b;
 	Type type;
diff --git a/src/loader/Parser.cpp b/src/loader/Parser.cpp
index 183accb..52585c4 100644
--- a/src/loader/Parser.cpp
+++ b/src/loader/Parser.cpp
@@ -112,6 +112,7 @@ bool Parser::BeginningOfLiteral(const Tokenizer::Token &t) const {
 		case Tokenizer::Token::BRACKET_OPEN:
 		case Tokenizer::Token::PARENTHESIS_OPEN:
 		case Tokenizer::Token::NUMBER:
+		case Tokenizer::Token::SCRIPT_BEGIN:
 		case Tokenizer::Token::STRING:
 		case Tokenizer::Token::KEYWORD_FALSE:
 		case Tokenizer::Token::KEYWORD_TRUE:
@@ -142,6 +143,10 @@ bool Parser::BeginOfPropertyList(const Tokenizer::Token &t) const {
 	return t.type == Tokenizer::Token::ANGLE_BRACKET_OPEN;
 }
 
+bool Parser::BeginningOfScriptLiteral(const Tokenizer::Token &t) const {
+	return t.type == Tokenizer::Token::SCRIPT_BEGIN;
+}
+
 Definition *Parser::ParseDefinition() {
 	string typeName(ParseTypeName());
 	string identifier(ParseIdentifier());
@@ -218,7 +223,10 @@ Literal *Parser::ParseLiteral() {
 	if (t.type == Tokenizer::Token::TYPE_NAME) {
 		PropertyList *props(ParsePropertyList());
 		return new Literal(t.str, props);
-	} else if (BeginningOfLiteral(t)) {
+	} else if (BeginningOfScriptLiteral(t)) {
+		tok.Putback(t);
+		return ParseScript();
+	} else if (BeginningOfPrimitiveLiteral(t)) {
 		switch (t.type) {
 			case Tokenizer::Token::CHEVRON_OPEN:
 				tok.Putback(t);
@@ -340,6 +348,51 @@ Literal *Parser::ParseVector() {
 	return new Literal(x.number, y.number);
 }
 
+Literal *Parser::ParseScript() {
+	std::string msg("error parsing script");
+	Tokenizer::Token t(GetToken());
+	AssertTokenType(t.type, Tokenizer::Token::SCRIPT_BEGIN, msg);
+
+	vector<ScriptToken *> script;
+	try {
+		while (t.type != Tokenizer::Token::SCRIPT_END) {
+			if (BeginningOfPrimitiveLiteral(t)) {
+				tok.Putback(t);
+				script.push_back(new ScriptToken(ParseLiteral()));
+			} else {
+				switch (t.type) {
+					case Tokenizer::Token::COMMAND: {
+						Tokenizer::Token t2(GetToken());
+						AssertTokenType(t.type, Tokenizer::Token::IDENTIFIER, msg);
+						script.push_back(new ScriptToken(t2.str, ScriptToken::COMMAND));
+						break;
+					}
+					case Tokenizer::Token::IDENTIFIER: {
+						script.push_back(new ScriptToken(t.str, ScriptToken::IDENTIFIER));
+						break;
+					}
+					case Tokenizer::Token::REGISTER: {
+						Tokenizer::Token t2(GetToken());
+						AssertTokenType(t.type, Tokenizer::Token::IDENTIFIER, msg);
+						script.push_back(new ScriptToken(t2.str, ScriptToken::REGISTER));
+						break;
+					}
+					default:
+						throw Error(file, tok.Line(), string("unexpected token in script: ") + TokenTypeToString(t.type));
+				}
+			}
+			t = GetToken();
+		}
+	} catch (...) {
+		for (vector<ScriptToken *>::const_iterator i(script.begin()), end(script.end()); i != end; ++i) {
+			delete *i;
+		}
+		throw;
+	}
+	return new Literal(script);
+}
+
+
 void Parser::AssertTokenType(Tokenizer::Token::Type actual, Tokenizer::Token::Type expected) {
 	if (expected != actual) {
 		throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(actual) + ", expected " + TokenTypeToString(expected));
diff --git a/src/loader/Parser.h b/src/loader/Parser.h
index 392e9b7..963c377 100644
--- a/src/loader/Parser.h
+++ b/src/loader/Parser.h
@@ -62,6 +62,7 @@ private:
 	Literal *ParseArray();
 	Literal *ParseColor();
 	Literal *ParseVector();
+	Literal *ParseScript();
 
 private:
 	void AssertTokenType(Tokenizer::Token::Type actual, Tokenizer::Token::Type expected);
@@ -69,6 +70,7 @@ private:
 	bool BeginningOfLiteral(const Tokenizer::Token &) const;
 	bool BeginningOfPrimitiveLiteral(const Tokenizer::Token &) const;
 	bool BeginOfPropertyList(const Tokenizer::Token &) const;
+	bool BeginningOfScriptLiteral(const Tokenizer::Token &) const;
 
 private:
 	std::string file;
diff --git a/src/loader/fwd.h b/src/loader/fwd.h
index 2f90849..b8b8458 100644
--- a/src/loader/fwd.h
+++ b/src/loader/fwd.h
@@ -20,6 +20,7 @@ class PagedAllocator;
 class ParsedSource;
 class Parser;
 class PropertyList;
+class ScriptToken;
 class Tokenizer;
 class TypeDescription;
 class Value;
-- 
2.39.2


From fa339aa45524243e716fd234a09c929d0eec95f8 Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Sun, 14 Oct 2012 15:34:33 +0200
Subject: [PATCH 04/16] less verbose token code in parser

---
 src/loader/Parser.cpp | 206 +++++++++++++++++++++---------------------
 1 file changed, 104 insertions(+), 102 deletions(-)

diff --git a/src/loader/Parser.cpp b/src/loader/Parser.cpp
index 52585c4..8ba3704 100644
--- a/src/loader/Parser.cpp
+++ b/src/loader/Parser.cpp
@@ -17,6 +17,8 @@ using std::ifstream;
 using std::string;
 using std::vector;
 
+typedef loader::Tokenizer::Token Token;
+
 namespace loader {
 
 Parser::Parser(const string &file, ParsedSource &product)
@@ -37,15 +39,15 @@ void Parser::Parse() {
 }
 
 void Parser::ParseStatement() {
-	Tokenizer::Token t(GetToken());
+	Token t(GetToken());
 	switch (t.type) {
-		case Tokenizer::Token::KEYWORD_EXPORT:
+		case Token::KEYWORD_EXPORT:
 			ParseExportDirective();
 			break;
-		case Tokenizer::Token::KEYWORD_INCLUDE:
+		case Token::KEYWORD_INCLUDE:
 			ParseIncludeDirective();
 			break;
-		case Tokenizer::Token::TYPE_NAME:
+		case Token::TYPE_NAME:
 			tok.Putback(t);
 			{
 				Declaration *decl(ProbeDefinition());
@@ -57,15 +59,15 @@ void Parser::ParseStatement() {
 	}
 }
 
-Tokenizer::Token Parser::GetToken() try {
+Token Parser::GetToken() try {
 	return tok.GetNext();
 } catch (Tokenizer::LexerError &e) {
 	throw Error(file, e.Line(), e.what());
 }
 
 void Parser::ParseExportDirective() {
-	Tokenizer::Token t(GetToken());
-	if (t.type != Tokenizer::Token::IDENTIFIER) {
+	Token t(GetToken());
+	if (t.type != Token::IDENTIFIER) {
 		tok.Putback(t);
 		Declaration *decl(ProbeDefinition());
 		product.ExportDeclaration(decl);
@@ -75,8 +77,8 @@ void Parser::ParseExportDirective() {
 }
 
 void Parser::ParseIncludeDirective() {
-	Tokenizer::Token t(GetToken());
-	AssertTokenType(t.type, Tokenizer::Token::STRING);
+	Token t(GetToken());
+	AssertTokenType(t.type, Token::STRING);
 	Parser sub(CatPath(dirname, t.str), product);
 	sub.Parse();
 }
@@ -86,7 +88,7 @@ Declaration *Parser::ProbeDefinition() {
 	string identifier(ParseIdentifier());
 
 	if (tok.HasMore()) {
-		Tokenizer::Token t(GetToken());
+		Token t(GetToken());
 		tok.Putback(t);
 		if (BeginOfPropertyList(t)) {
 			auto_ptr<PropertyList> propertyList(ParsePropertyList());
@@ -105,53 +107,53 @@ Declaration *Parser::ProbeDefinition() {
 	return new Declaration(typeName, identifier);
 }
 
-bool Parser::BeginningOfLiteral(const Tokenizer::Token &t) const {
+bool Parser::BeginningOfLiteral(const Token &t) const {
 	switch (t.type) {
-		case Tokenizer::Token::CHEVRON_OPEN:
-		case Tokenizer::Token::COLON:
-		case Tokenizer::Token::BRACKET_OPEN:
-		case Tokenizer::Token::PARENTHESIS_OPEN:
-		case Tokenizer::Token::NUMBER:
-		case Tokenizer::Token::SCRIPT_BEGIN:
-		case Tokenizer::Token::STRING:
-		case Tokenizer::Token::KEYWORD_FALSE:
-		case Tokenizer::Token::KEYWORD_TRUE:
-		case Tokenizer::Token::TYPE_NAME:
+		case Token::CHEVRON_OPEN:
+		case Token::COLON:
+		case Token::BRACKET_OPEN:
+		case Token::PARENTHESIS_OPEN:
+		case Token::NUMBER:
+		case Token::SCRIPT_BEGIN:
+		case Token::STRING:
+		case Token::KEYWORD_FALSE:
+		case Token::KEYWORD_TRUE:
+		case Token::TYPE_NAME:
 			return true;
 		default:
 			return false;
 	}
 }
 
-bool Parser::BeginningOfPrimitiveLiteral(const Tokenizer::Token &t) const {
+bool Parser::BeginningOfPrimitiveLiteral(const Token &t) const {
 	switch (t.type) {
-		case Tokenizer::Token::CHEVRON_OPEN:
-		case Tokenizer::Token::COLON:
-		case Tokenizer::Token::BRACKET_OPEN:
-		case Tokenizer::Token::PARENTHESIS_OPEN:
-		case Tokenizer::Token::NUMBER:
-		case Tokenizer::Token::STRING:
-		case Tokenizer::Token::KEYWORD_FALSE:
-		case Tokenizer::Token::KEYWORD_TRUE:
+		case Token::CHEVRON_OPEN:
+		case Token::COLON:
+		case Token::BRACKET_OPEN:
+		case Token::PARENTHESIS_OPEN:
+		case Token::NUMBER:
+		case Token::STRING:
+		case Token::KEYWORD_FALSE:
+		case Token::KEYWORD_TRUE:
 			return true;
 		default:
 			return false;
 	}
 }
 
-bool Parser::BeginOfPropertyList(const Tokenizer::Token &t) const {
-	return t.type == Tokenizer::Token::ANGLE_BRACKET_OPEN;
+bool Parser::BeginOfPropertyList(const Token &t) const {
+	return t.type == Token::ANGLE_BRACKET_OPEN;
 }
 
-bool Parser::BeginningOfScriptLiteral(const Tokenizer::Token &t) const {
-	return t.type == Tokenizer::Token::SCRIPT_BEGIN;
+bool Parser::BeginningOfScriptLiteral(const Token &t) const {
+	return t.type == Token::SCRIPT_BEGIN;
 }
 
 Definition *Parser::ParseDefinition() {
 	string typeName(ParseTypeName());
 	string identifier(ParseIdentifier());
 
-	Tokenizer::Token t(GetToken());
+	Token t(GetToken());
 	tok.Putback(t);
 	if (BeginOfPropertyList(t)) {
 		PropertyList *propertyList(ParsePropertyList());
@@ -169,35 +171,35 @@ Definition *Parser::ParseDefinition() {
 }
 
 string Parser::ParseIdentifier() {
-	Tokenizer::Token t(GetToken());
-	AssertTokenType(t.type, Tokenizer::Token::IDENTIFIER);
+	Token t(GetToken());
+	AssertTokenType(t.type, Token::IDENTIFIER);
 	return t.str;
 }
 
 string Parser::ParseTypeName() {
-	Tokenizer::Token t(GetToken());
-	AssertTokenType(t.type, Tokenizer::Token::TYPE_NAME);
+	Token t(GetToken());
+	AssertTokenType(t.type, Token::TYPE_NAME);
 	return t.str;
 }
 
 PropertyList *Parser::ParsePropertyList() {
-	Tokenizer::Token t(GetToken());
-	AssertTokenType(t.type, Tokenizer::Token::ANGLE_BRACKET_OPEN);
+	Token t(GetToken());
+	AssertTokenType(t.type, Token::ANGLE_BRACKET_OPEN);
 
 	auto_ptr<PropertyList> props(new PropertyList);
 
-	while (t.type != Tokenizer::Token::ANGLE_BRACKET_CLOSE) {
-		Tokenizer::Token name(GetToken());
-		AssertTokenType(name.type, Tokenizer::Token::IDENTIFIER);
+	while (t.type != Token::ANGLE_BRACKET_CLOSE) {
+		Token name(GetToken());
+		AssertTokenType(name.type, Token::IDENTIFIER);
 
 		t = GetToken();
-		AssertTokenType(t.type, Tokenizer::Token::COLON);
+		AssertTokenType(t.type, Token::COLON);
 
 		Value *value(ParseValue());
 		props->SetProperty(name.str, value);
 
 		t = GetToken();
-		if (t.type != Tokenizer::Token::ANGLE_BRACKET_CLOSE && t.type != Tokenizer::Token::COMMA) {
+		if (t.type != Token::ANGLE_BRACKET_CLOSE && t.type != Token::COMMA) {
 			throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type) + ", expected , or }");
 		}
 	}
@@ -206,8 +208,8 @@ PropertyList *Parser::ParsePropertyList() {
 }
 
 Value *Parser::ParseValue() {
-	Tokenizer::Token t(GetToken());
-	if (t.type == Tokenizer::Token::IDENTIFIER) {
+	Token t(GetToken());
+	if (t.type == Token::IDENTIFIER) {
 		return new Value(t.str);
 	} else if (BeginningOfLiteral(t)) {
 		tok.Putback(t);
@@ -219,8 +221,8 @@ Value *Parser::ParseValue() {
 }
 
 Literal *Parser::ParseLiteral() {
-	Tokenizer::Token t(GetToken());
-	if (t.type == Tokenizer::Token::TYPE_NAME) {
+	Token t(GetToken());
+	if (t.type == Token::TYPE_NAME) {
 		PropertyList *props(ParsePropertyList());
 		return new Literal(t.str, props);
 	} else if (BeginningOfScriptLiteral(t)) {
@@ -228,26 +230,26 @@ Literal *Parser::ParseLiteral() {
 		return ParseScript();
 	} else if (BeginningOfPrimitiveLiteral(t)) {
 		switch (t.type) {
-			case Tokenizer::Token::CHEVRON_OPEN:
+			case Token::CHEVRON_OPEN:
 				tok.Putback(t);
 				return ParseVector();
-			case Tokenizer::Token::COLON:
+			case Token::COLON:
 				t = GetToken();
-				AssertTokenType(t.type, Tokenizer::Token::STRING);
+				AssertTokenType(t.type, Token::STRING);
 				return new Literal(dirname, t.str);
-			case Tokenizer::Token::BRACKET_OPEN:
+			case Token::BRACKET_OPEN:
 				tok.Putback(t);
 				return ParseArray();
-			case Tokenizer::Token::PARENTHESIS_OPEN:
+			case Token::PARENTHESIS_OPEN:
 				tok.Putback(t);
 				return ParseColor();
-			case Tokenizer::Token::NUMBER:
+			case Token::NUMBER:
 				return new Literal(t.number);
-			case Tokenizer::Token::STRING:
+			case Token::STRING:
 				return new Literal(t.str);
-			case Tokenizer::Token::KEYWORD_FALSE:
+			case Token::KEYWORD_FALSE:
 				return new Literal(false);
-			case Tokenizer::Token::KEYWORD_TRUE:
+			case Token::KEYWORD_TRUE:
 				return new Literal(true);
 			default:
 				throw std::logic_error("literal switch reached impossible default branch oO");
@@ -258,19 +260,19 @@ Literal *Parser::ParseLiteral() {
 }
 
 Literal *Parser::ParseArray() {
-	Tokenizer::Token t(GetToken());
-	AssertTokenType(t.type, Tokenizer::Token::BRACKET_OPEN);
+	Token t(GetToken());
+	AssertTokenType(t.type, Token::BRACKET_OPEN);
 
-	Tokenizer::Token probe(GetToken());
+	Token probe(GetToken());
 
-	if (probe.type == Tokenizer::Token::TYPE_NAME) {
+	if (probe.type == Token::TYPE_NAME) {
 		vector<PropertyList *> values;
-		while (t.type != Tokenizer::Token::BRACKET_CLOSE) {
+		while (t.type != Token::BRACKET_CLOSE) {
 			PropertyList *value(ParsePropertyList());
 			values.push_back(value);
 
 			t = GetToken();
-			if (t.type != Tokenizer::Token::BRACKET_CLOSE && t.type != Tokenizer::Token::COMMA) {
+			if (t.type != Token::BRACKET_CLOSE && t.type != Token::COMMA) {
 				throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type) + ", expected , or ]");
 			}
 		}
@@ -279,12 +281,12 @@ Literal *Parser::ParseArray() {
 		tok.Putback(probe);
 
 		vector<Value *> values;
-		while (t.type != Tokenizer::Token::BRACKET_CLOSE) {
+		while (t.type != Token::BRACKET_CLOSE) {
 			Value *value(ParseValue());
 			values.push_back(value);
 
 			t = GetToken();
-			if (t.type != Tokenizer::Token::BRACKET_CLOSE && t.type != Tokenizer::Token::COMMA) {
+			if (t.type != Token::BRACKET_CLOSE && t.type != Token::COMMA) {
 				throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(t.type) + ", expected , or ]");
 			}
 		}
@@ -294,33 +296,33 @@ Literal *Parser::ParseArray() {
 
 Literal *Parser::ParseColor() {
 	string msg("error parsing color");
-	Tokenizer::Token t(GetToken());
-	AssertTokenType(t.type, Tokenizer::Token::PARENTHESIS_OPEN, msg);
+	Token t(GetToken());
+	AssertTokenType(t.type, Token::PARENTHESIS_OPEN, msg);
 
-	Tokenizer::Token red(GetToken());
-	AssertTokenType(red.type, Tokenizer::Token::NUMBER, "error parsing red component of color");
+	Token red(GetToken());
+	AssertTokenType(red.type, Token::NUMBER, "error parsing red component of color");
 
 	t = GetToken();
-	AssertTokenType(t.type, Tokenizer::Token::COMMA, msg);
+	AssertTokenType(t.type, Token::COMMA, msg);
 
-	Tokenizer::Token green(GetToken());
-	AssertTokenType(green.type, Tokenizer::Token::NUMBER, "error parsing green component of color");
+	Token green(GetToken());
+	AssertTokenType(green.type, Token::NUMBER, "error parsing green component of color");
 
 	t = GetToken();
-	AssertTokenType(t.type, Tokenizer::Token::COMMA, msg);
+	AssertTokenType(t.type, Token::COMMA, msg);
 
-	Tokenizer::Token blue(GetToken());
-	AssertTokenType(blue.type, Tokenizer::Token::NUMBER, "error parsing blue component of color");
+	Token blue(GetToken());
+	AssertTokenType(blue.type, Token::NUMBER, "error parsing blue component of color");
 
 	t = GetToken();
-	if (t.type == Tokenizer::Token::PARENTHESIS_CLOSE) {
+	if (t.type == Token::PARENTHESIS_CLOSE) {
 		return new Literal(red.number, green.number, blue.number);
-	} else if (t.type != Tokenizer::Token::COMMA) {
-		Tokenizer::Token alpha(GetToken());
-		AssertTokenType(alpha.type, Tokenizer::Token::NUMBER, "error parsing alpha component of color");
+	} else if (t.type != Token::COMMA) {
+		Token alpha(GetToken());
+		AssertTokenType(alpha.type, Token::NUMBER, "error parsing alpha component of color");
 
 		t = GetToken();
-		AssertTokenType(t.type, Tokenizer::Token::PARENTHESIS_CLOSE, msg);
+		AssertTokenType(t.type, Token::PARENTHESIS_CLOSE, msg);
 
 		return new Literal(red.number, green.number, blue.number, alpha.number);
 	} else {
@@ -330,50 +332,50 @@ Literal *Parser::ParseColor() {
 
 Literal *Parser::ParseVector() {
 	std::string msg("error parsing vector");
-	Tokenizer::Token t(GetToken());
-	AssertTokenType(t.type, Tokenizer::Token::CHEVRON_OPEN, msg);
+	Token t(GetToken());
+	AssertTokenType(t.type, Token::CHEVRON_OPEN, msg);
 
-	Tokenizer::Token x(GetToken());
-	AssertTokenType(x.type, Tokenizer::Token::NUMBER, "error parsing x component of vector");
+	Token x(GetToken());
+	AssertTokenType(x.type, Token::NUMBER, "error parsing x component of vector");
 
 	t = GetToken();
-	AssertTokenType(t.type, Tokenizer::Token::COMMA, msg);
+	AssertTokenType(t.type, Token::COMMA, msg);
 
-	Tokenizer::Token y(GetToken());
-	AssertTokenType(y.type, Tokenizer::Token::NUMBER, "error parsing y component of vector");
+	Token y(GetToken());
+	AssertTokenType(y.type, Token::NUMBER, "error parsing y component of vector");
 
 	t = GetToken();
-	AssertTokenType(t.type, Tokenizer::Token::CHEVRON_CLOSE, msg);
+	AssertTokenType(t.type, Token::CHEVRON_CLOSE, msg);
 
 	return new Literal(x.number, y.number);
 }
 
 Literal *Parser::ParseScript() {
 	std::string msg("error parsing script");
-	Tokenizer::Token t(GetToken());
-	AssertTokenType(t.type, Tokenizer::Token::SCRIPT_BEGIN, msg);
+	Token t(GetToken());
+	AssertTokenType(t.type, Token::SCRIPT_BEGIN, msg);
 
 	vector<ScriptToken *> script;
 	try {
-		while (t.type != Tokenizer::Token::SCRIPT_END) {
+		while (t.type != Token::SCRIPT_END) {
 			if (BeginningOfPrimitiveLiteral(t)) {
 				tok.Putback(t);
 				script.push_back(new ScriptToken(ParseLiteral()));
 			} else {
 				switch (t.type) {
-					case Tokenizer::Token::COMMAND: {
-						Tokenizer::Token t2(GetToken());
-						AssertTokenType(t.type, Tokenizer::Token::IDENTIFIER, msg);
+					case Token::COMMAND: {
+						Token t2(GetToken());
+						AssertTokenType(t.type, Token::IDENTIFIER, msg);
 						script.push_back(new ScriptToken(t2.str, ScriptToken::COMMAND));
 						break;
 					}
-					case Tokenizer::Token::IDENTIFIER: {
+					case Token::IDENTIFIER: {
 						script.push_back(new ScriptToken(t.str, ScriptToken::IDENTIFIER));
 						break;
 					}
-					case Tokenizer::Token::REGISTER: {
-						Tokenizer::Token t2(GetToken());
-						AssertTokenType(t.type, Tokenizer::Token::IDENTIFIER, msg);
+					case Token::REGISTER: {
+						Token t2(GetToken());
+						AssertTokenType(t.type, Token::IDENTIFIER, msg);
 						script.push_back(new ScriptToken(t2.str, ScriptToken::REGISTER));
 						break;
 					}
@@ -393,13 +395,13 @@ Literal *Parser::ParseScript() {
 }
 
 
-void Parser::AssertTokenType(Tokenizer::Token::Type actual, Tokenizer::Token::Type expected) {
+void Parser::AssertTokenType(Token::Type actual, Token::Type expected) {
 	if (expected != actual) {
 		throw Error(file, tok.Line(), string("unexpected token ") + TokenTypeToString(actual) + ", expected " + TokenTypeToString(expected));
 	}
 }
 
-void Parser::AssertTokenType(Tokenizer::Token::Type actual, Tokenizer::Token::Type expected, const string &msg) {
+void Parser::AssertTokenType(Token::Type actual, Token::Type expected, const string &msg) {
 	if (expected != actual) {
 		throw Error(file, tok.Line(), msg + ": unexpected token " + TokenTypeToString(actual) + ", expected " + TokenTypeToString(expected));
 	}
-- 
2.39.2


From 77915e0186f4fc0788054eb34651c726b80d981c Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Sun, 14 Oct 2012 17:06:33 +0200
Subject: [PATCH 05/16] added script assembler

---
 src/loader/Interpreter.cpp | 260 ++++++++++++++++++++++++++++++++++++-
 src/loader/Interpreter.h   |   5 +
 2 files changed, 263 insertions(+), 2 deletions(-)

diff --git a/src/loader/Interpreter.cpp b/src/loader/Interpreter.cpp
index 8b9b56a..c2ce0d4 100644
--- a/src/loader/Interpreter.cpp
+++ b/src/loader/Interpreter.cpp
@@ -14,6 +14,7 @@
 #include "../battle/Resources.h"
 #include "../common/Ikari.h"
 #include "../common/Item.h"
+#include "../common/Script.h"
 #include "../common/Spell.h"
 #include "../common/Stats.h"
 #include "../common/TargetingMode.h"
@@ -34,6 +35,7 @@ using battle::Monster;
 using battle::PartyLayout;
 using common::Ikari;
 using common::Item;
+using common::Script;
 using common::Spell;
 using common::Stats;
 using common::TargetingMode;
@@ -143,7 +145,9 @@ void Interpreter::ReadLiteral(int typeId, int id, char *object, const Literal &l
 			object[literal.GetString().size()] = '\0';
 			break;
 		case Literal::SCRIPT:
-			throw Error("script compiler not implemented");
+			new (object) Script;
+			ReadScript(literal.GetScript(), reinterpret_cast<Script *>(object));
+			break;
 		case Literal::STRING:
 			std::memcpy(object, literal.GetString().c_str(), literal.GetString().size());
 			object[literal.GetString().size()] = '\0';
@@ -215,7 +219,12 @@ void *Interpreter::GetObject(int typeId, const Value &v) {
 					}
 					break;
 				case Literal::SCRIPT:
-					throw Error("script compiler not implemented");
+					{
+						typeId = TypeDescription::GetTypeId("Script");
+						id = values[typeId].size();
+						values[typeId].push_back(ReadScript(v.GetLiteral().GetScript()));
+					}
+					break;
 				case Literal::STRING:
 					{
 						typeId = TypeDescription::GetTypeId("String");
@@ -324,6 +333,248 @@ void Interpreter::ReadObject(int typeId, int id, char *object, const PropertyLis
 }
 
 
+void Interpreter::ReadScript(const std::vector<ScriptToken *> &s, Script *script) {
+	int size(0);
+	for (vector<ScriptToken *>::const_iterator i(s.begin()), end(s.end()); i != end; ++i) {
+		if ((*i)->GetType() != ScriptToken::COMMAND) {
+			throw Error("unexpected script token");
+		}
+		++size;
+		const string &cmd((*i)->CommandName());
+		if (cmd == "move") {
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after move");
+			}
+			const string &reg((*i)->RegisterName());
+			switch (reg[0]) {
+				case 'a':
+					size += sizeof(void *);
+					break;
+				case 'i':
+					size += sizeof(int);
+					break;
+				case 'v':
+					size += sizeof(Vector<int>);
+					break;
+				default:
+					throw Error("unknown register " + reg);
+			}
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after move");
+			}
+		} else if (cmd == "add") {
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after add");
+			}
+			const string &reg((*i)->RegisterName());
+			switch (reg[0]) {
+				case 'i':
+					size += sizeof(int);
+					break;
+				case 'v':
+					size += sizeof(Vector<int>);
+					break;
+				default:
+					throw Error("expected register after add " + reg);
+			}
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after add");
+			}
+		} else if (cmd == "mod") {
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after mod");
+			}
+			size += sizeof(int);
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after mod");
+			}
+		} else if (cmd == "rand") {
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after rand");
+			}
+			size += sizeof(int);
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after rand");
+			}
+		} else if (cmd == "sysc") {
+
+		} else {
+			throw Error("unknown command " + cmd);
+		}
+	}
+
+	unsigned char *text(reinterpret_cast<unsigned char *>(alloc.Alloc(size)));
+	int cursor(0);
+	for (vector<ScriptToken *>::const_iterator i(s.begin()), end(s.end()); i != end; ++i) {
+		if ((*i)->GetType() != ScriptToken::COMMAND) {
+			throw Error("unexpected script token");
+		}
+		const string &cmd((*i)->CommandName());
+		if (cmd == "move") {
+			++i;
+			const string &reg((*i)->RegisterName());
+			++i;
+			if (reg == "a0") {
+				text[cursor] = Script::CODE_MOVE_A0;
+				++cursor;
+				ReadScriptAddress(**i, text + cursor);
+				cursor += sizeof(void *);
+			} else if (reg == "a1") {
+				text[cursor] = Script::CODE_MOVE_A1;
+				++cursor;
+				ReadScriptAddress(**i, text + cursor);
+				cursor += sizeof(void *);
+			} else if (reg == "i0") {
+				text[cursor] = Script::CODE_MOVE_I0;
+				++cursor;
+				ReadScriptInteger(**i, text + cursor);
+				cursor += sizeof(int);
+			} else if (reg == "i1") {
+				text[cursor] = Script::CODE_MOVE_I1;
+				++cursor;
+				ReadScriptInteger(**i, text + cursor);
+				cursor += sizeof(int);
+			} else if (reg == "v0") {
+				text[cursor] = Script::CODE_MOVE_V0;
+				++cursor;
+				ReadScriptVector(**i, text + cursor);
+				cursor += sizeof(Vector<int>);
+			} else if (reg == "v1") {
+				text[cursor] = Script::CODE_MOVE_V1;
+				++cursor;
+				ReadScriptVector(**i, text + cursor);
+				cursor += sizeof(Vector<int>);
+			} else {
+				throw Error("unknown register " + reg);
+			}
+		} else if (cmd == "add") {
+			++i;
+			const string &reg((*i)->RegisterName());
+			++i;
+			if (reg == "i0") {
+				text[cursor] = Script::CODE_ADD_I0;
+				++cursor;
+				ReadScriptInteger(**i, text + cursor);
+				cursor += sizeof(int);
+			} else if (reg == "i1") {
+				text[cursor] = Script::CODE_ADD_I1;
+				++cursor;
+				ReadScriptInteger(**i, text + cursor);
+				cursor += sizeof(int);
+			} else if (reg == "v0") {
+				text[cursor] = Script::CODE_ADD_V0;
+				++cursor;
+				ReadScriptVector(**i, text + cursor);
+				cursor += sizeof(Vector<int>);
+			} else if (reg == "v1") {
+				text[cursor] = Script::CODE_ADD_V1;
+				++cursor;
+				ReadScriptVector(**i, text + cursor);
+				cursor += sizeof(Vector<int>);
+			} else {
+				throw Error("unexpected register " + reg);
+			}
+		} else if (cmd == "mod") {
+			++i;
+			const string &reg((*i)->RegisterName());
+			++i;
+			if (reg == "i0") {
+				text[cursor] = Script::CODE_MOD_I0;
+				++cursor;
+				ReadScriptInteger(**i, text + cursor);
+				cursor += sizeof(int);
+			} else if (reg == "i1") {
+				text[cursor] = Script::CODE_MOD_I1;
+				++cursor;
+				ReadScriptInteger(**i, text + cursor);
+				cursor += sizeof(int);
+			} else {
+				throw Error("unexpected register " + reg);
+			}
+		} else if (cmd == "rand") {
+			++i;
+			const string &reg((*i)->RegisterName());
+			if (reg == "i0") {
+				text[cursor] = Script::CODE_RAND_I0;
+				++cursor;
+			} else if (reg == "i1") {
+				text[cursor] = Script::CODE_RAND_I1;
+				++cursor;
+			} else {
+				throw Error("unexpected register " + reg);
+			}
+		} else if (cmd == "sysc") {
+			text[cursor] = Script::CODE_SYSCALL;
+			++cursor;
+		} else {
+			throw Error("unknown command " + cmd);
+		}
+	}
+
+	script->text = text;
+	script->textlen = size;
+}
+
+char *Interpreter::ReadScript(const vector<ScriptToken *> &s) {
+	char *mem(alloc.Alloc(sizeof(Script)));
+	new (mem) Script;
+	Script *script(reinterpret_cast<Script *>(mem));
+	ReadScript(s, script);
+	return mem;
+}
+
+void Interpreter::ReadScriptAddress(const ScriptToken &t, unsigned char *dest) {
+	if (t.GetType() != ScriptToken::IDENTIFIER) {
+		throw Error("expected identifier for address");
+	}
+	if (source.IsDefined(t.GetIdentifier())) {
+		const ParsedDefinition &def(GetDefinition(t.GetIdentifier()));
+		void *addr(GetObject(def.type, t.GetIdentifier()));
+		*reinterpret_cast<void **>(dest) = addr;
+	} else {
+		throw Error("postponing values in scripts not implemented");
+	}
+}
+
+void Interpreter::ReadScriptInteger(const ScriptToken &t, unsigned char *dest) {
+	if (t.GetType() == ScriptToken::IDENTIFIER) {
+		if (source.IsDefined(t.GetIdentifier())) {
+			void *num(GetObject(TypeDescription::GetTypeId("Number"), t.GetIdentifier()));
+			*reinterpret_cast<int *>(dest) = *reinterpret_cast<int *>(num);
+		} else {
+			throw Error("postponing values in scripts not implemented");
+		}
+	} else if (t.GetType() == ScriptToken::LITERAL) {
+		*reinterpret_cast<int *>(dest) = t.GetLiteral()->GetNumber();
+	} else {
+		throw Error("expected identifier or integer literal");
+	}
+}
+
+void Interpreter::ReadScriptVector(const ScriptToken &t, unsigned char *dest) {
+	if (t.GetType() == ScriptToken::IDENTIFIER) {
+		if (source.IsDefined(t.GetIdentifier())) {
+			void *vec(GetObject(TypeDescription::GetTypeId("Vector"), t.GetIdentifier()));
+			*reinterpret_cast<Vector<int> *>(dest) = *reinterpret_cast<Vector<int> *>(vec);
+		} else {
+			throw Error("postponing values in scripts not implemented");
+		}
+	} else if (t.GetType() == ScriptToken::LITERAL) {
+		*reinterpret_cast<Vector<int> *>(dest) = Vector<int>(t.GetLiteral()->GetX(), t.GetLiteral()->GetY());
+	} else {
+		throw Error("expected identifier or vector literal");
+	}
+}
+
+
 SDL_Surface *Interpreter::GetImage(const string &path) {
 	std::map<string, SDL_Surface *>::const_iterator result(imageCache.find(path));
 	if (result != imageCache.end()) {
@@ -379,6 +630,11 @@ void Interpreter::CreateTypeDescriptions() {
 		td.SetSize(1);
 		td.AddSupertype(stringId, 0);
 	}
+	{
+		TypeDescription &td(TypeDescription::CreateOrGet("Script"));
+		td.SetDescription("Collection of commands that define a behaviour.");
+		td.SetSize(sizeof(Script));
+	}
 	{
 		TypeDescription &td(TypeDescription::CreateOrGet("String"));
 		td.SetDescription("Some characters.");
diff --git a/src/loader/Interpreter.h b/src/loader/Interpreter.h
index 15cebd5..5fbded6 100644
--- a/src/loader/Interpreter.h
+++ b/src/loader/Interpreter.h
@@ -80,6 +80,11 @@ private:
 	void ReadLiteral(int typeId, int id, char *dest, const Literal &);
 	void *GetObject(int typeId, const Value &value);
 	void ReadObject(int typeId, int id, char *dest, const PropertyList &);
+	void ReadScript(const std::vector<ScriptToken *> &, common::Script *);
+	char *ReadScript(const std::vector<ScriptToken *> &);
+	void ReadScriptAddress(const ScriptToken &t, unsigned char *dest);
+	void ReadScriptInteger(const ScriptToken &t, unsigned char *dest);
+	void ReadScriptVector(const ScriptToken &t, unsigned char *dest);
 
 	SDL_Surface *GetImage(const std::string &);
 
-- 
2.39.2


From 7c43158af1abf38fa896a442cb3c6d8a5bc630e7 Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Sun, 14 Oct 2012 20:00:30 +0200
Subject: [PATCH 06/16] moved map data to maps.l2s

---
 src/loader/Caster.cpp      |   6 +
 src/loader/Caster.h        |   3 +
 src/loader/Interpreter.cpp |  21 ++-
 src/loader/Interpreter.h   |   2 +-
 src/loader/Parser.cpp      |   5 +-
 src/main.cpp               | 326 ++-----------------------------------
 src/map/Area.cpp           |  24 +++
 src/map/Area.h             |   3 +
 src/map/Entity.cpp         |   5 +
 src/map/Entity.h           |   3 +
 src/map/Map.cpp            |  30 ++++
 src/map/Map.h              |  10 +-
 src/map/MapState.cpp       |   1 +
 src/map/Tile.cpp           |  27 +++
 src/map/Tile.h             |   5 +-
 src/map/Trigger.cpp        |  26 +++
 src/map/Trigger.h          |   9 +-
 test-data/constants.l2h    |  19 +++
 test-data/constants.l2s    |  19 +++
 test-data/maps.l2s         | 291 +++++++++++++++++++++++++++++++++
 20 files changed, 499 insertions(+), 336 deletions(-)
 create mode 100644 test-data/maps.l2s

diff --git a/src/loader/Caster.cpp b/src/loader/Caster.cpp
index 6d6d718..152c8b2 100644
--- a/src/loader/Caster.cpp
+++ b/src/loader/Caster.cpp
@@ -14,6 +14,7 @@ using battle::PartyLayout;
 using common::Hero;
 using common::Item;
 using common::Spell;
+using map::Map;
 using std::string;
 
 
@@ -24,6 +25,7 @@ Caster::Caster(Interpreter &intp)
 , battleResourcesId(TypeDescription::GetTypeId("BattleResources"))
 , heroId(TypeDescription::GetTypeId("Hero"))
 , itemId(TypeDescription::GetTypeId("Item"))
+, mapId(TypeDescription::GetTypeId("Map"))
 , monsterId(TypeDescription::GetTypeId("Monster"))
 , partyLayoutId(TypeDescription::GetTypeId("PartyLayout"))
 , spellId(TypeDescription::GetTypeId("Spell")) {
@@ -43,6 +45,10 @@ Item *Caster::GetItem(const string &ident) {
 	return reinterpret_cast<Item *>(intp.GetObject(itemId, ident));
 }
 
+Map *Caster::GetMap(const string &ident) {
+	return reinterpret_cast<Map *>(intp.GetObject(mapId, ident));
+}
+
 Monster *Caster::GetMonster(const string &ident) {
 	return reinterpret_cast<Monster *>(intp.GetObject(monsterId, ident));
 }
diff --git a/src/loader/Caster.h b/src/loader/Caster.h
index a3042ac..80e765e 100644
--- a/src/loader/Caster.h
+++ b/src/loader/Caster.h
@@ -11,6 +11,7 @@
 #include "Interpreter.h"
 #include "../battle/fwd.h"
 #include "../common/fwd.h"
+#include "../map/fwd.h"
 
 #include <string>
 
@@ -29,6 +30,7 @@ public:
 	battle::Resources *GetBattleResources(const std::string &identifier);
 	common::Hero *GetHero(const std::string &identifier);
 	common::Item *GetItem(const std::string &identifier);
+	map::Map *GetMap(const std::string &identifier);
 	battle::Monster *GetMonster(const std::string &identifier);
 	battle::PartyLayout *GetPartyLayout(const std::string &identifier);
 	common::Spell *GetSpell(const std::string &identifier);
@@ -39,6 +41,7 @@ private:
 	int battleResourcesId;
 	int heroId;
 	int itemId;
+	int mapId;
 	int monsterId;
 	int partyLayoutId;
 	int spellId;
diff --git a/src/loader/Interpreter.cpp b/src/loader/Interpreter.cpp
index c2ce0d4..0fd2d88 100644
--- a/src/loader/Interpreter.cpp
+++ b/src/loader/Interpreter.cpp
@@ -62,8 +62,16 @@ Interpreter::~Interpreter() {
 }
 
 
-const Interpreter::ParsedDefinition &Interpreter::GetDefinition(const string &identifier) const {
-	return parsedDefinitions.at(identifier);
+const Interpreter::ParsedDefinition &Interpreter::GetDefinition(const string &identifier) {
+	std::map<string, ParsedDefinition>::const_iterator i(parsedDefinitions.find(identifier));
+	if (i != parsedDefinitions.end()) {
+		return i->second;
+	} else if (source.IsDefined(identifier)) {
+		ReadDefinition(source.GetDefinition(identifier));
+		return parsedDefinitions.at(identifier);
+	} else {
+		throw Error("access to undefined object " + identifier);
+	}
 }
 
 
@@ -114,13 +122,13 @@ void Interpreter::ReadLiteral(const Definition &dfn) {
 					|| dfn.GetLiteral()->GetType() == Literal::STRING)
 			? dfn.GetLiteral()->GetString().size() : td.Size());
 	char *object(alloc.Alloc(size));
+	values[typeId].push_back(object);
+	parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, typeId, id)));
 	if (dfn.GetLiteral()->GetType() == Literal::OBJECT) {
 		ReadObject(typeId, id, object, *dfn.GetLiteral()->GetProperties());
 	} else {
 		ReadLiteral(typeId, id, object, *dfn.GetLiteral());
 	}
-	values[typeId].push_back(object);
-	parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, typeId, id)));
 }
 
 void Interpreter::ReadLiteral(int typeId, int id, char *object, const Literal &literal) {
@@ -221,8 +229,9 @@ void *Interpreter::GetObject(int typeId, const Value &v) {
 				case Literal::SCRIPT:
 					{
 						typeId = TypeDescription::GetTypeId("Script");
+						char *script(ReadScript(v.GetLiteral().GetScript()));
 						id = values[typeId].size();
-						values[typeId].push_back(ReadScript(v.GetLiteral().GetScript()));
+						values[typeId].push_back(script);
 					}
 					break;
 				case Literal::STRING:
@@ -271,8 +280,8 @@ void Interpreter::ReadObject(const Definition &dfn) {
 	char *object(alloc.Alloc(td.Size()));
 	td.Construct(object);
 	values[typeId].push_back(object);
-	ReadObject(typeId, id, object, *dfn.GetProperties());
 	parsedDefinitions.insert(make_pair(dfn.Identifier(), ParsedDefinition(&dfn, typeId, id)));
+	ReadObject(typeId, id, object, *dfn.GetProperties());
 }
 
 
diff --git a/src/loader/Interpreter.h b/src/loader/Interpreter.h
index 5fbded6..9795a60 100644
--- a/src/loader/Interpreter.h
+++ b/src/loader/Interpreter.h
@@ -67,7 +67,7 @@ public:
 	};
 
 	const std::set<std::string> &ExportedIdentifiers() const { return source.Exports(); }
-	const ParsedDefinition &GetDefinition(const std::string &identifier) const;
+	const ParsedDefinition &GetDefinition(const std::string &identifier);
 	const std::map<std::string, SDL_Surface *> &Images() const { return imageCache; }
 	const std::vector<PostponedDefinition> &PostponedDefinitions() const { return postponedDefinitions; }
 	const std::map<int, std::vector<void *> > &Values() const { return values; }
diff --git a/src/loader/Parser.cpp b/src/loader/Parser.cpp
index 8ba3704..9ddae34 100644
--- a/src/loader/Parser.cpp
+++ b/src/loader/Parser.cpp
@@ -355,6 +355,7 @@ Literal *Parser::ParseScript() {
 	Token t(GetToken());
 	AssertTokenType(t.type, Token::SCRIPT_BEGIN, msg);
 
+	t = GetToken();
 	vector<ScriptToken *> script;
 	try {
 		while (t.type != Token::SCRIPT_END) {
@@ -365,7 +366,7 @@ Literal *Parser::ParseScript() {
 				switch (t.type) {
 					case Token::COMMAND: {
 						Token t2(GetToken());
-						AssertTokenType(t.type, Token::IDENTIFIER, msg);
+						AssertTokenType(t2.type, Token::IDENTIFIER, msg);
 						script.push_back(new ScriptToken(t2.str, ScriptToken::COMMAND));
 						break;
 					}
@@ -375,7 +376,7 @@ Literal *Parser::ParseScript() {
 					}
 					case Token::REGISTER: {
 						Token t2(GetToken());
-						AssertTokenType(t.type, Token::IDENTIFIER, msg);
+						AssertTokenType(t2.type, Token::IDENTIFIER, msg);
 						script.push_back(new ScriptToken(t2.str, ScriptToken::REGISTER));
 						break;
 					}
diff --git a/src/main.cpp b/src/main.cpp
index a8a7225..40b38f1 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -103,7 +103,6 @@ int main(int argc, char **argv) {
 	const int width = 800;
 	const int height = 480;
 
-	const int tileSize = 32;
 	const float walkSpeed = 128.0f;
 
 	bool battle(false);
@@ -114,6 +113,7 @@ int main(int argc, char **argv) {
 		InitSDL sdl;
 		InitImage image(IMG_INIT_PNG);
 
+		Area::CreateTypeDescription();
 		battle::Resources::CreateTypeDescription();
 		ComplexAnimation::CreateTypeDescription();
 		Font::CreateTypeDescription();
@@ -123,6 +123,7 @@ int main(int argc, char **argv) {
 		Ikari::CreateTypeDescription();
 		Interpreter::CreateTypeDescriptions();
 		Item::CreateTypeDescription();
+		Map::CreateTypeDescription();
 		graphics::MenuProperties::CreateTypeDescription();
 		Monster::CreateTypeDescription();
 		PartyLayout::CreateTypeDescription();
@@ -131,6 +132,8 @@ int main(int argc, char **argv) {
 		Sprite::CreateTypeDescription();
 		Stats::CreateTypeDescription();
 		common::TargetingMode::CreateTypeDescription();
+		Tile::CreateTypeDescription();
+		Trigger::CreateTypeDescription();
 		Entity::CreateTypeDescription();
 
 		Arguments args;
@@ -186,6 +189,12 @@ int main(int argc, char **argv) {
 
 		Caster caster(intp);
 
+		{
+			Map *map1(caster.GetMap("map1"));
+			Map *map2(caster.GetMap("map2"));
+			std::cout << map1 << ' ' << map2 << std::endl;
+		}
+
 		GameState gameState;
 
 		gameState.heroes[0] = *caster.GetHero("maxim");
@@ -263,301 +272,6 @@ int main(int argc, char **argv) {
 		gameState.heroes[3].SetRing(caster.GetItem("rocketRingItem"));
 		gameState.heroes[3].SetJewel(caster.GetItem("krakenRockItem"));
 
-		Tile tiles1[64];
-
-		tiles1[ 0].SetOffset(Vector<int>(2, 1));
-		tiles1[ 1].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_NORTH | Tile::BLOCK_WEST);
-		tiles1[ 2].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH);
-		tiles1[ 3].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH | Tile::BLOCK_EAST);
-		tiles1[ 4].SetOffset(Vector<int>(0, 1));
-		tiles1[ 5].SetOffset(Vector<int>(2, 0));
-		tiles1[ 6].SetOffset(Vector<int>(2, 0));
-		tiles1[ 7].SetOffset(Vector<int>(2, 0));
-
-		tiles1[ 8].SetOffset(Vector<int>(2, 1));
-		tiles1[ 9].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_WEST);
-		tiles1[10].SetOffset(Vector<int>(3, 0));
-		tiles1[11].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_EAST);
-		tiles1[12].SetOffset(Vector<int>(0, 2));
-		tiles1[13].SetOffset(Vector<int>(1, 2));
-		tiles1[14].SetOffset(Vector<int>(1, 2));
-		tiles1[15].SetOffset(Vector<int>(1, 2));
-
-		tiles1[16].SetOffset(Vector<int>(2, 1));
-		tiles1[17].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_WEST);
-		tiles1[18].SetOffset(Vector<int>(3, 0));
-		tiles1[19].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_EAST);
-		tiles1[20].SetOffset(Vector<int>(0, 3));
-		tiles1[21].SetOffset(Vector<int>(1, 3));
-		tiles1[22].SetOffset(Vector<int>(1, 3));
-		tiles1[23].SetOffset(Vector<int>(2, 3));
-
-		tiles1[24].SetOffset(Vector<int>(2, 1));
-		tiles1[25].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_WEST);
-		tiles1[26].SetOffset(Vector<int>(3, 0));
-		tiles1[27].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_EAST);
-		tiles1[28].SetOffset(Vector<int>(0, 4));
-		tiles1[29].SetOffset(Vector<int>(1, 4));
-		tiles1[30].SetOffset(Vector<int>(1, 4));
-		tiles1[31].SetOffset(Vector<int>(2, 4));
-
-		tiles1[32].SetOffset(Vector<int>(2, 1));
-		tiles1[33].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_WEST);
-		tiles1[34].SetOffset(Vector<int>(3, 0));
-		tiles1[35].SetOffset(Vector<int>(3, 0));
-		tiles1[36].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH);
-		tiles1[37].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH);
-		tiles1[38].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH);
-		tiles1[39].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH);
-
-		tiles1[40].SetOffset(Vector<int>(2, 1));
-		tiles1[41].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_WEST);
-		tiles1[42].SetOffset(Vector<int>(3, 0));
-		tiles1[43].SetOffset(Vector<int>(3, 0));
-		tiles1[44].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_SOUTH);
-		tiles1[45].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_SOUTH);
-		tiles1[46].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_SOUTH);
-		tiles1[47].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_SOUTH);
-
-		tiles1[48].SetOffset(Vector<int>(2, 1));
-		tiles1[49].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_WEST);
-		tiles1[50].SetOffset(Vector<int>(3, 0));
-		tiles1[51].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_EAST);
-		tiles1[52].SetOffset(Vector<int>(0, 0));
-		tiles1[53].SetOffset(Vector<int>(1, 0));
-		tiles1[54].SetOffset(Vector<int>(1, 0));
-		tiles1[55].SetOffset(Vector<int>(1, 0));
-
-		tiles1[56].SetOffset(Vector<int>(2, 1));
-		tiles1[57].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_SOUTH | Tile::BLOCK_WEST);
-		tiles1[58].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_SOUTH);
-		tiles1[59].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_SOUTH | Tile::BLOCK_EAST);
-		tiles1[60].SetOffset(Vector<int>(0, 1));
-		tiles1[61].SetOffset(Vector<int>(1, 1));
-		tiles1[62].SetOffset(Vector<int>(1, 1));
-		tiles1[63].SetOffset(Vector<int>(1, 1));
-
-		Tile tiles2[64];
-
-		tiles2[ 0].SetOffset(Vector<int>(2, 0));
-		tiles2[ 1].SetOffset(Vector<int>(2, 0));
-		tiles2[ 2].SetOffset(Vector<int>(2, 0));
-		tiles2[ 3].SetOffset(Vector<int>(2, 0));
-		tiles2[ 4].SetOffset(Vector<int>(2, 0));
-		tiles2[ 5].SetOffset(Vector<int>(2, 0));
-		tiles2[ 6].SetOffset(Vector<int>(2, 0));
-		tiles2[ 7].SetOffset(Vector<int>(2, 0));
-
-		tiles2[ 8].SetOffset(Vector<int>(1, 2));
-		tiles2[ 9].SetOffset(Vector<int>(1, 2));
-		tiles2[10].SetOffset(Vector<int>(5, 3));
-		tiles2[11].SetOffset(Vector<int>(2, 0));
-		tiles2[12].SetOffset(Vector<int>(2, 0));
-		tiles2[13].SetOffset(Vector<int>(2, 0));
-		tiles2[14].SetOffset(Vector<int>(2, 0));
-		tiles2[15].SetOffset(Vector<int>(2, 0));
-
-		tiles2[16].SetOffset(Vector<int>(3, 3));
-		tiles2[17].SetOffset(Vector<int>(0, 3));
-		tiles2[18].SetOffset(Vector<int>(0, 1));
-		tiles2[19].SetOffset(Vector<int>(2, 0));
-		tiles2[20].SetOffset(Vector<int>(2, 0));
-		tiles2[21].SetOffset(Vector<int>(2, 0));
-		tiles2[22].SetOffset(Vector<int>(2, 0));
-		tiles2[23].SetOffset(Vector<int>(2, 0));
-
-		tiles2[24].SetOffset(Vector<int>(3, 4)).SetFlags(Tile::BLOCK_NORTH | Tile::BLOCK_EAST | Tile::BLOCK_WEST);
-		tiles2[25].SetOffset(Vector<int>(0, 4));
-		tiles2[26].SetOffset(Vector<int>(0, 1));
-		tiles2[27].SetOffset(Vector<int>(2, 0));
-		tiles2[28].SetOffset(Vector<int>(2, 0));
-		tiles2[29].SetOffset(Vector<int>(2, 0));
-		tiles2[30].SetOffset(Vector<int>(2, 0));
-		tiles2[31].SetOffset(Vector<int>(2, 0));
-
-		tiles2[32].SetOffset(Vector<int>(5, 0));
-		tiles2[33].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH | Tile::BLOCK_EAST);
-		tiles2[34].SetOffset(Vector<int>(0, 1));
-		tiles2[35].SetOffset(Vector<int>(2, 0));
-		tiles2[36].SetOffset(Vector<int>(2, 0));
-		tiles2[37].SetOffset(Vector<int>(2, 0));
-		tiles2[38].SetOffset(Vector<int>(2, 0));
-		tiles2[39].SetOffset(Vector<int>(2, 0));
-
-		tiles2[40].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_SOUTH);
-		tiles2[41].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_SOUTH | Tile::BLOCK_EAST);
-		tiles2[42].SetOffset(Vector<int>(0, 1));
-		tiles2[43].SetOffset(Vector<int>(2, 0));
-		tiles2[44].SetOffset(Vector<int>(2, 0));
-		tiles2[45].SetOffset(Vector<int>(2, 0));
-		tiles2[46].SetOffset(Vector<int>(2, 0));
-		tiles2[47].SetOffset(Vector<int>(2, 0));
-
-		tiles2[48].SetOffset(Vector<int>(1, 0));
-		tiles2[49].SetOffset(Vector<int>(1, 0));
-		tiles2[50].SetOffset(Vector<int>(5, 4));
-		tiles2[51].SetOffset(Vector<int>(2, 0));
-		tiles2[52].SetOffset(Vector<int>(2, 0));
-		tiles2[53].SetOffset(Vector<int>(2, 0));
-		tiles2[54].SetOffset(Vector<int>(2, 0));
-		tiles2[55].SetOffset(Vector<int>(2, 0));
-
-		tiles2[56].SetOffset(Vector<int>(2, 0));
-		tiles2[57].SetOffset(Vector<int>(2, 0));
-		tiles2[58].SetOffset(Vector<int>(2, 0));
-		tiles2[59].SetOffset(Vector<int>(2, 0));
-		tiles2[60].SetOffset(Vector<int>(2, 0));
-		tiles2[61].SetOffset(Vector<int>(2, 0));
-		tiles2[62].SetOffset(Vector<int>(2, 0));
-		tiles2[63].SetOffset(Vector<int>(2, 0));
-
-		Area areas1[2];
-		areas1[0].SetTiles(tiles1, 64);
-		areas1[0].SetWidth(8);
-		areas1[1].SetTiles(tiles2, 64);
-		areas1[1].SetWidth(8);
-
-		Trigger triggers1[1];
-		triggers1[0].SetTilePosition(Vector<int>(8, 3));
-		triggers1[0].SetType(Trigger::TYPE_NORTH);
-
-		SDL_Surface *tilesetImg(IMG_Load("test-data/tileset.png"));
-		Sprite tileset(tilesetImg, tileSize, tileSize);
-
-		Map map1;
-		map1.SetAreas(areas1, 2);
-		map1.SetTileset(&tileset);
-		map1.SetTriggers(triggers1, 1);
-		map1.SetWidth(2);
-		map1.SetBattleBackground(bg);
-
-		Tile tiles3[64];
-
-		tiles3[ 0].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH | Tile::BLOCK_WEST);
-		tiles3[ 1].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH);
-		tiles3[ 2].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH);
-		tiles3[ 3].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH);
-		tiles3[ 4].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH);
-		tiles3[ 5].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH);
-		tiles3[ 6].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH);
-		tiles3[ 7].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_NORTH | Tile::BLOCK_EAST);
-
-		tiles3[ 8].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_WEST);
-		tiles3[ 9].SetOffset(Vector<int>(3, 0));
-		tiles3[10].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_SOUTH);
-		tiles3[11].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_SOUTH);
-		tiles3[12].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_SOUTH);
-		tiles3[13].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_SOUTH);
-		tiles3[14].SetOffset(Vector<int>(4, 0));
-		tiles3[15].SetOffset(Vector<int>(4, 0)).SetFlags(Tile::BLOCK_EAST | Tile::BLOCK_SOUTH);
-
-		tiles3[16].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_WEST);
-		tiles3[17].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_EAST);
-		tiles3[18].SetOffset(Vector<int>(0, 0));
-		tiles3[19].SetOffset(Vector<int>(1, 0));
-		tiles3[20].SetOffset(Vector<int>(1, 0));
-		tiles3[21].SetOffset(Vector<int>(3, 2));
-		tiles3[22].SetOffset(Vector<int>(4, 2)).SetFlags(Tile::BLOCK_EAST | Tile::BLOCK_SOUTH | Tile::BLOCK_WEST);
-		tiles3[23].SetOffset(Vector<int>(5, 2));
-
-		tiles3[24].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_WEST);
-		tiles3[25].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_EAST);
-		tiles3[26].SetOffset(Vector<int>(0, 1));
-		tiles3[27].SetOffset(Vector<int>(2, 0));
-		tiles3[28].SetOffset(Vector<int>(2, 0));
-		tiles3[29].SetOffset(Vector<int>(1, 2));
-		tiles3[30].SetOffset(Vector<int>(1, 2));
-		tiles3[31].SetOffset(Vector<int>(1, 2));
-
-		tiles3[32].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_WEST);
-		tiles3[33].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_EAST);
-		tiles3[34].SetOffset(Vector<int>(0, 1));
-		tiles3[35].SetOffset(Vector<int>(2, 0));
-		tiles3[36].SetOffset(Vector<int>(2, 0));
-		tiles3[37].SetOffset(Vector<int>(2, 3));
-		tiles3[38].SetOffset(Vector<int>(3, 3));
-		tiles3[39].SetOffset(Vector<int>(0, 3));
-
-		tiles3[40].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_WEST);
-		tiles3[41].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_EAST);
-		tiles3[42].SetOffset(Vector<int>(0, 1));
-		tiles3[43].SetOffset(Vector<int>(2, 0));
-		tiles3[44].SetOffset(Vector<int>(2, 0));
-		tiles3[45].SetOffset(Vector<int>(2, 4));
-		tiles3[46].SetOffset(Vector<int>(3, 4));
-		tiles3[47].SetOffset(Vector<int>(0, 4));
-
-		tiles3[48].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_WEST);
-		tiles3[49].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_EAST);
-		tiles3[50].SetOffset(Vector<int>(0, 1));
-		tiles3[51].SetOffset(Vector<int>(2, 0));
-		tiles3[52].SetOffset(Vector<int>(2, 0));
-		tiles3[53].SetOffset(Vector<int>(4, 1));
-		tiles3[54].SetOffset(Vector<int>(5, 1));
-		tiles3[55].SetOffset(Vector<int>(3, 1));
-
-		tiles3[56].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_SOUTH | Tile::BLOCK_WEST);
-		tiles3[57].SetOffset(Vector<int>(3, 0)).SetFlags(Tile::BLOCK_EAST | Tile::BLOCK_SOUTH);
-		tiles3[58].SetOffset(Vector<int>(0, 1));
-		tiles3[59].SetOffset(Vector<int>(2, 0));
-		tiles3[60].SetOffset(Vector<int>(2, 0));
-		tiles3[61].SetOffset(Vector<int>(2, 0));
-		tiles3[62].SetOffset(Vector<int>(2, 0));
-		tiles3[63].SetOffset(Vector<int>(2, 0));
-
-		Area areas2[1];
-		areas2[0].SetTiles(tiles3, 64);
-		areas2[0].SetWidth(8);
-
-		Trigger triggers2[1];
-		triggers2[0].SetTilePosition(Vector<int>(6, 2));
-		triggers2[0].SetType(Trigger::TYPE_SOUTH);
-
-		Map map2;
-		map2.SetAreas(areas2, 1);
-		map2.SetTileset(&tileset);
-		map2.SetTriggers(triggers2, 1);
-		map2.SetWidth(1);
-		map2.SetBattleBackground(bg);
-
-		unsigned char transition1text[4 + sizeof(int) + sizeof(Map *) + sizeof(Vector<int>)];
-		int i(0);
-		transition1text[i++] = Script::CODE_MOVE_I0;
-		*reinterpret_cast<int *>(transition1text + i) = 1;
-		i += sizeof(int);
-		transition1text[i++] = Script::CODE_MOVE_A0;
-		*reinterpret_cast<Map **>(transition1text + i) = &map2;
-		i += sizeof(Map *);
-		transition1text[i++] = Script::CODE_MOVE_V0;
-		*reinterpret_cast<Vector<int> *>(transition1text + i) = Vector<int>(6, 2);
-		i += sizeof(Vector<int>);
-		transition1text[i++] = Script::CODE_SYSCALL;
-
-		Script transition1;
-		transition1.text = transition1text;
-		transition1.textlen = sizeof(transition1text);
-
-		triggers1[0].SetScript(&transition1);
-
-		unsigned char transition2text[4 + sizeof(int) + sizeof(Map *) + sizeof(Vector<int>)];
-		i = 0;
-		transition2text[i++] = Script::CODE_MOVE_I0;
-		*reinterpret_cast<int *>(transition2text + i) = 1;
-		i += sizeof(int);
-		transition2text[i++] = Script::CODE_MOVE_A0;
-		*reinterpret_cast<Map **>(transition2text + i) = &map1;
-		i += sizeof(Map *);
-		transition2text[i++] = Script::CODE_MOVE_V0;
-		*reinterpret_cast<Vector<int> *>(transition2text + i) = Vector<int>(8, 3);
-		i += sizeof(Vector<int>);
-		transition2text[i++] = Script::CODE_SYSCALL;
-
-		Script transition2;
-		transition2.text = transition2text;
-		transition2.textlen = sizeof(transition2text);
-
-		triggers2[0].SetScript(&transition2);
-
 		gameState.heroes[0].MapEntity().Position() = Vector<float>(64, 128);
 
 		gameState.heroes[1].MapEntity().Position() = Vector<float>(64, 128);
@@ -572,23 +286,6 @@ int main(int argc, char **argv) {
 		gameState.heroes[3].MapEntity().SetFlags(Entity::FLAG_NONBLOCKING);
 		gameState.heroes[2].MapEntity().AddFollower(&gameState.heroes[3].MapEntity());
 
-		Entity mapPopulation[2];
-		map1.SetEntities(mapPopulation, 2);
-
-		SDL_Surface *mapMonsterImg(IMG_Load("test-data/monster-map.png"));
-		Sprite mapMonsterSprite(mapMonsterImg, 32, 32);
-		SimpleAnimation mapMonsterAnimation(&mapMonsterSprite, 500, 2, 0, 0, true);
-		mapPopulation[0].SetAnimation(&mapMonsterAnimation);
-		mapPopulation[0].Position() = Vector<float>(64, 32);
-		mapPopulation[0].SetOrientation(Entity::ORIENTATION_SOUTH);
-		mapPopulation[0].SetPartyLayout(&monstersLayout);
-		mapPopulation[0].SetMonsters(&monster, 1);
-
-		Sprite blockSprite(tilesetImg, tileSize, tileSize, 3 * tileSize, 1 * tileSize);
-		mapPopulation[1].SetSprite(&blockSprite);
-		mapPopulation[1].Position() = Vector<float>(64, 160);
-		mapPopulation[1].SetFlags(Entity::FLAG_PUSHABLE | Entity::FLAG_FIXED_ORIENTATION);
-
 		InitScreen screen(width, height);
 
 		app::State *state(0);
@@ -605,11 +302,10 @@ int main(int argc, char **argv) {
 			battleState->AddHero(gameState.heroes[3]);
 			state = battleState;
 		} else {
-			MapState *mapState(new MapState(&gameConfig, &map1));
+			MapState *mapState(new MapState(&gameConfig, caster.GetMap("map1")));
 
 			mapState->ControlEntity(&gameState.heroes[0].MapEntity());
 			mapState->SetWalkingSpeed(walkSpeed);
-			mapPopulation[0].StartAnimation(*mapState);
 
 			state = mapState;
 		}
diff --git a/src/map/Area.cpp b/src/map/Area.cpp
index 985dea2..1b9488a 100644
--- a/src/map/Area.cpp
+++ b/src/map/Area.cpp
@@ -9,11 +9,14 @@
 
 #include "Tile.h"
 #include "../graphics/Sprite.h"
+#include "../loader/TypeDescription.h"
 #include "../sdl/utility.h"
 
 #include <stdexcept>
 
 using geometry::Vector;
+using loader::FieldDescription;
+using loader::TypeDescription;
 
 namespace map {
 
@@ -86,4 +89,25 @@ void Area::RenderDebug(SDL_Surface *dest, const graphics::Sprite *tileset, const
 	}
 }
 
+
+void Area::CreateTypeDescription() {
+	Area a;
+
+	int imageId(TypeDescription::GetTypeId("Image"));
+	int numberId(TypeDescription::GetTypeId("Number"));
+	int tileId(TypeDescription::GetTypeId("Tile"));
+
+	TypeDescription &td(TypeDescription::CreateOrGet("Area"));
+	td.SetConstructor(&Construct);
+	td.SetSize(sizeof(Area));
+
+	td.AddField("battlebg", FieldDescription(((char *)&a.battlebg) - ((char *)&a), imageId).SetReferenced());
+	td.AddField("tiles", FieldDescription(((char *)&a.tiles) - ((char *)&a), tileId).SetReferenced().SetAggregate());
+	td.AddField("width", FieldDescription(((char *)&a.width) - ((char *)&a), numberId));
+}
+
+void Area::Construct(void *data) {
+	new (data) Area;
+}
+
 }
diff --git a/src/map/Area.h b/src/map/Area.h
index a044c8b..3c370ab 100644
--- a/src/map/Area.h
+++ b/src/map/Area.h
@@ -34,6 +34,9 @@ public:
 	void Render(SDL_Surface *dest, const graphics::Sprite *tileset, const geometry::Vector<int> &offset) const;
 	void RenderDebug(SDL_Surface *dest, const graphics::Sprite *tileset, const geometry::Vector<int> &offset) const;
 
+	static void CreateTypeDescription();
+	static void Construct(void *);
+
 // temporary setters
 public:
 	void SetTiles(Tile *t, int num) { tiles = t; numTiles = num; }
diff --git a/src/map/Entity.cpp b/src/map/Entity.cpp
index e922e54..9929534 100644
--- a/src/map/Entity.cpp
+++ b/src/map/Entity.cpp
@@ -143,7 +143,9 @@ void Entity::CreateTypeDescription() {
 
 	int animationId(TypeDescription::GetTypeId("Animation"));
 	int monsterId(TypeDescription::GetTypeId("Monster"));
+	int numberId(TypeDescription::GetTypeId("Number"));
 	int partyLayoutId(TypeDescription::GetTypeId("PartyLayout"));
+	int spriteId(TypeDescription::GetTypeId("Sprite"));
 	int vectorId(TypeDescription::GetTypeId("Vector"));
 
 	TypeDescription &td(TypeDescription::CreateOrGet("Entity"));
@@ -152,9 +154,12 @@ void Entity::CreateTypeDescription() {
 	td.SetSize(sizeof(Entity));
 
 	td.AddField("animation", FieldDescription(((char *)&e.animation) - ((char *)&e), animationId).SetReferenced());
+	td.AddField("sprite", FieldDescription(((char *)&e.sprite) - ((char *)&e), spriteId).SetReferenced());
 	td.AddField("partyLayout", FieldDescription(((char *)&e.partyLayout) - ((char *)&e), partyLayoutId).SetReferenced());
 	td.AddField("monsters", FieldDescription(((char *)&e.monsters) - ((char *)&e), monsterId).SetReferenced().SetAggregate());
 	td.AddField("spriteOffset", FieldDescription(((char *)&e.spriteOffset) - ((char *)&e), vectorId));
+	td.AddField("position", FieldDescription(((char *)&e.tilePosition) - ((char *)&e), vectorId));
+	td.AddField("flags", FieldDescription(((char *)&e.flags) - ((char *)&e), numberId));
 }
 
 void Entity::Construct(void *data) {
diff --git a/src/map/Entity.h b/src/map/Entity.h
index fc1dc81..cc30c95 100644
--- a/src/map/Entity.h
+++ b/src/map/Entity.h
@@ -48,6 +48,8 @@ public:
 	geometry::Vector<int> &SpriteOffset() { return spriteOffset; }
 	const geometry::Vector<int> &SpriteOffset() const { return spriteOffset; }
 
+	void ResetPosition(const geometry::Vector<int> &tileSize) { position = tilePosition * tileSize; }
+
 	void SetAnimation(const graphics::Animation *a);
 	void StartAnimation(app::Application &ctrl);
 	void StartAnimation(app::State &ctrl);
@@ -104,6 +106,7 @@ private:
 	int numMonsters;
 	graphics::AnimationRunner runner;
 	geometry::Vector<int> spriteOffset;
+	geometry::Vector<int> tilePosition;
 	geometry::Vector<float> position;
 	geometry::Vector<float> velocity;
 	Orientation orientation;
diff --git a/src/map/Map.cpp b/src/map/Map.cpp
index 1c55eaf..3f05962 100644
--- a/src/map/Map.cpp
+++ b/src/map/Map.cpp
@@ -11,11 +11,14 @@
 #include "Tile.h"
 #include "Trigger.h"
 #include "../graphics/Sprite.h"
+#include "../loader/TypeDescription.h"
 #include "../sdl/utility.h"
 
 #include <stdexcept>
 
 using geometry::Vector;
+using loader::FieldDescription;
+using loader::TypeDescription;
 
 namespace map {
 
@@ -149,4 +152,31 @@ void Map::RenderDebug(SDL_Surface *dest, const Vector<int> &inOffset) const {
 	}
 }
 
+
+void Map::CreateTypeDescription() {
+	Map m;
+
+	int areaId(TypeDescription::GetTypeId("Area"));
+	int entityId(TypeDescription::GetTypeId("Entity"));
+	int imageId(TypeDescription::GetTypeId("Image"));
+	int numberId(TypeDescription::GetTypeId("Number"));
+	int spriteId(TypeDescription::GetTypeId("Sprite"));
+	int triggerId(TypeDescription::GetTypeId("Trigger"));
+
+	TypeDescription &td(TypeDescription::CreateOrGet("Map"));
+	td.SetConstructor(&Construct);
+	td.SetSize(sizeof(Map));
+
+	td.AddField("tileset", FieldDescription(((char *)&m.tileset) - ((char *)&m), spriteId).SetReferenced());
+	td.AddField("battlebg", FieldDescription(((char *)&m.battlebg) - ((char *)&m), imageId).SetReferenced());
+	td.AddField("areas", FieldDescription(((char *)&m.areas) - ((char *)&m), areaId).SetReferenced().SetAggregate());
+	td.AddField("triggers", FieldDescription(((char *)&m.triggers) - ((char *)&m), triggerId).SetReferenced().SetAggregate());
+	td.AddField("entities", FieldDescription(((char *)&m.entities) - ((char *)&m), entityId).SetReferenced().SetAggregate());
+	td.AddField("width", FieldDescription(((char *)&m.width) - ((char *)&m), numberId));
+}
+
+void Map::Construct(void *data) {
+	new (data) Map;
+}
+
 }
diff --git a/src/map/Map.h b/src/map/Map.h
index 40cce1c..a985d84 100644
--- a/src/map/Map.h
+++ b/src/map/Map.h
@@ -39,14 +39,8 @@ public:
 	void Render(SDL_Surface *dest, const geometry::Vector<int> &offset) const;
 	void RenderDebug(SDL_Surface *dest, const geometry::Vector<int> &offset) const;
 
-// temporary setters
-public:
-	void SetTileset(const graphics::Sprite *t) { tileset = t; }
-	void SetBattleBackground(SDL_Surface *bg) { battlebg = bg; }
-	void SetAreas(Area *a, int num) { areas = a; numAreas = num; }
-	void SetTriggers(Trigger *t, int num) { triggers = t; numTriggers = num; }
-	void SetEntities(Entity *e, int num) { entities = e; numEntities = num; }
-	void SetWidth(int w) { width = w; }
+	static void CreateTypeDescription();
+	static void Construct(void *);
 
 private:
 	const graphics::Sprite *tileset;
diff --git a/src/map/MapState.cpp b/src/map/MapState.cpp
index 6b02531..37ccc72 100644
--- a/src/map/MapState.cpp
+++ b/src/map/MapState.cpp
@@ -412,6 +412,7 @@ void MapState::LoadMap(Map *m) {
 	map = m;
 	for (Entity *e(m->EntitiesBegin()), *end(m->EntitiesEnd()); e != end; ++e) {
 		entities.push_back(e);
+		e->ResetPosition(map->Tileset()->Size());
 	}
 	for (Entity *e(controlled); e; e = e->Follower()) {
 		entities.push_back(e);
diff --git a/src/map/Tile.cpp b/src/map/Tile.cpp
index 303c9e5..650bbdb 100644
--- a/src/map/Tile.cpp
+++ b/src/map/Tile.cpp
@@ -7,6 +7,11 @@
 
 #include "Tile.h"
 
+#include "../loader/TypeDescription.h"
+
+using loader::FieldDescription;
+using loader::TypeDescription;
+
 namespace map {
 
 Tile::Tile()
@@ -15,4 +20,26 @@ Tile::Tile()
 
 }
 
+
+void Tile::CreateTypeDescription() {
+	Tile t;
+
+	int imageId(TypeDescription::GetTypeId("Image"));
+	int numberId(TypeDescription::GetTypeId("Number"));
+	int vectorId(TypeDescription::GetTypeId("Vector"));
+
+	TypeDescription &td(TypeDescription::CreateOrGet("Tile"));
+	td.SetConstructor(&Construct);
+	td.SetSize(sizeof(Tile));
+
+	td.AddField("battlebg", FieldDescription(((char *)&t.battlebg) - ((char *)&t), imageId).SetReferenced());
+	td.AddField("t", FieldDescription(((char *)&t.offset) - ((char *)&t), vectorId));
+	td.AddField("flags", FieldDescription(((char *)&t.flags) - ((char *)&t), numberId));
+
+}
+
+void Tile::Construct(void *data) {
+	new (data) Tile;
+}
+
 }
diff --git a/src/map/Tile.h b/src/map/Tile.h
index 06b3b11..6706b01 100644
--- a/src/map/Tile.h
+++ b/src/map/Tile.h
@@ -37,6 +37,9 @@ public:
 	bool BlocksSouth() const { return flags & BLOCK_SOUTH; }
 	bool BlocksWest() const { return flags & BLOCK_WEST; }
 
+	static void CreateTypeDescription();
+	static void Construct(void *);
+
 // temporary setters
 public:
 	Tile &SetOffset(const geometry::Vector<int> &o) { offset = o; return *this; }
@@ -45,7 +48,7 @@ public:
 private:
 	SDL_Surface *battlebg;
 	geometry::Vector<int> offset;
-	Uint32 flags;
+	int flags;
 
 };
 
diff --git a/src/map/Trigger.cpp b/src/map/Trigger.cpp
index f454613..ff4863d 100644
--- a/src/map/Trigger.cpp
+++ b/src/map/Trigger.cpp
@@ -7,6 +7,11 @@
 
 #include "Trigger.h"
 
+#include "../loader/TypeDescription.h"
+
+using loader::FieldDescription;
+using loader::TypeDescription;
+
 namespace map {
 
 Trigger::Trigger()
@@ -15,4 +20,25 @@ Trigger::Trigger()
 
 }
 
+
+void Trigger::CreateTypeDescription() {
+	Trigger t;
+
+	int numberId(TypeDescription::GetTypeId("Number"));
+	int scriptId(TypeDescription::GetTypeId("Script"));
+	int vectorId(TypeDescription::GetTypeId("Vector"));
+
+	TypeDescription &td(TypeDescription::CreateOrGet("Trigger"));
+	td.SetConstructor(&Construct);
+	td.SetSize(sizeof(Trigger));
+
+	td.AddField("script", FieldDescription(((char *)&t.script) - ((char *)&t), scriptId).SetReferenced());
+	td.AddField("position", FieldDescription(((char *)&t.tilePosition) - ((char *)&t), vectorId));
+	td.AddField("type", FieldDescription(((char *)&t.type) - ((char *)&t), numberId));
+}
+
+void Trigger::Construct(void *data) {
+	new (data) Trigger;
+}
+
 }
diff --git a/src/map/Trigger.h b/src/map/Trigger.h
index 13b85ac..eb17460 100644
--- a/src/map/Trigger.h
+++ b/src/map/Trigger.h
@@ -26,16 +26,19 @@ public:
 		TYPE_EAST = Entity::ORIENTATION_EAST,
 		TYPE_SOUTH = Entity::ORIENTATION_SOUTH,
 		TYPE_WEST = Entity::ORIENTATION_WEST,
-		TYPE_CONTACT,
+		TYPE_CONTACT = 4,
 	};
 
 public:
 	const geometry::Vector<int> &TilePosition() const { return tilePosition; }
-	Type GetType() const { return type; }
+	Type GetType() const { return Type(type); }
 	bool HasScript() const { return script; }
 	common::Script &GetScript() { return *script; }
 	const common::Script &GetScript() const { return *script; }
 
+	static void CreateTypeDescription();
+	static void Construct(void *);
+
 // temporary setters
 public:
 	void SetTilePosition(const geometry::Vector<int> &p) { tilePosition = p; }
@@ -45,7 +48,7 @@ public:
 private:
 	common::Script *script;
 	geometry::Vector<int> tilePosition;
-	Type type;
+	int type;
 
 };
 
diff --git a/test-data/constants.l2h b/test-data/constants.l2h
index 851f7ff..5ace629 100644
--- a/test-data/constants.l2h
+++ b/test-data/constants.l2h
@@ -9,3 +9,22 @@ Number multiple
 // Ikari
 Boolean magical
 Boolean physical
+
+// Trigger type
+Number triggerNorth
+Number triggerEast
+Number triggerSouth
+Number triggerWest
+Number triggerContact
+
+// Tile flags
+Number blockN
+Number blockE
+Number blockNE
+Number blockS
+Number blockES
+Number blockW
+Number blockNW
+Number blockNEW
+Number blockSW
+Number blockESW
diff --git a/test-data/constants.l2s b/test-data/constants.l2s
index 8c624ec..fa01f2b 100644
--- a/test-data/constants.l2s
+++ b/test-data/constants.l2s
@@ -9,3 +9,22 @@ export Number single 2
 // Ikari
 export Boolean magical false
 export Boolean physical true
+
+// Trigger type
+export Number triggerNorth 0
+export Number triggerEast 1
+export Number triggerSouth 2
+export Number triggerWest 3
+export Number triggerContact 4
+
+// Tile flags
+export Number blockN    1
+export Number blockE    2
+export Number blockNE   3
+export Number blockS    4
+export Number blockES   6
+export Number blockW    8
+export Number blockNW   9
+export Number blockNEW 11
+export Number blockSW  12
+export Number blockESW 14
diff --git a/test-data/maps.l2s b/test-data/maps.l2s
new file mode 100644
index 0000000..e91ace9
--- /dev/null
+++ b/test-data/maps.l2s
@@ -0,0 +1,291 @@
+include "constants.l2h"
+
+export Map map1 {
+	tileset: Sprite {
+		image: :"tileset.png",
+		size: <32, 32>
+	},
+	battlebg: :"battle-bg.png",
+	width: 2,
+	areas: [ Area
+		{
+			width: 8,
+			tiles: [ Tile
+				{ t: <2, 1> },
+				{ t: <4, 0>, flags: blockNW },
+				{ t: <3, 0>, flags: blockN },
+				{ t: <3, 0>, flags: blockNE },
+				{ t: <0, 1> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				
+				{ t: <2, 1> },
+				{ t: <4, 0>, flags: blockW },
+				{ t: <3, 0> },
+				{ t: <3, 0>, flags: blockE },
+				{ t: <0, 2> },
+				{ t: <1, 2> },
+				{ t: <1, 2> },
+				{ t: <1, 2> },
+				
+				{ t: <2, 1> },
+				{ t: <4, 0>, flags: blockW },
+				{ t: <3, 0> },
+				{ t: <3, 0>, flags: blockE },
+				{ t: <0, 3> },
+				{ t: <1, 3> },
+				{ t: <1, 3> },
+				{ t: <2, 3> },
+				
+				{ t: <2, 1> },
+				{ t: <4, 0>, flags: blockW },
+				{ t: <3, 0> },
+				{ t: <3, 0>, flags: blockE },
+				{ t: <0, 4> },
+				{ t: <1, 4> },
+				{ t: <1, 4> },
+				{ t: <2, 4> },
+				
+				{ t: <2, 1> },
+				{ t: <4, 0>, flags: blockW },
+				{ t: <3, 0> },
+				{ t: <3, 0> },
+				{ t: <3, 0>, flags: blockN },
+				{ t: <3, 0>, flags: blockN },
+				{ t: <3, 0>, flags: blockN },
+				{ t: <3, 0>, flags: blockN },
+				
+				{ t: <2, 1> },
+				{ t: <4, 0>, flags: blockW },
+				{ t: <3, 0> },
+				{ t: <3, 0> },
+				{ t: <3, 0>, flags: blockS },
+				{ t: <4, 0>, flags: blockS },
+				{ t: <4, 0>, flags: blockS },
+				{ t: <4, 0>, flags: blockS },
+				
+				{ t: <2, 1> },
+				{ t: <4, 0>, flags: blockW },
+				{ t: <3, 0> },
+				{ t: <3, 0>, flags: blockE },
+				{ t: <0, 0> },
+				{ t: <1, 0> },
+				{ t: <1, 0> },
+				{ t: <1, 0> },
+				
+				{ t: <2, 1> },
+				{ t: <4, 0>, flags: blockSW },
+				{ t: <3, 0>, flags: blockS },
+				{ t: <3, 0>, flags: blockES },
+				{ t: <0, 1> },
+				{ t: <1, 1> },
+				{ t: <1, 1> },
+				{ t: <1, 1> }
+			]
+		},
+		{
+			width: 8,
+			tiles: [ Tile
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				
+				{ t: <1, 2> },
+				{ t: <1, 2> },
+				{ t: <5, 3> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				
+				{ t: <3, 3> },
+				{ t: <0, 3> },
+				{ t: <0, 1> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				
+				{ t: <3, 4>, flags: blockNEW },
+				{ t: <0, 4> },
+				{ t: <0, 1> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				
+				{ t: <5, 0> },
+				{ t: <3, 0>, flags: blockNE },
+				{ t: <0, 1> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				
+				{ t: <4, 0>, flags: blockS },
+				{ t: <4, 0>, flags: blockES },
+				{ t: <0, 1> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				
+				{ t: <1, 0> },
+				{ t: <1, 0> },
+				{ t: <5, 4> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> }
+			]
+		}
+	],
+	triggers: [ Trigger
+		{
+			position: <8, 3>,
+			type: triggerNorth,
+			script: <<
+				$move %i0 1
+				$move %a0 map2
+				$move %v0 <6, 2>
+				$sysc
+			>>
+		}
+	],
+	entities: [ Entity
+		{
+			animation: SimpleAnimation {
+				sprite: Sprite {
+					image: :"monster-map.png",
+					size: <32, 32>
+				},
+				framecount: 2,
+				frametime: 500,
+				repeat: true
+			},
+			position: <2, 1>,
+			partyLayout: monstersLayout
+			// TODO: monsters
+		},
+		{
+			sprite: Sprite {
+				image: :"tileset.png",
+				size: <32, 32>,
+				offset: <96, 32>
+			},
+			position: <2, 5>,
+			flags: 6 // TODO: hard support for flags
+		}
+	]
+}
+
+export Map map2 {
+	tileset: Sprite {
+		image: :"tileset.png",
+		size: <32, 32>
+	},
+	battlebg: :"battle-bg.png",
+	width: 2,
+	areas: [ Area
+		{
+			width: 8,
+			tiles: [ Tile
+				{ t: <3, 0>, flags: blockNW },
+				{ t: <3, 0>, flags: blockN },
+				{ t: <3, 0>, flags: blockN },
+				{ t: <3, 0>, flags: blockN },
+				{ t: <3, 0>, flags: blockN },
+				{ t: <3, 0>, flags: blockN },
+				{ t: <3, 0>, flags: blockN },
+				{ t: <3, 0>, flags: blockNE },
+				
+				{ t: <3, 0>, flags: blockW },
+				{ t: <3, 0> },
+				{ t: <3, 0>, flags: blockS },
+				{ t: <4, 0>, flags: blockS },
+				{ t: <4, 0>, flags: blockS },
+				{ t: <4, 0>, flags: blockS },
+				{ t: <4, 0> },
+				{ t: <4, 0>, flags: blockES },
+				
+				{ t: <3, 0>, flags: blockW },
+				{ t: <3, 0>, flags: blockE },
+				{ t: <0, 0> },
+				{ t: <1, 0> },
+				{ t: <1, 0> },
+				{ t: <3, 2> },
+				{ t: <4, 2>, flags: blockESW },
+				{ t: <5, 2> },
+				
+				{ t: <3, 0>, flags: blockW },
+				{ t: <3, 0>, flags: blockE },
+				{ t: <0, 1> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <1, 2> },
+				{ t: <1, 2> },
+				{ t: <1, 2> },
+				
+				{ t: <3, 0>, flags: blockW },
+				{ t: <3, 0>, flags: blockE },
+				{ t: <0, 1> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 4> },
+				{ t: <3, 4> },
+				{ t: <0, 4> },
+				
+				{ t: <3, 0>, flags: blockW },
+				{ t: <3, 0>, flags: blockE },
+				{ t: <0, 1> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <4, 1> },
+				{ t: <5, 1> },
+				{ t: <3, 1> },
+				
+				{ t: <3, 0>, flags: blockW },
+				{ t: <3, 0>, flags: blockE },
+				{ t: <0, 1> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> },
+				{ t: <2, 0> }
+			]
+		}
+	],
+	triggers: [ Trigger
+		{
+			position: <6, 2>,
+			type: triggerSouth,
+			script: <<
+				$move %i0 1
+				$move %a0 map1
+				$move %v0 <8, 3>
+				$sysc
+			>>
+		}
+	]
+}
-- 
2.39.2


From 8060b9ee74a24fe33a874732035dc8b74003439f Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Sun, 14 Oct 2012 23:07:07 +0200
Subject: [PATCH 07/16] added compare and jump codes for scripts

---
 src/common/Script.h         | 12 +++++++
 src/common/ScriptRunner.cpp | 67 ++++++++++++++++++++++++++++++++++++-
 src/common/ScriptRunner.h   | 12 +++++++
 3 files changed, 90 insertions(+), 1 deletion(-)

diff --git a/src/common/Script.h b/src/common/Script.h
index 0dbaf4d..c203f40 100644
--- a/src/common/Script.h
+++ b/src/common/Script.h
@@ -35,6 +35,18 @@ public:
 		CODE_RAND_I0,
 		CODE_RAND_I1,
 
+		CODE_CMP_I0,
+		CODE_CMP_I1,
+		CODE_CMP_I0_I1,
+
+		CODE_JUMP,
+		CODE_JUMP_EQUAL,
+		CODE_JUMP_NOT_EQUAL,
+		CODE_JUMP_LESS,
+		CODE_JUMP_LESS_EQUAL,
+		CODE_JUMP_GREATER,
+		CODE_JUMP_GREATER_EQUAL,
+
 		CODE_SYSCALL,
 	};
 
diff --git a/src/common/ScriptRunner.cpp b/src/common/ScriptRunner.cpp
index c1022c4..98fd4fb 100644
--- a/src/common/ScriptRunner.cpp
+++ b/src/common/ScriptRunner.cpp
@@ -25,7 +25,8 @@ ScriptRunner::ScriptRunner()
 , integer0(0)
 , integer1(0)
 , vector0(0, 0)
-, vector1(0, 0) {
+, vector1(0, 0)
+, compare(0) {
 
 }
 
@@ -105,6 +106,60 @@ void ScriptRunner::Exec(unsigned char code) {
 		case Script::CODE_RAND_I1:
 			integer1 = std::rand();
 			break;
+		case Script::CODE_CMP_I0:
+			Compare(integer0, PopInt());
+			break;
+		case Script::CODE_CMP_I1:
+			Compare(integer1, PopInt());
+			break;
+		case Script::CODE_CMP_I0_I1:
+			Compare(integer0, integer1);
+			break;
+		case Script::CODE_JUMP:
+			cursor = PopInt();
+			break;
+		case Script::CODE_JUMP_EQUAL: {
+			int addr(PopInt());
+			if (compare == COMPARE_EQUAL) {
+				cursor = addr;
+			}
+			break;
+		}
+		case Script::CODE_JUMP_NOT_EQUAL: {
+			int addr(PopInt());
+			if (compare != COMPARE_EQUAL) {
+				cursor = addr;
+			}
+			break;
+		}
+		case Script::CODE_JUMP_LESS: {
+			int addr(PopInt());
+			if (compare == COMPARE_LESS) {
+				cursor = addr;
+			}
+			break;
+		}
+		case Script::CODE_JUMP_LESS_EQUAL: {
+			int addr(PopInt());
+			if (compare != COMPARE_GREATER) {
+				cursor = addr;
+			}
+			break;
+		}
+		case Script::CODE_JUMP_GREATER: {
+			int addr(PopInt());
+			if (compare == COMPARE_GREATER) {
+				cursor = addr;
+			}
+			break;
+		}
+		case Script::CODE_JUMP_GREATER_EQUAL: {
+			int addr(PopInt());
+			if (compare != COMPARE_LESS) {
+				cursor = addr;
+			}
+			break;
+		}
 		case Script::CODE_SYSCALL:
 			host->HandleSyscall(*this);
 			break;
@@ -129,4 +184,14 @@ const Vector<int> &ScriptRunner::PopVector() {
 	return *vec;
 }
 
+void ScriptRunner::Compare(int lhs, int rhs) {
+	if (lhs < rhs) {
+		compare = COMPARE_LESS;
+	} else if (lhs > rhs) {
+		compare = COMPARE_GREATER;
+	} else {
+		compare = COMPARE_EQUAL;
+	}
+}
+
 }
diff --git a/src/common/ScriptRunner.h b/src/common/ScriptRunner.h
index 4751908..9b0f1ac 100644
--- a/src/common/ScriptRunner.h
+++ b/src/common/ScriptRunner.h
@@ -11,6 +11,8 @@
 #include "fwd.h"
 #include "../geometry/Vector.h"
 
+#include <SDL.h>
+
 namespace common {
 
 class ScriptRunner {
@@ -38,6 +40,14 @@ private:
 	int PopInt();
 	const geometry::Vector<int> &PopVector();
 
+	void Compare(int, int);
+
+	enum CompareFlags {
+		COMPARE_EQUAL = 0,
+		COMPARE_LESS = 1,
+		COMPARE_GREATER = 2,
+	};
+
 private:
 	ScriptHost *host;
 	const Script *script;
@@ -50,6 +60,8 @@ private:
 	geometry::Vector<int> vector0;
 	geometry::Vector<int> vector1;
 
+	Uint8 compare;
+
 };
 
 }
-- 
2.39.2


From 535f472174fd386567bec7002f645183b80cb2ef Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Sun, 14 Oct 2012 23:19:58 +0200
Subject: [PATCH 08/16] added script labels in parser/interpreter

---
 src/loader/Interpreter.cpp  | 26 ++++++++++++++++++--------
 src/loader/ParsedSource.cpp | 10 +++++++++-
 src/loader/ParsedSource.h   |  4 +++-
 src/loader/Parser.cpp       |  8 +++++++-
 4 files changed, 37 insertions(+), 11 deletions(-)

diff --git a/src/loader/Interpreter.cpp b/src/loader/Interpreter.cpp
index 0fd2d88..bd7473a 100644
--- a/src/loader/Interpreter.cpp
+++ b/src/loader/Interpreter.cpp
@@ -343,9 +343,16 @@ void Interpreter::ReadObject(int typeId, int id, char *object, const PropertyLis
 
 
 void Interpreter::ReadScript(const std::vector<ScriptToken *> &s, Script *script) {
+	std::map<string, int> labels;
 	int size(0);
 	for (vector<ScriptToken *>::const_iterator i(s.begin()), end(s.end()); i != end; ++i) {
-		if ((*i)->GetType() != ScriptToken::COMMAND) {
+		if ((*i)->GetType() == ScriptToken::LABEL) {
+			if (labels.count((*i)->Label())) {
+				throw Error("duplicate label " + (*i)->Label());
+			} else {
+				labels[(*i)->Label()] = size;
+			}
+		} else if ((*i)->GetType() != ScriptToken::COMMAND) {
 			throw Error("unexpected script token");
 		}
 		++size;
@@ -423,6 +430,9 @@ void Interpreter::ReadScript(const std::vector<ScriptToken *> &s, Script *script
 	unsigned char *text(reinterpret_cast<unsigned char *>(alloc.Alloc(size)));
 	int cursor(0);
 	for (vector<ScriptToken *>::const_iterator i(s.begin()), end(s.end()); i != end; ++i) {
+		if ((*i)->GetType() == ScriptToken::LABEL) {
+			continue;
+		}
 		if ((*i)->GetType() != ScriptToken::COMMAND) {
 			throw Error("unexpected script token");
 		}
@@ -544,9 +554,9 @@ void Interpreter::ReadScriptAddress(const ScriptToken &t, unsigned char *dest) {
 	if (t.GetType() != ScriptToken::IDENTIFIER) {
 		throw Error("expected identifier for address");
 	}
-	if (source.IsDefined(t.GetIdentifier())) {
-		const ParsedDefinition &def(GetDefinition(t.GetIdentifier()));
-		void *addr(GetObject(def.type, t.GetIdentifier()));
+	if (source.IsDefined(t.Identifier())) {
+		const ParsedDefinition &def(GetDefinition(t.Identifier()));
+		void *addr(GetObject(def.type, t.Identifier()));
 		*reinterpret_cast<void **>(dest) = addr;
 	} else {
 		throw Error("postponing values in scripts not implemented");
@@ -555,8 +565,8 @@ void Interpreter::ReadScriptAddress(const ScriptToken &t, unsigned char *dest) {
 
 void Interpreter::ReadScriptInteger(const ScriptToken &t, unsigned char *dest) {
 	if (t.GetType() == ScriptToken::IDENTIFIER) {
-		if (source.IsDefined(t.GetIdentifier())) {
-			void *num(GetObject(TypeDescription::GetTypeId("Number"), t.GetIdentifier()));
+		if (source.IsDefined(t.Identifier())) {
+			void *num(GetObject(TypeDescription::GetTypeId("Number"), t.Identifier()));
 			*reinterpret_cast<int *>(dest) = *reinterpret_cast<int *>(num);
 		} else {
 			throw Error("postponing values in scripts not implemented");
@@ -570,8 +580,8 @@ void Interpreter::ReadScriptInteger(const ScriptToken &t, unsigned char *dest) {
 
 void Interpreter::ReadScriptVector(const ScriptToken &t, unsigned char *dest) {
 	if (t.GetType() == ScriptToken::IDENTIFIER) {
-		if (source.IsDefined(t.GetIdentifier())) {
-			void *vec(GetObject(TypeDescription::GetTypeId("Vector"), t.GetIdentifier()));
+		if (source.IsDefined(t.Identifier())) {
+			void *vec(GetObject(TypeDescription::GetTypeId("Vector"), t.Identifier()));
 			*reinterpret_cast<Vector<int> *>(dest) = *reinterpret_cast<Vector<int> *>(vec);
 		} else {
 			throw Error("postponing values in scripts not implemented");
diff --git a/src/loader/ParsedSource.cpp b/src/loader/ParsedSource.cpp
index 6b2fc80..8c3d3bd 100644
--- a/src/loader/ParsedSource.cpp
+++ b/src/loader/ParsedSource.cpp
@@ -485,7 +485,7 @@ const string &ScriptToken::CommandName() const {
 	}
 }
 
-const string &ScriptToken::GetIdentifier() const {
+const string &ScriptToken::Identifier() const {
 	if (type == IDENTIFIER) {
 		return str;
 	} else {
@@ -493,6 +493,14 @@ const string &ScriptToken::GetIdentifier() const {
 	}
 }
 
+const string &ScriptToken::Label() const {
+	if (type == LABEL) {
+		return str;
+	} else {
+		throw runtime_error("access to label of non-label script token");
+	}
+}
+
 const Literal *ScriptToken::GetLiteral() const {
 	if (type == LITERAL) {
 		return literal;
diff --git a/src/loader/ParsedSource.h b/src/loader/ParsedSource.h
index 9ba5297..6a7a2d4 100644
--- a/src/loader/ParsedSource.h
+++ b/src/loader/ParsedSource.h
@@ -26,6 +26,7 @@ public:
 		REGISTER,
 		IDENTIFIER,
 		LITERAL,
+		LABEL,
 	};
 
 	ScriptToken(const std::string &, Type);
@@ -39,7 +40,8 @@ public:
 	Type GetType() const { return type; }
 	const std::string &RegisterName() const;
 	const std::string &CommandName() const;
-	const std::string &GetIdentifier() const;
+	const std::string &Identifier() const;
+	const std::string &Label() const;
 	const Literal *GetLiteral() const;
 
 private:
diff --git a/src/loader/Parser.cpp b/src/loader/Parser.cpp
index 9ddae34..9641fad 100644
--- a/src/loader/Parser.cpp
+++ b/src/loader/Parser.cpp
@@ -371,7 +371,13 @@ Literal *Parser::ParseScript() {
 						break;
 					}
 					case Token::IDENTIFIER: {
-						script.push_back(new ScriptToken(t.str, ScriptToken::IDENTIFIER));
+						Token t2(GetToken());
+						if (t2.type == Token::COLON) {
+							script.push_back(new ScriptToken(t.str, ScriptToken::LABEL));
+						} else {
+							tok.Putback(t2);
+							script.push_back(new ScriptToken(t.str, ScriptToken::IDENTIFIER));
+						}
 						break;
 					}
 					case Token::REGISTER: {
-- 
2.39.2


From 1014598c02e9635d9d4a008010d43c3c0b845e06 Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Sun, 14 Oct 2012 23:42:59 +0200
Subject: [PATCH 09/16] handle compare/jump instructions in script assembler

---
 src/loader/Interpreter.cpp | 137 +++++++++++++++++++++++++++++++++++++
 1 file changed, 137 insertions(+)

diff --git a/src/loader/Interpreter.cpp b/src/loader/Interpreter.cpp
index bd7473a..6bb022f 100644
--- a/src/loader/Interpreter.cpp
+++ b/src/loader/Interpreter.cpp
@@ -420,6 +420,58 @@ void Interpreter::ReadScript(const std::vector<ScriptToken *> &s, Script *script
 			if (i == end) {
 				throw Error("unexpected script end after rand");
 			}
+		} else if (cmd == "cmp") {
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after cmp");
+			}
+			size += sizeof(int);
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after cmp");
+			}
+		} else if (cmd == "jmp") {
+			size += sizeof(int);
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after cmp");
+			}
+		} else if (cmd == "jeq") {
+			size += sizeof(int);
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after cmp");
+			}
+		} else if (cmd == "jne") {
+			size += sizeof(int);
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after cmp");
+			}
+		} else if (cmd == "jl") {
+			size += sizeof(int);
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after cmp");
+			}
+		} else if (cmd == "jle") {
+			size += sizeof(int);
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after cmp");
+			}
+		} else if (cmd == "jg") {
+			size += sizeof(int);
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after cmp");
+			}
+		} else if (cmd == "jge") {
+			size += sizeof(int);
+			++i;
+			if (i == end) {
+				throw Error("unexpected script end after cmp");
+			}
 		} else if (cmd == "sysc") {
 
 		} else {
@@ -530,6 +582,91 @@ void Interpreter::ReadScript(const std::vector<ScriptToken *> &s, Script *script
 			} else {
 				throw Error("unexpected register " + reg);
 			}
+		} else if (cmd == "cmp") {
+			++i;
+			const string &reg((*i)->RegisterName());
+			++i;
+			if (reg == "i0") {
+				if ((*i)->GetType() == ScriptToken::REGISTER && (*i)->RegisterName() == "i1") {
+					text[cursor] = Script::CODE_CMP_I0_I1;
+					++cursor;
+				} else {
+					text[cursor] = Script::CODE_CMP_I0;
+					++cursor;
+					ReadScriptInteger(**i, text + cursor);
+					cursor += sizeof(int);
+				}
+			} else if (reg == "i1") {
+				text[cursor] = Script::CODE_CMP_I1;
+				++cursor;
+				ReadScriptInteger(**i, text + cursor);
+				cursor += sizeof(int);
+			} else {
+				throw Error("cannot use " + reg + " as lhs for comparison");
+			}
+		} else if (cmd == "jmp") {
+			text[cursor] = Script::CODE_JUMP;
+			++cursor;
+			++i;
+			if (!labels.count((*i)->Identifier())) {
+				throw Error("use of undefined label " + (*i)->Identifier());
+			}
+			*reinterpret_cast<int *>(text + cursor) = labels[(*i)->Identifier()];
+			cursor += sizeof(int);
+		} else if (cmd == "jeq") {
+			text[cursor] = Script::CODE_JUMP_EQUAL;
+			++cursor;
+			++i;
+			if (!labels.count((*i)->Identifier())) {
+				throw Error("use of undefined label " + (*i)->Identifier());
+			}
+			*reinterpret_cast<int *>(text + cursor) = labels[(*i)->Identifier()];
+			cursor += sizeof(int);
+		} else if (cmd == "jne") {
+			text[cursor] = Script::CODE_JUMP_NOT_EQUAL;
+			++cursor;
+			++i;
+			if (!labels.count((*i)->Identifier())) {
+				throw Error("use of undefined label " + (*i)->Identifier());
+			}
+			*reinterpret_cast<int *>(text + cursor) = labels[(*i)->Identifier()];
+			cursor += sizeof(int);
+		} else if (cmd == "jl") {
+			text[cursor] = Script::CODE_JUMP_LESS;
+			++cursor;
+			++i;
+			if (!labels.count((*i)->Identifier())) {
+				throw Error("use of undefined label " + (*i)->Identifier());
+			}
+			*reinterpret_cast<int *>(text + cursor) = labels[(*i)->Identifier()];
+			cursor += sizeof(int);
+		} else if (cmd == "jle") {
+			text[cursor] = Script::CODE_JUMP_LESS_EQUAL;
+			++cursor;
+			++i;
+			if (!labels.count((*i)->Identifier())) {
+				throw Error("use of undefined label " + (*i)->Identifier());
+			}
+			*reinterpret_cast<int *>(text + cursor) = labels[(*i)->Identifier()];
+			cursor += sizeof(int);
+		} else if (cmd == "jg") {
+			text[cursor] = Script::CODE_JUMP_GREATER;
+			++cursor;
+			++i;
+			if (!labels.count((*i)->Identifier())) {
+				throw Error("use of undefined label " + (*i)->Identifier());
+			}
+			*reinterpret_cast<int *>(text + cursor) = labels[(*i)->Identifier()];
+			cursor += sizeof(int);
+		} else if (cmd == "jge") {
+			text[cursor] = Script::CODE_JUMP_GREATER_EQUAL;
+			++cursor;
+			++i;
+			if (!labels.count((*i)->Identifier())) {
+				throw Error("use of undefined label " + (*i)->Identifier());
+			}
+			*reinterpret_cast<int *>(text + cursor) = labels[(*i)->Identifier()];
+			cursor += sizeof(int);
 		} else if (cmd == "sysc") {
 			text[cursor] = Script::CODE_SYSCALL;
 			++cursor;
-- 
2.39.2


From ede708d4e15a34a4443727fc64fd28946fcbeb41 Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Tue, 16 Oct 2012 22:33:33 +0200
Subject: [PATCH 10/16] commented headers in app/ directory

---
 src/app/Application.cpp | 33 ++++++++++++++++-----------------
 src/app/Application.h   | 17 +++++++++++++++--
 src/app/Arguments.h     |  2 ++
 src/app/Input.h         | 13 +++++++++++++
 src/app/State.h         | 28 +++++++++++++++++++++-------
 src/app/Timer.h         | 25 +++++++++++++++++++++++++
 src/main.cpp            |  2 +-
 7 files changed, 93 insertions(+), 27 deletions(-)

diff --git a/src/app/Application.cpp b/src/app/Application.cpp
index 4de48d4..f773cfc 100644
--- a/src/app/Application.cpp
+++ b/src/app/Application.cpp
@@ -13,12 +13,11 @@
 
 namespace app {
 
-Application::Application(sdl::InitScreen *screen, State *initialState)
+Application::Application(sdl::InitScreen &screen, State *initialState)
 : screen(screen)
 , states()
 , last(SDL_GetTicks())
 , inStateChage(false) {
-	assert(screen && "cannot create application without screen");
 	assert(initialState && "cannot create application without initial state");
 	RealPushState(initialState);
 }
@@ -86,32 +85,32 @@ void Application::PopState() {
 
 void Application::RealChangeState(State *s) {
 	if (!states.empty()) {
-		states.top()->PauseState(*this, screen->Screen());
-		states.top()->ExitState(*this, screen->Screen());
+		states.top()->PauseState(*this, screen.Screen());
+		states.top()->ExitState(*this, screen.Screen());
 		states.pop();
 	}
 	states.push(s);
-	s->EnterState(*this, screen->Screen());
-	s->ResumeState(*this, screen->Screen());
+	s->EnterState(*this, screen.Screen());
+	s->ResumeState(*this, screen.Screen());
 }
 
 void Application::RealPushState(State *s) {
 	if (!states.empty()) {
-		states.top()->PauseState(*this, screen->Screen());
+		states.top()->PauseState(*this, screen.Screen());
 	}
 	states.push(s);
-	s->EnterState(*this, screen->Screen());
-	s->ResumeState(*this, screen->Screen());
+	s->EnterState(*this, screen.Screen());
+	s->ResumeState(*this, screen.Screen());
 }
 
 void Application::RealPopState() {
 	if (states.empty()) return;
-	states.top()->PauseState(*this, screen->Screen());
-	states.top()->ExitState(*this, screen->Screen());
+	states.top()->PauseState(*this, screen.Screen());
+	states.top()->ExitState(*this, screen.Screen());
 	delete states.top();
 	states.pop();
 	if (!states.empty()) {
-		states.top()->ResumeState(*this, screen->Screen());
+		states.top()->ResumeState(*this, screen.Screen());
 	}
 }
 
@@ -121,8 +120,8 @@ void Application::Quit() {
 
 void Application::PopAllStates() {
 	while (!states.empty()) {
-		states.top()->PauseState(*this, screen->Screen());
-		states.top()->ExitState(*this, screen->Screen());
+		states.top()->PauseState(*this, screen.Screen());
+		states.top()->ExitState(*this, screen.Screen());
 		delete states.top();
 		states.pop();
 	}
@@ -165,7 +164,7 @@ void Application::HandleEvents() {
 				PopAllStates();
 				break;
 			case SDL_VIDEORESIZE:
-				screen->Resize(event.resize.w, event.resize.h);
+				screen.Resize(event.resize.w, event.resize.h);
 				CurrentState()->Resize(event.resize.w, event.resize.h);
 				break;
 			case SDL_KEYDOWN:
@@ -190,8 +189,8 @@ void Application::UpdateWorld(Uint32 deltaT) {
 
 void Application::Render(void) {
 	if (!CurrentState()) return;
-	CurrentState()->Render(screen->Screen());
-	screen->Flip();
+	CurrentState()->Render(screen.Screen());
+	screen.Flip();
 }
 
 }
diff --git a/src/app/Application.h b/src/app/Application.h
index 41198bc..df5de25 100644
--- a/src/app/Application.h
+++ b/src/app/Application.h
@@ -20,10 +20,23 @@
 
 namespace app {
 
+/// Application controller class.
+/// Operates on a state stack that can be modified via ChangeState, PushState,
+/// and PopState.
+/// All state changes are delayed until the looping mechanism gets control again
+/// (i.e. after a top level state function returns, not during).
+/// SDL key events are preprocessed, see app::Input.
+/// The quit event (typically window closed or signal received) is caught and
+/// results in immediate (that is, after the next input loop) termination.
+/// Popped states will be deleted via the plain delete operator on an app::State
+/// pointer.
+/// Timers created by GlobalTimers() operate on actual application time and are
+/// not paused when the current state is paused (as are the timers started by
+/// the app::State members).
 class Application {
 
 public:
-	Application(sdl::InitScreen *screen, State *initialState);
+	Application(sdl::InitScreen &screen, State *initialState);
 	~Application();
 private:
 	Application(const Application &);
@@ -65,7 +78,7 @@ private:
 	void Render();
 
 private:
-	sdl::InitScreen *screen;
+	sdl::InitScreen &screen;
 	std::stack<State *> states;
 	std::queue<StateCommand> stateChanges;
 	Timers<Uint32> globalTimers;
diff --git a/src/app/Arguments.h b/src/app/Arguments.h
index 7c51b7f..ace8cda 100644
--- a/src/app/Arguments.h
+++ b/src/app/Arguments.h
@@ -12,6 +12,8 @@
 
 namespace app {
 
+/// Specialized argument interpreter.
+/// Reads command line arguments via Read(int, char**) function.
 class Arguments {
 
 public:
diff --git a/src/app/Input.h b/src/app/Input.h
index 415d11f..4df4685 100644
--- a/src/app/Input.h
+++ b/src/app/Input.h
@@ -13,6 +13,19 @@
 
 namespace app {
 
+/// Maps SDL key events to virtual buttons.
+/// Records the state and whether it was pressed/released in the current
+/// iteration.
+/// Multiple buttons can be passed by ORing them bitwise.
+/// The MapKey(SDLKey, Button) function introduces a mapping for the given key
+/// to the given virtual button. Each key can be assigned to one button only,
+/// but there is no limit (well, except for memory, I guess) on how many keys
+/// may map to the same button.
+/// Each iteration should first call ResetInteractiveState() to drop the just
+/// pressed/released information and then pass each SDL_KeyboardEvent to
+/// HandleKeyboardEvent(const SDL_KeyboardEvent &).
+/// The four DEBUG_? buttons do not map to any real SNES/Lufia 2 button and may
+/// be used for debugging or non-gameplay-related input.
 class Input {
 
 public:
diff --git a/src/app/State.h b/src/app/State.h
index 958e423..41af536 100644
--- a/src/app/State.h
+++ b/src/app/State.h
@@ -15,33 +15,47 @@
 
 namespace app {
 
+/// Application state base class for use with app::Application.
 class State {
 
 public:
 	virtual ~State() { };
 
 public:
-	/// do some setup
-	/// called when the state first enters the stack
+	/// Do some setup that needs an application and/or screen handle and thus
+	/// can not be done by the constructor.
+	/// Called when the state first enters the stack.
 	/// @param ctrl the Application running the state
 	virtual void EnterState(Application &ctrl, SDL_Surface *screen) = 0;
-	/// do some cleanup
-	/// called when the state is popped from the stack
+	/// Do some cleanup.
+	/// Called when the state is popped from the stack.
 	virtual void ExitState(Application &ctrl, SDL_Surface *screen) = 0;
-	/// called when the state becomes the active one
+	/// Called when the state becomes the active one.
 	virtual void ResumeState(Application &ctrl, SDL_Surface *screen) = 0;
-	/// called when the state becomes inactive
+	/// Called when the state becomes inactive.
 	virtual void PauseState(Application &ctrl, SDL_Surface *screen) = 0;
 
-	/// adapt the state's graphics to given dimensions
+	/// Adapt the state's graphics to given dimensions.
+	/// NOTE: currently, this is only called for the stack top and not
+	///       propagated on stack changes.
+	///       Will be fixed soom ;).
 	virtual void Resize(int width, int height) = 0;
 
+	/// Handle interactive events such as input and timers.
 	virtual void HandleEvents(const Input &) = 0;
+	/// Update the time-dependant world representation.
 	virtual void UpdateWorld(float deltaT) = 0;
+	/// Draw a picture of the world.
 	virtual void Render(SDL_Surface *) = 0;
 
 public:
+	/// Timers handle intended for graphics, sync'ed with render time.
+	/// These timers are only updated for the stack top and thus appear paused
+	/// when the state is visible (roughly).
 	Timers<Uint32> &GraphicsTimers() { return graphicsTimers; }
+	/// Timers handle intended for graphics, sync'ed with world time.
+	/// These timers are only updated for the stack top and thus appear paused
+	/// when the state is visible (roughly).
 	Timers<float> &PhysicsTimers() { return physicsTimers; }
 
 private:
diff --git a/src/app/Timer.h b/src/app/Timer.h
index 13f48f3..05d295e 100644
--- a/src/app/Timer.h
+++ b/src/app/Timer.h
@@ -14,6 +14,8 @@
 
 namespace app {
 
+/// Stores timing information.
+/// For use by app::Timer.
 template<class Time>
 struct TimerData {
 
@@ -29,6 +31,9 @@ struct TimerData {
 };
 
 
+/// Timer handle.
+/// How the various information returned by the const member functions is to be
+/// interpreted highly depends on how the timer was created (by app::Timers).
 template<class Time>
 class Timer {
 
@@ -48,37 +53,50 @@ public:
 	}
 
 public:
+	/// Check if the timer was started (and not cleared) yet.
 	bool Started() const {
 		return data;
 	}
+	/// Check if the timer has reached its target time (only sensible for
+	/// countdown timers).
 	bool Finished() const {
 		return data && data->target != Time() && !data->repeat && data->time >= data->target;
 	}
+	/// Check if the timer was started and has not finished yet (in case it's a
+	/// countdown).
 	bool Running() const {
 		return data && !Finished();
 	}
+	/// Get the elapsed time since the timer started.
 	Time Elapsed() const {
 		return data ? data->time : Time();
 	}
+	/// Get the time remaining for countdowns.
 	Time Remaining() const {
 		return data ? (data->target - data->time) : Time();
 	}
+	/// Get the iteration index for interval timers.
 	int Iteration() const {
 		return (data && data->target > Time()) ? std::floor(data->time / data->target) : Time();
 	}
+	/// Check if the timer reached its interval or countdown goal this iteration.
 	bool JustHit() const {
 		return data && data->justHit;
 	}
 
+	/// Unset the timer (does not stop other handles for a shared timer).
 	void Clear() {
 		if (data) {
 			--data->refCount;
 			data = 0;
 		}
 	}
+	/// Reset the timer, do not stop it if it's running.
 	void Reset() {
 		if (data) data->time = Time();
 	}
+	/// Restart the timer.
+	/// Only works if the timer was started at least once.
 	void Restart() {
 		if (data) {
 			if (data->target > Time() && data->justHit) {
@@ -95,6 +113,7 @@ private:
 };
 
 
+/// Tracker for timers, responsible for creating and updating them.
 template<class Time>
 class Timers {
 
@@ -102,6 +121,7 @@ public:
 	Timers() { }
 
 public:
+	/// Move all timers forward by delta.
 	void Update(Time delta) {
 		for (typename std::list<TimerData<Time> >::iterator i(data.begin()), end(data.end()); i != end;) {
 			if (i->target > 0) {
@@ -117,14 +137,19 @@ public:
 			}
 		}
 	}
+	/// Start a timer that counts elapsed time until stopped manually.
 	Timer<Time> StartTimer() {
 		data.push_back(TimerData<Time>());
 		return Timer<Time>(&data.back());
 	}
+	/// Start a countdown that hits (JustHit() returing true) when duration
+	/// elapsed.
 	Timer<Time> StartCountdown(Time duration) {
 		data.push_back(TimerData<Time>(duration, false));
 		return Timer<Time>(&data.back());
 	}
+	/// Start an interval timer that hits (JustHit() returning true) each time
+	/// duration has passed.
 	Timer<Time> StartInterval(Time duration) {
 		data.push_back(TimerData<Time>(duration, true));
 		return Timer<Time>(&data.back());
diff --git a/src/main.cpp b/src/main.cpp
index 40b38f1..cd3de2a 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -310,7 +310,7 @@ int main(int argc, char **argv) {
 			state = mapState;
 		}
 
-		Application app(&screen, state);
+		Application app(screen, state);
 		app.Buttons().MapKey(SDLK_w, Input::PAD_UP);
 		app.Buttons().MapKey(SDLK_d, Input::PAD_RIGHT);
 		app.Buttons().MapKey(SDLK_s, Input::PAD_DOWN);
-- 
2.39.2


From f6691e2827a7eb8d2bdd3fbe175ecbfda09357ae Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Tue, 16 Oct 2012 22:41:01 +0200
Subject: [PATCH 11/16] commented headers in geometry directory ^^

---
 src/geometry/Vector.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/geometry/Vector.h b/src/geometry/Vector.h
index c6a42fb..ebff4b3 100644
--- a/src/geometry/Vector.h
+++ b/src/geometry/Vector.h
@@ -14,6 +14,8 @@
 
 namespace geometry {
 
+/// Basic vector class with emphasis on graphical/computational ease of use
+/// rather than mathematical accuracy ;) .
 template<class Scalar>
 class Vector {
 
-- 
2.39.2


From 65158353d1ecbed0032752863c6c4eb96b1a084a Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Tue, 16 Oct 2012 23:02:42 +0200
Subject: [PATCH 12/16] renamed state callbacks

---
 src/app/Application.cpp                | 24 ++++++++++++------------
 src/app/State.h                        |  8 ++++----
 src/battle/BattleState.cpp             |  8 ++++----
 src/battle/BattleState.h               |  8 ++++----
 src/battle/states/PerformAttacks.cpp   |  8 ++++----
 src/battle/states/PerformAttacks.h     |  8 ++++----
 src/battle/states/RunState.cpp         |  8 ++++----
 src/battle/states/RunState.h           |  8 ++++----
 src/battle/states/SelectAttackType.cpp |  8 ++++----
 src/battle/states/SelectAttackType.h   |  8 ++++----
 src/battle/states/SelectIkari.cpp      |  8 ++++----
 src/battle/states/SelectIkari.h        |  8 ++++----
 src/battle/states/SelectItem.cpp       |  8 ++++----
 src/battle/states/SelectItem.h         |  8 ++++----
 src/battle/states/SelectMoveAction.cpp |  8 ++++----
 src/battle/states/SelectMoveAction.h   |  8 ++++----
 src/battle/states/SelectSpell.cpp      |  8 ++++----
 src/battle/states/SelectSpell.h        |  8 ++++----
 src/battle/states/SelectTarget.cpp     |  8 ++++----
 src/battle/states/SelectTarget.h       |  8 ++++----
 src/battle/states/SwapHeroes.cpp       |  8 ++++----
 src/battle/states/SwapHeroes.h         |  8 ++++----
 src/graphics/ColorFade.cpp             |  8 ++++----
 src/graphics/ColorFade.h               |  8 ++++----
 src/map/MapState.cpp                   |  8 ++++----
 src/map/MapState.h                     |  8 ++++----
 src/map/TransitionState.cpp            |  8 ++++----
 src/map/TransitionState.h              |  8 ++++----
 28 files changed, 120 insertions(+), 120 deletions(-)

diff --git a/src/app/Application.cpp b/src/app/Application.cpp
index f773cfc..06ea727 100644
--- a/src/app/Application.cpp
+++ b/src/app/Application.cpp
@@ -85,32 +85,32 @@ void Application::PopState() {
 
 void Application::RealChangeState(State *s) {
 	if (!states.empty()) {
-		states.top()->PauseState(*this, screen.Screen());
-		states.top()->ExitState(*this, screen.Screen());
+		states.top()->OnPauseState(*this, screen.Screen());
+		states.top()->OnExitState(*this, screen.Screen());
 		states.pop();
 	}
 	states.push(s);
-	s->EnterState(*this, screen.Screen());
-	s->ResumeState(*this, screen.Screen());
+	s->OnEnterState(*this, screen.Screen());
+	s->OnResumeState(*this, screen.Screen());
 }
 
 void Application::RealPushState(State *s) {
 	if (!states.empty()) {
-		states.top()->PauseState(*this, screen.Screen());
+		states.top()->OnPauseState(*this, screen.Screen());
 	}
 	states.push(s);
-	s->EnterState(*this, screen.Screen());
-	s->ResumeState(*this, screen.Screen());
+	s->OnEnterState(*this, screen.Screen());
+	s->OnResumeState(*this, screen.Screen());
 }
 
 void Application::RealPopState() {
 	if (states.empty()) return;
-	states.top()->PauseState(*this, screen.Screen());
-	states.top()->ExitState(*this, screen.Screen());
+	states.top()->OnPauseState(*this, screen.Screen());
+	states.top()->OnExitState(*this, screen.Screen());
 	delete states.top();
 	states.pop();
 	if (!states.empty()) {
-		states.top()->ResumeState(*this, screen.Screen());
+		states.top()->OnResumeState(*this, screen.Screen());
 	}
 }
 
@@ -120,8 +120,8 @@ void Application::Quit() {
 
 void Application::PopAllStates() {
 	while (!states.empty()) {
-		states.top()->PauseState(*this, screen.Screen());
-		states.top()->ExitState(*this, screen.Screen());
+		states.top()->OnPauseState(*this, screen.Screen());
+		states.top()->OnExitState(*this, screen.Screen());
 		delete states.top();
 		states.pop();
 	}
diff --git a/src/app/State.h b/src/app/State.h
index 41af536..28cb94d 100644
--- a/src/app/State.h
+++ b/src/app/State.h
@@ -26,14 +26,14 @@ public:
 	/// can not be done by the constructor.
 	/// Called when the state first enters the stack.
 	/// @param ctrl the Application running the state
-	virtual void EnterState(Application &ctrl, SDL_Surface *screen) = 0;
+	virtual void OnEnterState(Application &ctrl, SDL_Surface *screen) = 0;
 	/// Do some cleanup.
 	/// Called when the state is popped from the stack.
-	virtual void ExitState(Application &ctrl, SDL_Surface *screen) = 0;
+	virtual void OnExitState(Application &ctrl, SDL_Surface *screen) = 0;
 	/// Called when the state becomes the active one.
-	virtual void ResumeState(Application &ctrl, SDL_Surface *screen) = 0;
+	virtual void OnResumeState(Application &ctrl, SDL_Surface *screen) = 0;
 	/// Called when the state becomes inactive.
-	virtual void PauseState(Application &ctrl, SDL_Surface *screen) = 0;
+	virtual void OnPauseState(Application &ctrl, SDL_Surface *screen) = 0;
 
 	/// Adapt the state's graphics to given dimensions.
 	/// NOTE: currently, this is only called for the stack top and not
diff --git a/src/battle/BattleState.cpp b/src/battle/BattleState.cpp
index dcd824e..c2310ea 100644
--- a/src/battle/BattleState.cpp
+++ b/src/battle/BattleState.cpp
@@ -79,7 +79,7 @@ void BattleState::Resize(int w, int h) {
 }
 
 
-void BattleState::EnterState(Application &ctrl, SDL_Surface *screen) {
+void BattleState::OnEnterState(Application &ctrl, SDL_Surface *screen) {
 	for (int i(0); i < 4; ++i) {
 		heroes[i].Position() = heroesLayout->CalculatePosition(i, background->w, background->h);
 		heroes[i].SpellMenu() = *res->spellMenuProperties;
@@ -130,11 +130,11 @@ void BattleState::LoadInventory() {
 	ClearAllAttacks();
 }
 
-void BattleState::ExitState(Application &ctrl, SDL_Surface *screen) {
+void BattleState::OnExitState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
-void BattleState::ResumeState(Application &ctrl, SDL_Surface *screen) {
+void BattleState::OnResumeState(Application &ctrl, SDL_Surface *screen) {
 	if (ranAway) {
 		ctrl.PopState(); // quit the battle scene
 		return;
@@ -169,7 +169,7 @@ bool BattleState::Defeat() const {
 	return true;
 }
 
-void BattleState::PauseState(Application &ctrl, SDL_Surface *screen) {
+void BattleState::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/BattleState.h b/src/battle/BattleState.h
index 60c24bc..4ac6459 100644
--- a/src/battle/BattleState.h
+++ b/src/battle/BattleState.h
@@ -56,10 +56,10 @@ public:
 	void AddHero(const Hero &);
 
 public:
-	virtual void EnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void PauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
 	virtual void Resize(int width, int height);
 
diff --git a/src/battle/states/PerformAttacks.cpp b/src/battle/states/PerformAttacks.cpp
index 19fccb0..2c82c09 100644
--- a/src/battle/states/PerformAttacks.cpp
+++ b/src/battle/states/PerformAttacks.cpp
@@ -29,23 +29,23 @@ using std::vector;
 
 namespace battle {
 
-void PerformAttacks::EnterState(Application &c, SDL_Surface *screen) {
+void PerformAttacks::OnEnterState(Application &c, SDL_Surface *screen) {
 	ctrl = &c;
 	battle->CalculateAttackOrder();
 	numberAnimation.reserve(battle->MaxMonsters() > battle->NumHeroes() + 1 ? battle->MaxMonsters() : battle->NumHeroes() + 1);
 	numberPosition.reserve(numberAnimation.size());
 }
 
-void PerformAttacks::ExitState(Application &c, SDL_Surface *screen) {
+void PerformAttacks::OnExitState(Application &c, SDL_Surface *screen) {
 	battle->ClearAllAttacks();
 	ctrl = 0;
 }
 
-void PerformAttacks::ResumeState(Application &ctrl, SDL_Surface *screen) {
+void PerformAttacks::OnResumeState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
-void PerformAttacks::PauseState(Application &ctrl, SDL_Surface *screen) {
+void PerformAttacks::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/PerformAttacks.h b/src/battle/states/PerformAttacks.h
index 19c6967..44ea74b 100644
--- a/src/battle/states/PerformAttacks.h
+++ b/src/battle/states/PerformAttacks.h
@@ -27,10 +27,10 @@ public:
 	: ctrl(0), battle(battle), moveAnimation(0), targetAnimation(0), titleBarText(0), cursor(-1) { }
 
 public:
-	virtual void EnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void PauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
 	virtual void Resize(int width, int height);
 
diff --git a/src/battle/states/RunState.cpp b/src/battle/states/RunState.cpp
index c75255c..56bcbed 100644
--- a/src/battle/states/RunState.cpp
+++ b/src/battle/states/RunState.cpp
@@ -22,19 +22,19 @@ using geometry::Vector;
 
 namespace battle {
 
-void RunState::EnterState(Application &c, SDL_Surface *screen) {
+void RunState::OnEnterState(Application &c, SDL_Surface *screen) {
 	ctrl = &c;
 }
 
-void RunState::ExitState(Application &c, SDL_Surface *screen) {
+void RunState::OnExitState(Application &c, SDL_Surface *screen) {
 	ctrl = 0;
 }
 
-void RunState::ResumeState(Application &ctrl, SDL_Surface *screen) {
+void RunState::OnResumeState(Application &ctrl, SDL_Surface *screen) {
 	timer = GraphicsTimers().StartCountdown(2500);
 }
 
-void RunState::PauseState(Application &ctrl, SDL_Surface *screen) {
+void RunState::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/RunState.h b/src/battle/states/RunState.h
index 7af5461..b1c18cb 100644
--- a/src/battle/states/RunState.h
+++ b/src/battle/states/RunState.h
@@ -22,10 +22,10 @@ public:
 	: ctrl(0), battle(battle){ }
 
 public:
-	virtual void EnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void PauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
 	virtual void Resize(int width, int height);
 
diff --git a/src/battle/states/SelectAttackType.cpp b/src/battle/states/SelectAttackType.cpp
index fbd4333..351ad1c 100644
--- a/src/battle/states/SelectAttackType.cpp
+++ b/src/battle/states/SelectAttackType.cpp
@@ -27,15 +27,15 @@ using geometry::Vector;
 
 namespace battle {
 
-void SelectAttackType::EnterState(Application &c, SDL_Surface *screen) {
+void SelectAttackType::OnEnterState(Application &c, SDL_Surface *screen) {
 	ctrl = &c;
 }
 
-void SelectAttackType::ExitState(Application &c, SDL_Surface *screen) {
+void SelectAttackType::OnExitState(Application &c, SDL_Surface *screen) {
 	ctrl = 0;
 }
 
-void SelectAttackType::ResumeState(Application &ctrl, SDL_Surface *screen) {
+void SelectAttackType::OnResumeState(Application &ctrl, SDL_Surface *screen) {
 	if (battle->ActiveHero().GetAttackChoice().Selection().HasSelected()) {
 		battle->ActiveHero().GetAttackChoice().SetType(battle->GetAttackTypeMenu().Selected());
 		battle->NextHero();
@@ -46,7 +46,7 @@ void SelectAttackType::ResumeState(Application &ctrl, SDL_Surface *screen) {
 	}
 }
 
-void SelectAttackType::PauseState(Application &ctrl, SDL_Surface *screen) {
+void SelectAttackType::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SelectAttackType.h b/src/battle/states/SelectAttackType.h
index 17298b2..6acaaef 100644
--- a/src/battle/states/SelectAttackType.h
+++ b/src/battle/states/SelectAttackType.h
@@ -22,10 +22,10 @@ public:
 	: ctrl(0), battle(battle) { }
 
 public:
-	virtual void EnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void PauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
 	virtual void Resize(int width, int height);
 
diff --git a/src/battle/states/SelectIkari.cpp b/src/battle/states/SelectIkari.cpp
index 22853ce..898b85c 100644
--- a/src/battle/states/SelectIkari.cpp
+++ b/src/battle/states/SelectIkari.cpp
@@ -24,15 +24,15 @@ using graphics::Frame;
 
 namespace battle {
 
-void SelectIkari::EnterState(Application &c, SDL_Surface *screen) {
+void SelectIkari::OnEnterState(Application &c, SDL_Surface *screen) {
 	ctrl = &c;
 }
 
-void SelectIkari::ExitState(Application &c, SDL_Surface *screen) {
+void SelectIkari::OnExitState(Application &c, SDL_Surface *screen) {
 	ctrl = 0;
 }
 
-void SelectIkari::ResumeState(Application &ctrl, SDL_Surface *screen) {
+void SelectIkari::OnResumeState(Application &ctrl, SDL_Surface *screen) {
 	if (battle->ActiveHero().GetAttackChoice().Selection().HasSelected()) {
 		battle->ActiveHero().GetAttackChoice().SetType(AttackChoice::IKARI);
 		battle->ActiveHero().GetAttackChoice().SetItem(battle->ActiveHero().IkariMenu().Selected());
@@ -40,7 +40,7 @@ void SelectIkari::ResumeState(Application &ctrl, SDL_Surface *screen) {
 	}
 }
 
-void SelectIkari::PauseState(Application &ctrl, SDL_Surface *screen) {
+void SelectIkari::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SelectIkari.h b/src/battle/states/SelectIkari.h
index 8e565c4..9e89912 100644
--- a/src/battle/states/SelectIkari.h
+++ b/src/battle/states/SelectIkari.h
@@ -23,10 +23,10 @@ public:
 	: ctrl(0), battle(battle), parent(parent) { }
 
 public:
-	virtual void EnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void PauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
 	virtual void Resize(int width, int height);
 
diff --git a/src/battle/states/SelectItem.cpp b/src/battle/states/SelectItem.cpp
index e0f6aeb..86f11c2 100644
--- a/src/battle/states/SelectItem.cpp
+++ b/src/battle/states/SelectItem.cpp
@@ -23,15 +23,15 @@ using graphics::Frame;
 
 namespace battle {
 
-void SelectItem::EnterState(Application &c, SDL_Surface *screen) {
+void SelectItem::OnEnterState(Application &c, SDL_Surface *screen) {
 	ctrl = &c;
 }
 
-void SelectItem::ExitState(Application &c, SDL_Surface *screen) {
+void SelectItem::OnExitState(Application &c, SDL_Surface *screen) {
 	ctrl = 0;
 }
 
-void SelectItem::ResumeState(Application &ctrl, SDL_Surface *screen) {
+void SelectItem::OnResumeState(Application &ctrl, SDL_Surface *screen) {
 	if (battle->ActiveHero().GetAttackChoice().Selection().HasSelected()) {
 		battle->ActiveHero().GetAttackChoice().SetType(AttackChoice::ITEM);
 		battle->ActiveHero().GetAttackChoice().SetItem(battle->ItemMenu().Selected());
@@ -39,7 +39,7 @@ void SelectItem::ResumeState(Application &ctrl, SDL_Surface *screen) {
 	}
 }
 
-void SelectItem::PauseState(Application &ctrl, SDL_Surface *screen) {
+void SelectItem::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SelectItem.h b/src/battle/states/SelectItem.h
index 3d03d2f..bf29124 100644
--- a/src/battle/states/SelectItem.h
+++ b/src/battle/states/SelectItem.h
@@ -22,10 +22,10 @@ public:
 	: ctrl(0), battle(battle), parent(parent) { }
 
 public:
-	virtual void EnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void PauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
 	virtual void Resize(int width, int height);
 
diff --git a/src/battle/states/SelectMoveAction.cpp b/src/battle/states/SelectMoveAction.cpp
index b2cac81..351116b 100644
--- a/src/battle/states/SelectMoveAction.cpp
+++ b/src/battle/states/SelectMoveAction.cpp
@@ -21,19 +21,19 @@ using geometry::Vector;
 
 namespace battle {
 
-void SelectMoveAction::EnterState(Application &c, SDL_Surface *screen) {
+void SelectMoveAction::OnEnterState(Application &c, SDL_Surface *screen) {
 	ctrl = &c;
 }
 
-void SelectMoveAction::ExitState(Application &c, SDL_Surface *screen) {
+void SelectMoveAction::OnExitState(Application &c, SDL_Surface *screen) {
 	ctrl = 0;
 }
 
-void SelectMoveAction::ResumeState(Application &ctrl, SDL_Surface *screen) {
+void SelectMoveAction::OnResumeState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
-void SelectMoveAction::PauseState(Application &ctrl, SDL_Surface *screen) {
+void SelectMoveAction::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SelectMoveAction.h b/src/battle/states/SelectMoveAction.h
index 8a28468..f302ebf 100644
--- a/src/battle/states/SelectMoveAction.h
+++ b/src/battle/states/SelectMoveAction.h
@@ -22,10 +22,10 @@ public:
 	: ctrl(0), battle(battle) { }
 
 public:
-	virtual void EnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void PauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
 	virtual void Resize(int width, int height);
 
diff --git a/src/battle/states/SelectSpell.cpp b/src/battle/states/SelectSpell.cpp
index df92733..cdf9b69 100644
--- a/src/battle/states/SelectSpell.cpp
+++ b/src/battle/states/SelectSpell.cpp
@@ -24,15 +24,15 @@ using graphics::Frame;
 
 namespace battle {
 
-void SelectSpell::EnterState(Application &c, SDL_Surface *screen) {
+void SelectSpell::OnEnterState(Application &c, SDL_Surface *screen) {
 	ctrl = &c;
 }
 
-void SelectSpell::ExitState(Application &c, SDL_Surface *screen) {
+void SelectSpell::OnExitState(Application &c, SDL_Surface *screen) {
 	ctrl = 0;
 }
 
-void SelectSpell::ResumeState(Application &ctrl, SDL_Surface *screen) {
+void SelectSpell::OnResumeState(Application &ctrl, SDL_Surface *screen) {
 	if (battle->ActiveHero().GetAttackChoice().Selection().HasSelected()) {
 		battle->ActiveHero().GetAttackChoice().SetType(AttackChoice::MAGIC);
 		battle->ActiveHero().GetAttackChoice().SetSpell(battle->ActiveHero().SpellMenu().Selected());
@@ -40,7 +40,7 @@ void SelectSpell::ResumeState(Application &ctrl, SDL_Surface *screen) {
 	}
 }
 
-void SelectSpell::PauseState(Application &ctrl, SDL_Surface *screen) {
+void SelectSpell::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SelectSpell.h b/src/battle/states/SelectSpell.h
index 38d2c39..237e662 100644
--- a/src/battle/states/SelectSpell.h
+++ b/src/battle/states/SelectSpell.h
@@ -22,10 +22,10 @@ public:
 	: ctrl(0), battle(battle), parent(parent) { }
 
 public:
-	virtual void EnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void PauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
 	virtual void Resize(int width, int height);
 
diff --git a/src/battle/states/SelectTarget.cpp b/src/battle/states/SelectTarget.cpp
index e857288..0b5b01d 100644
--- a/src/battle/states/SelectTarget.cpp
+++ b/src/battle/states/SelectTarget.cpp
@@ -19,19 +19,19 @@ using std::vector;
 
 namespace battle {
 
-void SelectTarget::EnterState(Application &c, SDL_Surface *screen) {
+void SelectTarget::OnEnterState(Application &c, SDL_Surface *screen) {
 	ctrl = &c;
 }
 
-void SelectTarget::ExitState(Application &c, SDL_Surface *screen) {
+void SelectTarget::OnExitState(Application &c, SDL_Surface *screen) {
 	ctrl = 0;
 }
 
-void SelectTarget::ResumeState(Application &ctrl, SDL_Surface *screen) {
+void SelectTarget::OnResumeState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
-void SelectTarget::PauseState(Application &ctrl, SDL_Surface *screen) {
+void SelectTarget::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SelectTarget.h b/src/battle/states/SelectTarget.h
index 9bd51f5..50d1000 100644
--- a/src/battle/states/SelectTarget.h
+++ b/src/battle/states/SelectTarget.h
@@ -23,10 +23,10 @@ public:
 	: ctrl(0), battle(battle), parent(parent), selection(selection), cursorIcon(cursorIcon), flipFlop(true) { }
 
 public:
-	virtual void EnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void PauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
 	virtual void Resize(int width, int height);
 
diff --git a/src/battle/states/SwapHeroes.cpp b/src/battle/states/SwapHeroes.cpp
index 5c83f74..0feb7e9 100644
--- a/src/battle/states/SwapHeroes.cpp
+++ b/src/battle/states/SwapHeroes.cpp
@@ -19,19 +19,19 @@ using std::vector;
 
 namespace battle {
 
-void SwapHeroes::EnterState(Application &c, SDL_Surface *screen) {
+void SwapHeroes::OnEnterState(Application &c, SDL_Surface *screen) {
 	ctrl = &c;
 }
 
-void SwapHeroes::ExitState(Application &c, SDL_Surface *screen) {
+void SwapHeroes::OnExitState(Application &c, SDL_Surface *screen) {
 	ctrl = 0;
 }
 
-void SwapHeroes::ResumeState(Application &ctrl, SDL_Surface *screen) {
+void SwapHeroes::OnResumeState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
-void SwapHeroes::PauseState(Application &ctrl, SDL_Surface *screen) {
+void SwapHeroes::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SwapHeroes.h b/src/battle/states/SwapHeroes.h
index 8ad9298..1e7602a 100644
--- a/src/battle/states/SwapHeroes.h
+++ b/src/battle/states/SwapHeroes.h
@@ -22,10 +22,10 @@ public:
 	: ctrl(0), battle(battle), parent(parent), cursor(0), selected(-1), flipFlop(true) { }
 
 public:
-	virtual void EnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void PauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
 	virtual void Resize(int width, int height);
 
diff --git a/src/graphics/ColorFade.cpp b/src/graphics/ColorFade.cpp
index e83edbb..ac45a9e 100644
--- a/src/graphics/ColorFade.cpp
+++ b/src/graphics/ColorFade.cpp
@@ -30,7 +30,7 @@ ColorFade::ColorFade(State *slave, Uint32 color, int duration, bool in, bool int
 
 }
 
-void ColorFade::EnterState(Application &c, SDL_Surface *screen) {
+void ColorFade::OnEnterState(Application &c, SDL_Surface *screen) {
 	ctrl = &c;
 	if (leadIn > 0) {
 		timer = GraphicsTimers().StartCountdown(leadIn);
@@ -40,18 +40,18 @@ void ColorFade::EnterState(Application &c, SDL_Surface *screen) {
 	}
 }
 
-void ColorFade::ExitState(Application &, SDL_Surface *screen) {
+void ColorFade::OnExitState(Application &, SDL_Surface *screen) {
 	if (blinds) {
 		SDL_FreeSurface(blinds);
 		blinds = 0;
 	}
 }
 
-void ColorFade::ResumeState(Application &ctrl, SDL_Surface *screen) {
+void ColorFade::OnResumeState(Application &ctrl, SDL_Surface *screen) {
 	UpdateBlinds(screen->w, screen->h);
 }
 
-void ColorFade::PauseState(Application &ctrl, SDL_Surface *screen) {
+void ColorFade::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
diff --git a/src/graphics/ColorFade.h b/src/graphics/ColorFade.h
index 7226a00..4ccb02b 100644
--- a/src/graphics/ColorFade.h
+++ b/src/graphics/ColorFade.h
@@ -27,10 +27,10 @@ public:
 	void SetLeadOutTime(int ms) { leadOut = ms; }
 
 public:
-	virtual void EnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void PauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
 	virtual void Resize(int width, int height);
 
diff --git a/src/map/MapState.cpp b/src/map/MapState.cpp
index 37ccc72..8103fb1 100644
--- a/src/map/MapState.cpp
+++ b/src/map/MapState.cpp
@@ -47,21 +47,21 @@ MapState::MapState(GameConfig *g, Map *map)
 }
 
 
-void MapState::EnterState(Application &c, SDL_Surface *screen) {
+void MapState::OnEnterState(Application &c, SDL_Surface *screen) {
 	ctrl = &c;
 	camera.Resize(screen->w, screen->h);
 	LoadMap(map);
 }
 
-void MapState::ExitState(Application &ctrl, SDL_Surface *screen) {
+void MapState::OnExitState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
-void MapState::ResumeState(Application &ctrl, SDL_Surface *screen) {
+void MapState::OnResumeState(Application &ctrl, SDL_Surface *screen) {
 	camera.Resize(screen->w, screen->h);
 }
 
-void MapState::PauseState(Application &ctrl, SDL_Surface *screen) {
+void MapState::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
diff --git a/src/map/MapState.h b/src/map/MapState.h
index 952bcee..35c6d64 100644
--- a/src/map/MapState.h
+++ b/src/map/MapState.h
@@ -30,10 +30,10 @@ public:
 	virtual ~MapState() { }
 
 public:
-	virtual void EnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void PauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void Resize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
diff --git a/src/map/TransitionState.cpp b/src/map/TransitionState.cpp
index 9a1d699..75a4dea 100644
--- a/src/map/TransitionState.cpp
+++ b/src/map/TransitionState.cpp
@@ -25,19 +25,19 @@ TransitionState::TransitionState(MapState *ms, Map *map, const Vector<int> &coor
 
 }
 
-void TransitionState::EnterState(Application &c, SDL_Surface *screen) {
+void TransitionState::OnEnterState(Application &c, SDL_Surface *screen) {
 	ctrl = &c;
 }
 
-void TransitionState::ExitState(Application &, SDL_Surface *screen) {
+void TransitionState::OnExitState(Application &, SDL_Surface *screen) {
 
 }
 
-void TransitionState::ResumeState(Application &ctrl, SDL_Surface *screen) {
+void TransitionState::OnResumeState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
-void TransitionState::PauseState(Application &ctrl, SDL_Surface *screen) {
+void TransitionState::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
diff --git a/src/map/TransitionState.h b/src/map/TransitionState.h
index ee832a8..844665a 100644
--- a/src/map/TransitionState.h
+++ b/src/map/TransitionState.h
@@ -22,10 +22,10 @@ public:
 	virtual ~TransitionState() { }
 
 public:
-	virtual void EnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void ResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void PauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
 	virtual void Resize(int width, int height);
 
-- 
2.39.2


From 2ccc2369d32fb680a3047519d79c17de34c4e10a Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Wed, 17 Oct 2012 20:21:56 +0200
Subject: [PATCH 13/16] renamed app::State's Resize -> OnResize

---
 src/app/Application.cpp                | 2 +-
 src/app/State.h                        | 2 +-
 src/battle/BattleState.cpp             | 2 +-
 src/battle/BattleState.h               | 2 +-
 src/battle/states/PerformAttacks.cpp   | 2 +-
 src/battle/states/PerformAttacks.h     | 2 +-
 src/battle/states/RunState.cpp         | 2 +-
 src/battle/states/RunState.h           | 2 +-
 src/battle/states/SelectAttackType.cpp | 2 +-
 src/battle/states/SelectAttackType.h   | 2 +-
 src/battle/states/SelectIkari.cpp      | 2 +-
 src/battle/states/SelectIkari.h        | 2 +-
 src/battle/states/SelectItem.cpp       | 2 +-
 src/battle/states/SelectItem.h         | 2 +-
 src/battle/states/SelectMoveAction.cpp | 2 +-
 src/battle/states/SelectMoveAction.h   | 2 +-
 src/battle/states/SelectSpell.cpp      | 2 +-
 src/battle/states/SelectSpell.h        | 2 +-
 src/battle/states/SelectTarget.cpp     | 2 +-
 src/battle/states/SelectTarget.h       | 2 +-
 src/battle/states/SwapHeroes.cpp       | 2 +-
 src/battle/states/SwapHeroes.h         | 2 +-
 src/graphics/ColorFade.cpp             | 4 ++--
 src/graphics/ColorFade.h               | 2 +-
 src/map/MapState.cpp                   | 2 +-
 src/map/MapState.h                     | 2 +-
 src/map/TransitionState.cpp            | 2 +-
 src/map/TransitionState.h              | 2 +-
 28 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/src/app/Application.cpp b/src/app/Application.cpp
index 06ea727..b84d724 100644
--- a/src/app/Application.cpp
+++ b/src/app/Application.cpp
@@ -165,7 +165,7 @@ void Application::HandleEvents() {
 				break;
 			case SDL_VIDEORESIZE:
 				screen.Resize(event.resize.w, event.resize.h);
-				CurrentState()->Resize(event.resize.w, event.resize.h);
+				CurrentState()->OnResize(event.resize.w, event.resize.h);
 				break;
 			case SDL_KEYDOWN:
 			case SDL_KEYUP:
diff --git a/src/app/State.h b/src/app/State.h
index 28cb94d..6783d76 100644
--- a/src/app/State.h
+++ b/src/app/State.h
@@ -39,7 +39,7 @@ public:
 	/// NOTE: currently, this is only called for the stack top and not
 	///       propagated on stack changes.
 	///       Will be fixed soom ;).
-	virtual void Resize(int width, int height) = 0;
+	virtual void OnResize(int width, int height) = 0;
 
 	/// Handle interactive events such as input and timers.
 	virtual void HandleEvents(const Input &) = 0;
diff --git a/src/battle/BattleState.cpp b/src/battle/BattleState.cpp
index c2310ea..d442f22 100644
--- a/src/battle/BattleState.cpp
+++ b/src/battle/BattleState.cpp
@@ -74,7 +74,7 @@ void BattleState::SwapHeroes(int lhs, int rhs) {
 }
 
 
-void BattleState::Resize(int w, int h) {
+void BattleState::OnResize(int w, int h) {
 
 }
 
diff --git a/src/battle/BattleState.h b/src/battle/BattleState.h
index 4ac6459..00cea78 100644
--- a/src/battle/BattleState.h
+++ b/src/battle/BattleState.h
@@ -61,7 +61,7 @@ public:
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
-	virtual void Resize(int width, int height);
+	virtual void OnResize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
diff --git a/src/battle/states/PerformAttacks.cpp b/src/battle/states/PerformAttacks.cpp
index 2c82c09..50c7b14 100644
--- a/src/battle/states/PerformAttacks.cpp
+++ b/src/battle/states/PerformAttacks.cpp
@@ -50,7 +50,7 @@ void PerformAttacks::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 }
 
 
-void PerformAttacks::Resize(int width, int height) {
+void PerformAttacks::OnResize(int width, int height) {
 
 }
 
diff --git a/src/battle/states/PerformAttacks.h b/src/battle/states/PerformAttacks.h
index 44ea74b..fa16b4c 100644
--- a/src/battle/states/PerformAttacks.h
+++ b/src/battle/states/PerformAttacks.h
@@ -32,7 +32,7 @@ public:
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
-	virtual void Resize(int width, int height);
+	virtual void OnResize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
diff --git a/src/battle/states/RunState.cpp b/src/battle/states/RunState.cpp
index 56bcbed..dbf3868 100644
--- a/src/battle/states/RunState.cpp
+++ b/src/battle/states/RunState.cpp
@@ -39,7 +39,7 @@ void RunState::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 }
 
 
-void RunState::Resize(int width, int height) {
+void RunState::OnResize(int width, int height) {
 
 }
 
diff --git a/src/battle/states/RunState.h b/src/battle/states/RunState.h
index b1c18cb..e2d1b1b 100644
--- a/src/battle/states/RunState.h
+++ b/src/battle/states/RunState.h
@@ -27,7 +27,7 @@ public:
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
-	virtual void Resize(int width, int height);
+	virtual void OnResize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
diff --git a/src/battle/states/SelectAttackType.cpp b/src/battle/states/SelectAttackType.cpp
index 351ad1c..c41eb67 100644
--- a/src/battle/states/SelectAttackType.cpp
+++ b/src/battle/states/SelectAttackType.cpp
@@ -51,7 +51,7 @@ void SelectAttackType::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 }
 
 
-void SelectAttackType::Resize(int width, int height) {
+void SelectAttackType::OnResize(int width, int height) {
 
 }
 
diff --git a/src/battle/states/SelectAttackType.h b/src/battle/states/SelectAttackType.h
index 6acaaef..690427f 100644
--- a/src/battle/states/SelectAttackType.h
+++ b/src/battle/states/SelectAttackType.h
@@ -27,7 +27,7 @@ public:
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
-	virtual void Resize(int width, int height);
+	virtual void OnResize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
diff --git a/src/battle/states/SelectIkari.cpp b/src/battle/states/SelectIkari.cpp
index 898b85c..1a36e41 100644
--- a/src/battle/states/SelectIkari.cpp
+++ b/src/battle/states/SelectIkari.cpp
@@ -45,7 +45,7 @@ void SelectIkari::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 }
 
 
-void SelectIkari::Resize(int width, int height) {
+void SelectIkari::OnResize(int width, int height) {
 
 }
 
diff --git a/src/battle/states/SelectIkari.h b/src/battle/states/SelectIkari.h
index 9e89912..c213b7f 100644
--- a/src/battle/states/SelectIkari.h
+++ b/src/battle/states/SelectIkari.h
@@ -28,7 +28,7 @@ public:
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
-	virtual void Resize(int width, int height);
+	virtual void OnResize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
diff --git a/src/battle/states/SelectItem.cpp b/src/battle/states/SelectItem.cpp
index 86f11c2..35a0c61 100644
--- a/src/battle/states/SelectItem.cpp
+++ b/src/battle/states/SelectItem.cpp
@@ -44,7 +44,7 @@ void SelectItem::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 }
 
 
-void SelectItem::Resize(int width, int height) {
+void SelectItem::OnResize(int width, int height) {
 
 }
 
diff --git a/src/battle/states/SelectItem.h b/src/battle/states/SelectItem.h
index bf29124..5fe98d0 100644
--- a/src/battle/states/SelectItem.h
+++ b/src/battle/states/SelectItem.h
@@ -27,7 +27,7 @@ public:
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
-	virtual void Resize(int width, int height);
+	virtual void OnResize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
diff --git a/src/battle/states/SelectMoveAction.cpp b/src/battle/states/SelectMoveAction.cpp
index 351116b..072b03d 100644
--- a/src/battle/states/SelectMoveAction.cpp
+++ b/src/battle/states/SelectMoveAction.cpp
@@ -38,7 +38,7 @@ void SelectMoveAction::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 }
 
 
-void SelectMoveAction::Resize(int width, int height) {
+void SelectMoveAction::OnResize(int width, int height) {
 
 }
 
diff --git a/src/battle/states/SelectMoveAction.h b/src/battle/states/SelectMoveAction.h
index f302ebf..2a55a92 100644
--- a/src/battle/states/SelectMoveAction.h
+++ b/src/battle/states/SelectMoveAction.h
@@ -27,7 +27,7 @@ public:
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
-	virtual void Resize(int width, int height);
+	virtual void OnResize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
diff --git a/src/battle/states/SelectSpell.cpp b/src/battle/states/SelectSpell.cpp
index cdf9b69..6ea4675 100644
--- a/src/battle/states/SelectSpell.cpp
+++ b/src/battle/states/SelectSpell.cpp
@@ -45,7 +45,7 @@ void SelectSpell::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 }
 
 
-void SelectSpell::Resize(int width, int height) {
+void SelectSpell::OnResize(int width, int height) {
 
 }
 
diff --git a/src/battle/states/SelectSpell.h b/src/battle/states/SelectSpell.h
index 237e662..823bef2 100644
--- a/src/battle/states/SelectSpell.h
+++ b/src/battle/states/SelectSpell.h
@@ -27,7 +27,7 @@ public:
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
-	virtual void Resize(int width, int height);
+	virtual void OnResize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
diff --git a/src/battle/states/SelectTarget.cpp b/src/battle/states/SelectTarget.cpp
index 0b5b01d..4645f6d 100644
--- a/src/battle/states/SelectTarget.cpp
+++ b/src/battle/states/SelectTarget.cpp
@@ -36,7 +36,7 @@ void SelectTarget::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 }
 
 
-void SelectTarget::Resize(int width, int height) {
+void SelectTarget::OnResize(int width, int height) {
 
 }
 
diff --git a/src/battle/states/SelectTarget.h b/src/battle/states/SelectTarget.h
index 50d1000..2f1f384 100644
--- a/src/battle/states/SelectTarget.h
+++ b/src/battle/states/SelectTarget.h
@@ -28,7 +28,7 @@ public:
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
-	virtual void Resize(int width, int height);
+	virtual void OnResize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
diff --git a/src/battle/states/SwapHeroes.cpp b/src/battle/states/SwapHeroes.cpp
index 0feb7e9..678b5c8 100644
--- a/src/battle/states/SwapHeroes.cpp
+++ b/src/battle/states/SwapHeroes.cpp
@@ -36,7 +36,7 @@ void SwapHeroes::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 }
 
 
-void SwapHeroes::Resize(int width, int height) {
+void SwapHeroes::OnResize(int width, int height) {
 
 }
 
diff --git a/src/battle/states/SwapHeroes.h b/src/battle/states/SwapHeroes.h
index 1e7602a..68e7360 100644
--- a/src/battle/states/SwapHeroes.h
+++ b/src/battle/states/SwapHeroes.h
@@ -27,7 +27,7 @@ public:
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
-	virtual void Resize(int width, int height);
+	virtual void OnResize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
diff --git a/src/graphics/ColorFade.cpp b/src/graphics/ColorFade.cpp
index ac45a9e..b33ee08 100644
--- a/src/graphics/ColorFade.cpp
+++ b/src/graphics/ColorFade.cpp
@@ -56,8 +56,8 @@ void ColorFade::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 }
 
 
-void ColorFade::Resize(int width, int height) {
-	slave->Resize(width, height);
+void ColorFade::OnResize(int width, int height) {
+	slave->OnResize(width, height);
 	UpdateBlinds(width, height);
 }
 
diff --git a/src/graphics/ColorFade.h b/src/graphics/ColorFade.h
index 4ccb02b..947675e 100644
--- a/src/graphics/ColorFade.h
+++ b/src/graphics/ColorFade.h
@@ -32,7 +32,7 @@ public:
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
-	virtual void Resize(int width, int height);
+	virtual void OnResize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
diff --git a/src/map/MapState.cpp b/src/map/MapState.cpp
index 8103fb1..7e42e13 100644
--- a/src/map/MapState.cpp
+++ b/src/map/MapState.cpp
@@ -65,7 +65,7 @@ void MapState::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 }
 
-void MapState::Resize(int width, int height) {
+void MapState::OnResize(int width, int height) {
 	camera.Resize(width, height);
 }
 
diff --git a/src/map/MapState.h b/src/map/MapState.h
index 35c6d64..c5f26e1 100644
--- a/src/map/MapState.h
+++ b/src/map/MapState.h
@@ -34,7 +34,7 @@ public:
 	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void Resize(int width, int height);
+	virtual void OnResize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
diff --git a/src/map/TransitionState.cpp b/src/map/TransitionState.cpp
index 75a4dea..1a2afb5 100644
--- a/src/map/TransitionState.cpp
+++ b/src/map/TransitionState.cpp
@@ -42,7 +42,7 @@ void TransitionState::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 }
 
 
-void TransitionState::Resize(int width, int height) {
+void TransitionState::OnResize(int width, int height) {
 
 }
 
diff --git a/src/map/TransitionState.h b/src/map/TransitionState.h
index 844665a..2a99f1a 100644
--- a/src/map/TransitionState.h
+++ b/src/map/TransitionState.h
@@ -27,7 +27,7 @@ public:
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
 
-	virtual void Resize(int width, int height);
+	virtual void OnResize(int width, int height);
 
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
-- 
2.39.2


From 7252571fb926a187c4c40e8f4eec718f16d63ffa Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Wed, 17 Oct 2012 20:44:51 +0200
Subject: [PATCH 14/16] wrapped some virtual State methods in non-virtual calls

---
 Debug/src/app/subdir.mk              |  9 ++++---
 Release/src/app/subdir.mk            |  9 ++++---
 src/app/Application.cpp              | 26 +++++++++----------
 src/app/State.cpp                    | 37 ++++++++++++++++++++++++++++
 src/app/State.h                      | 29 ++++++++++++++++------
 src/battle/BattleState.h             | 15 +++++------
 src/battle/states/PerformAttacks.h   |  9 ++++---
 src/battle/states/RunState.h         | 10 +++++---
 src/battle/states/SelectAttackType.h |  9 ++++---
 src/battle/states/SelectIkari.h      |  9 ++++---
 src/battle/states/SelectItem.h       |  9 ++++---
 src/battle/states/SelectMoveAction.h |  9 ++++---
 src/battle/states/SelectSpell.h      |  9 ++++---
 src/battle/states/SelectTarget.h     |  9 ++++---
 src/battle/states/SwapHeroes.h       |  9 ++++---
 src/graphics/ColorFade.cpp           |  2 +-
 src/graphics/ColorFade.h             |  9 ++++---
 src/map/MapState.h                   | 14 ++++++-----
 src/map/TransitionState.h            |  9 ++++---
 19 files changed, 156 insertions(+), 85 deletions(-)
 create mode 100644 src/app/State.cpp

diff --git a/Debug/src/app/subdir.mk b/Debug/src/app/subdir.mk
index 8fad388..caae915 100644
--- a/Debug/src/app/subdir.mk
+++ b/Debug/src/app/subdir.mk
@@ -6,17 +6,20 @@
 CPP_SRCS += \
 ../src/app/Application.cpp \
 ../src/app/Arguments.cpp \
-../src/app/Input.cpp 
+../src/app/Input.cpp \
+../src/app/State.cpp 
 
 OBJS += \
 ./src/app/Application.o \
 ./src/app/Arguments.o \
-./src/app/Input.o 
+./src/app/Input.o \
+./src/app/State.o 
 
 CPP_DEPS += \
 ./src/app/Application.d \
 ./src/app/Arguments.d \
-./src/app/Input.d 
+./src/app/Input.d \
+./src/app/State.d 
 
 
 # Each subdirectory must supply rules for building sources it contributes
diff --git a/Release/src/app/subdir.mk b/Release/src/app/subdir.mk
index cf54190..57cbd25 100644
--- a/Release/src/app/subdir.mk
+++ b/Release/src/app/subdir.mk
@@ -6,17 +6,20 @@
 CPP_SRCS += \
 ../src/app/Application.cpp \
 ../src/app/Arguments.cpp \
-../src/app/Input.cpp 
+../src/app/Input.cpp \
+../src/app/State.cpp 
 
 OBJS += \
 ./src/app/Application.o \
 ./src/app/Arguments.o \
-./src/app/Input.o 
+./src/app/Input.o \
+./src/app/State.o 
 
 CPP_DEPS += \
 ./src/app/Application.d \
 ./src/app/Arguments.d \
-./src/app/Input.d 
+./src/app/Input.d \
+./src/app/State.d 
 
 
 # Each subdirectory must supply rules for building sources it contributes
diff --git a/src/app/Application.cpp b/src/app/Application.cpp
index b84d724..f773cfc 100644
--- a/src/app/Application.cpp
+++ b/src/app/Application.cpp
@@ -85,32 +85,32 @@ void Application::PopState() {
 
 void Application::RealChangeState(State *s) {
 	if (!states.empty()) {
-		states.top()->OnPauseState(*this, screen.Screen());
-		states.top()->OnExitState(*this, screen.Screen());
+		states.top()->PauseState(*this, screen.Screen());
+		states.top()->ExitState(*this, screen.Screen());
 		states.pop();
 	}
 	states.push(s);
-	s->OnEnterState(*this, screen.Screen());
-	s->OnResumeState(*this, screen.Screen());
+	s->EnterState(*this, screen.Screen());
+	s->ResumeState(*this, screen.Screen());
 }
 
 void Application::RealPushState(State *s) {
 	if (!states.empty()) {
-		states.top()->OnPauseState(*this, screen.Screen());
+		states.top()->PauseState(*this, screen.Screen());
 	}
 	states.push(s);
-	s->OnEnterState(*this, screen.Screen());
-	s->OnResumeState(*this, screen.Screen());
+	s->EnterState(*this, screen.Screen());
+	s->ResumeState(*this, screen.Screen());
 }
 
 void Application::RealPopState() {
 	if (states.empty()) return;
-	states.top()->OnPauseState(*this, screen.Screen());
-	states.top()->OnExitState(*this, screen.Screen());
+	states.top()->PauseState(*this, screen.Screen());
+	states.top()->ExitState(*this, screen.Screen());
 	delete states.top();
 	states.pop();
 	if (!states.empty()) {
-		states.top()->OnResumeState(*this, screen.Screen());
+		states.top()->ResumeState(*this, screen.Screen());
 	}
 }
 
@@ -120,8 +120,8 @@ void Application::Quit() {
 
 void Application::PopAllStates() {
 	while (!states.empty()) {
-		states.top()->OnPauseState(*this, screen.Screen());
-		states.top()->OnExitState(*this, screen.Screen());
+		states.top()->PauseState(*this, screen.Screen());
+		states.top()->ExitState(*this, screen.Screen());
 		delete states.top();
 		states.pop();
 	}
@@ -165,7 +165,7 @@ void Application::HandleEvents() {
 				break;
 			case SDL_VIDEORESIZE:
 				screen.Resize(event.resize.w, event.resize.h);
-				CurrentState()->OnResize(event.resize.w, event.resize.h);
+				CurrentState()->Resize(event.resize.w, event.resize.h);
 				break;
 			case SDL_KEYDOWN:
 			case SDL_KEYUP:
diff --git a/src/app/State.cpp b/src/app/State.cpp
new file mode 100644
index 0000000..50b5bf6
--- /dev/null
+++ b/src/app/State.cpp
@@ -0,0 +1,37 @@
+/*
+ * State.cpp
+ *
+ *  Created on: Oct 17, 2012
+ *      Author: holy
+ */
+
+#include "State.h"
+
+namespace app {
+
+State::~State() {
+
+}
+
+
+void State::EnterState(Application &ctrl, SDL_Surface *screen) {
+	OnEnterState(ctrl, screen);
+}
+
+void State::ExitState(Application &ctrl, SDL_Surface *screen) {
+	OnExitState(ctrl, screen);
+}
+
+void State::ResumeState(Application &ctrl, SDL_Surface *screen) {
+	OnResumeState(ctrl, screen);
+}
+
+void State::PauseState(Application &ctrl, SDL_Surface *screen) {
+	OnPauseState(ctrl, screen);
+}
+
+void State::Resize(int width, int height) {
+	OnResize(width, height);
+}
+
+}
diff --git a/src/app/State.h b/src/app/State.h
index 6783d76..a84afde 100644
--- a/src/app/State.h
+++ b/src/app/State.h
@@ -19,9 +19,29 @@ namespace app {
 class State {
 
 public:
-	virtual ~State() { };
+	virtual ~State();
 
 public:
+	/// Called by Application when pushing this state.
+	void EnterState(Application &ctrl, SDL_Surface *screen);
+	/// Called by Application when popping this state.
+	void ExitState(Application &ctrl, SDL_Surface *screen);
+	/// Called by Application when this state becomes the top state.
+	void ResumeState(Application &ctrl, SDL_Surface *screen);
+	/// Called by Application when this state no longer is the top state.
+	void PauseState(Application &ctrl, SDL_Surface *screen);
+
+	/// Called by Application on SDL window resize events.
+	void Resize(int width, int height);
+
+	/// Handle interactive events such as input and timers.
+	virtual void HandleEvents(const Input &) = 0;
+	/// Update the time-dependant world representation.
+	virtual void UpdateWorld(float deltaT) = 0;
+	/// Draw a picture of the world.
+	virtual void Render(SDL_Surface *) = 0;
+
+private:
 	/// Do some setup that needs an application and/or screen handle and thus
 	/// can not be done by the constructor.
 	/// Called when the state first enters the stack.
@@ -41,13 +61,6 @@ public:
 	///       Will be fixed soom ;).
 	virtual void OnResize(int width, int height) = 0;
 
-	/// Handle interactive events such as input and timers.
-	virtual void HandleEvents(const Input &) = 0;
-	/// Update the time-dependant world representation.
-	virtual void UpdateWorld(float deltaT) = 0;
-	/// Draw a picture of the world.
-	virtual void Render(SDL_Surface *) = 0;
-
 public:
 	/// Timers handle intended for graphics, sync'ed with render time.
 	/// These timers are only updated for the stack top and thus appear paused
diff --git a/src/battle/BattleState.h b/src/battle/BattleState.h
index 00cea78..cc9eaf1 100644
--- a/src/battle/BattleState.h
+++ b/src/battle/BattleState.h
@@ -56,13 +56,6 @@ public:
 	void AddHero(const Hero &);
 
 public:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
-
-	virtual void OnResize(int width, int height);
-
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
 	virtual void Render(SDL_Surface *);
@@ -137,6 +130,14 @@ public:
 	void RenderHeroTags(SDL_Surface *screen, const geometry::Vector<int> &offset);
 	void RenderSmallHeroTags(SDL_Surface *screen, const geometry::Vector<int> &offset);
 
+private:
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+
+	virtual void OnResize(int width, int height);
+
 private:
 	void LoadInventory();
 
diff --git a/src/battle/states/PerformAttacks.h b/src/battle/states/PerformAttacks.h
index fa16b4c..e52160c 100644
--- a/src/battle/states/PerformAttacks.h
+++ b/src/battle/states/PerformAttacks.h
@@ -27,6 +27,11 @@ public:
 	: ctrl(0), battle(battle), moveAnimation(0), targetAnimation(0), titleBarText(0), cursor(-1) { }
 
 public:
+	virtual void HandleEvents(const app::Input &);
+	virtual void UpdateWorld(float deltaT);
+	virtual void Render(SDL_Surface *);
+
+private:
 	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
@@ -34,10 +39,6 @@ public:
 
 	virtual void OnResize(int width, int height);
 
-	virtual void HandleEvents(const app::Input &);
-	virtual void UpdateWorld(float deltaT);
-	virtual void Render(SDL_Surface *);
-
 private:
 	void CheckAnimations();
 	bool HasAnimationsRunning() const;
diff --git a/src/battle/states/RunState.h b/src/battle/states/RunState.h
index e2d1b1b..0f2818d 100644
--- a/src/battle/states/RunState.h
+++ b/src/battle/states/RunState.h
@@ -22,6 +22,12 @@ public:
 	: ctrl(0), battle(battle){ }
 
 public:
+
+	virtual void HandleEvents(const app::Input &);
+	virtual void UpdateWorld(float deltaT);
+	virtual void Render(SDL_Surface *);
+
+private:
 	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
@@ -29,10 +35,6 @@ public:
 
 	virtual void OnResize(int width, int height);
 
-	virtual void HandleEvents(const app::Input &);
-	virtual void UpdateWorld(float deltaT);
-	virtual void Render(SDL_Surface *);
-
 private:
 	void RenderTitleBar(SDL_Surface *screen, const geometry::Vector<int> &offset);
 
diff --git a/src/battle/states/SelectAttackType.h b/src/battle/states/SelectAttackType.h
index 690427f..557602f 100644
--- a/src/battle/states/SelectAttackType.h
+++ b/src/battle/states/SelectAttackType.h
@@ -22,6 +22,11 @@ public:
 	: ctrl(0), battle(battle) { }
 
 public:
+	virtual void HandleEvents(const app::Input &);
+	virtual void UpdateWorld(float deltaT);
+	virtual void Render(SDL_Surface *);
+
+private:
 	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
@@ -29,10 +34,6 @@ public:
 
 	virtual void OnResize(int width, int height);
 
-	virtual void HandleEvents(const app::Input &);
-	virtual void UpdateWorld(float deltaT);
-	virtual void Render(SDL_Surface *);
-
 private:
 	void RenderMenu(SDL_Surface *screen, const geometry::Vector<int> &offset);
 
diff --git a/src/battle/states/SelectIkari.h b/src/battle/states/SelectIkari.h
index c213b7f..a7383a0 100644
--- a/src/battle/states/SelectIkari.h
+++ b/src/battle/states/SelectIkari.h
@@ -23,6 +23,11 @@ public:
 	: ctrl(0), battle(battle), parent(parent) { }
 
 public:
+	virtual void HandleEvents(const app::Input &);
+	virtual void UpdateWorld(float deltaT);
+	virtual void Render(SDL_Surface *);
+
+private:
 	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
@@ -30,10 +35,6 @@ public:
 
 	virtual void OnResize(int width, int height);
 
-	virtual void HandleEvents(const app::Input &);
-	virtual void UpdateWorld(float deltaT);
-	virtual void Render(SDL_Surface *);
-
 private:
 	void RenderFrame(SDL_Surface *, const geometry::Vector<int> &offset);
 	void RenderHeadline(SDL_Surface *, const geometry::Vector<int> &offset);
diff --git a/src/battle/states/SelectItem.h b/src/battle/states/SelectItem.h
index 5fe98d0..e3d2168 100644
--- a/src/battle/states/SelectItem.h
+++ b/src/battle/states/SelectItem.h
@@ -22,6 +22,11 @@ public:
 	: ctrl(0), battle(battle), parent(parent) { }
 
 public:
+	virtual void HandleEvents(const app::Input &);
+	virtual void UpdateWorld(float deltaT);
+	virtual void Render(SDL_Surface *);
+
+private:
 	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
@@ -29,10 +34,6 @@ public:
 
 	virtual void OnResize(int width, int height);
 
-	virtual void HandleEvents(const app::Input &);
-	virtual void UpdateWorld(float deltaT);
-	virtual void Render(SDL_Surface *);
-
 private:
 	void RenderFrame(SDL_Surface *, const geometry::Vector<int> &offset);
 	void RenderHeadline(SDL_Surface *, const geometry::Vector<int> &offset);
diff --git a/src/battle/states/SelectMoveAction.h b/src/battle/states/SelectMoveAction.h
index 2a55a92..bb04fb5 100644
--- a/src/battle/states/SelectMoveAction.h
+++ b/src/battle/states/SelectMoveAction.h
@@ -22,6 +22,11 @@ public:
 	: ctrl(0), battle(battle) { }
 
 public:
+	virtual void HandleEvents(const app::Input &);
+	virtual void UpdateWorld(float deltaT);
+	virtual void Render(SDL_Surface *);
+
+private:
 	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
@@ -29,10 +34,6 @@ public:
 
 	virtual void OnResize(int width, int height);
 
-	virtual void HandleEvents(const app::Input &);
-	virtual void UpdateWorld(float deltaT);
-	virtual void Render(SDL_Surface *);
-
 private:
 	void RenderMenu(SDL_Surface *screen, const geometry::Vector<int> &offset);
 
diff --git a/src/battle/states/SelectSpell.h b/src/battle/states/SelectSpell.h
index 823bef2..7a0bad4 100644
--- a/src/battle/states/SelectSpell.h
+++ b/src/battle/states/SelectSpell.h
@@ -22,6 +22,11 @@ public:
 	: ctrl(0), battle(battle), parent(parent) { }
 
 public:
+	virtual void HandleEvents(const app::Input &);
+	virtual void UpdateWorld(float deltaT);
+	virtual void Render(SDL_Surface *);
+
+private:
 	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
@@ -29,10 +34,6 @@ public:
 
 	virtual void OnResize(int width, int height);
 
-	virtual void HandleEvents(const app::Input &);
-	virtual void UpdateWorld(float deltaT);
-	virtual void Render(SDL_Surface *);
-
 private:
 	void RenderFrame(SDL_Surface *, const geometry::Vector<int> &offset);
 	void RenderHeadline(SDL_Surface *, const geometry::Vector<int> &offset);
diff --git a/src/battle/states/SelectTarget.h b/src/battle/states/SelectTarget.h
index 2f1f384..4549036 100644
--- a/src/battle/states/SelectTarget.h
+++ b/src/battle/states/SelectTarget.h
@@ -23,6 +23,11 @@ public:
 	: ctrl(0), battle(battle), parent(parent), selection(selection), cursorIcon(cursorIcon), flipFlop(true) { }
 
 public:
+	virtual void HandleEvents(const app::Input &);
+	virtual void UpdateWorld(float deltaT);
+	virtual void Render(SDL_Surface *);
+
+private:
 	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
@@ -30,10 +35,6 @@ public:
 
 	virtual void OnResize(int width, int height);
 
-	virtual void HandleEvents(const app::Input &);
-	virtual void UpdateWorld(float deltaT);
-	virtual void Render(SDL_Surface *);
-
 private:
 	void RenderCursors(SDL_Surface *screen, const geometry::Vector<int> &offset);
 
diff --git a/src/battle/states/SwapHeroes.h b/src/battle/states/SwapHeroes.h
index 68e7360..a5f5c62 100644
--- a/src/battle/states/SwapHeroes.h
+++ b/src/battle/states/SwapHeroes.h
@@ -22,6 +22,11 @@ public:
 	: ctrl(0), battle(battle), parent(parent), cursor(0), selected(-1), flipFlop(true) { }
 
 public:
+	virtual void HandleEvents(const app::Input &);
+	virtual void UpdateWorld(float deltaT);
+	virtual void Render(SDL_Surface *);
+
+private:
 	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
@@ -29,10 +34,6 @@ public:
 
 	virtual void OnResize(int width, int height);
 
-	virtual void HandleEvents(const app::Input &);
-	virtual void UpdateWorld(float deltaT);
-	virtual void Render(SDL_Surface *);
-
 private:
 	void MoveUp();
 	void MoveRight();
diff --git a/src/graphics/ColorFade.cpp b/src/graphics/ColorFade.cpp
index b33ee08..196b0d8 100644
--- a/src/graphics/ColorFade.cpp
+++ b/src/graphics/ColorFade.cpp
@@ -57,7 +57,7 @@ void ColorFade::OnPauseState(Application &ctrl, SDL_Surface *screen) {
 
 
 void ColorFade::OnResize(int width, int height) {
-	slave->OnResize(width, height);
+	slave->Resize(width, height);
 	UpdateBlinds(width, height);
 }
 
diff --git a/src/graphics/ColorFade.h b/src/graphics/ColorFade.h
index 947675e..2694272 100644
--- a/src/graphics/ColorFade.h
+++ b/src/graphics/ColorFade.h
@@ -27,6 +27,11 @@ public:
 	void SetLeadOutTime(int ms) { leadOut = ms; }
 
 public:
+	virtual void HandleEvents(const app::Input &);
+	virtual void UpdateWorld(float deltaT);
+	virtual void Render(SDL_Surface *);
+
+private:
 	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
@@ -34,10 +39,6 @@ public:
 
 	virtual void OnResize(int width, int height);
 
-	virtual void HandleEvents(const app::Input &);
-	virtual void UpdateWorld(float deltaT);
-	virtual void Render(SDL_Surface *);
-
 private:
 	void UpdateBlinds(int width, int height);
 	Uint8 GetAlpha() const;
diff --git a/src/map/MapState.h b/src/map/MapState.h
index c5f26e1..fcea893 100644
--- a/src/map/MapState.h
+++ b/src/map/MapState.h
@@ -30,12 +30,6 @@ public:
 	virtual ~MapState() { }
 
 public:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResize(int width, int height);
-
 	virtual void HandleEvents(const app::Input &);
 	virtual void UpdateWorld(float deltaT);
 	virtual void Render(SDL_Surface *);
@@ -50,6 +44,14 @@ public:
 
 	virtual void HandleSyscall(common::ScriptRunner &);
 
+private:
+	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+
+	virtual void OnResize(int width, int height);
+
 private:
 	static bool ZCompare(const Entity *lhs, const Entity *rhs);
 
diff --git a/src/map/TransitionState.h b/src/map/TransitionState.h
index 2a99f1a..0dfa7cf 100644
--- a/src/map/TransitionState.h
+++ b/src/map/TransitionState.h
@@ -22,6 +22,11 @@ public:
 	virtual ~TransitionState() { }
 
 public:
+	virtual void HandleEvents(const app::Input &);
+	virtual void UpdateWorld(float deltaT);
+	virtual void Render(SDL_Surface *);
+
+private:
 	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
 	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
@@ -29,10 +34,6 @@ public:
 
 	virtual void OnResize(int width, int height);
 
-	virtual void HandleEvents(const app::Input &);
-	virtual void UpdateWorld(float deltaT);
-	virtual void Render(SDL_Surface *);
-
 private:
 	app::Application *ctrl;
 	MapState *ms;
-- 
2.39.2


From 3f8fac16c7ae2cbe7da47b98aba9b558825723e7 Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Wed, 17 Oct 2012 21:14:31 +0200
Subject: [PATCH 15/16] store an application handle in each state

---
 src/app/State.cpp                      | 36 +++++++++++++++++++++++---
 src/app/State.h                        |  9 +++++++
 src/battle/states/PerformAttacks.cpp   |  4 +--
 src/battle/states/PerformAttacks.h     |  3 +--
 src/battle/states/RunState.cpp         |  6 ++---
 src/battle/states/RunState.h           |  3 +--
 src/battle/states/SelectAttackType.cpp | 16 ++++++------
 src/battle/states/SelectAttackType.h   |  3 +--
 src/battle/states/SelectIkari.cpp      | 10 +++----
 src/battle/states/SelectIkari.h        |  3 +--
 src/battle/states/SelectItem.cpp       | 10 +++----
 src/battle/states/SelectItem.h         |  3 +--
 src/battle/states/SelectMoveAction.cpp | 10 +++----
 src/battle/states/SelectMoveAction.h   |  3 +--
 src/battle/states/SelectSpell.cpp      | 10 +++----
 src/battle/states/SelectSpell.h        |  3 +--
 src/battle/states/SelectTarget.cpp     | 10 +++----
 src/battle/states/SelectTarget.h       |  3 +--
 src/battle/states/SwapHeroes.cpp       |  6 ++---
 src/battle/states/SwapHeroes.h         |  3 +--
 src/graphics/ColorFade.cpp             |  8 +++---
 src/graphics/ColorFade.h               |  1 -
 src/map/MapState.cpp                   | 14 +++++-----
 src/map/MapState.h                     |  1 -
 src/map/TransitionState.cpp            |  7 +++--
 src/map/TransitionState.h              |  1 -
 26 files changed, 102 insertions(+), 84 deletions(-)

diff --git a/src/app/State.cpp b/src/app/State.cpp
index 50b5bf6..f1c7712 100644
--- a/src/app/State.cpp
+++ b/src/app/State.cpp
@@ -7,19 +7,30 @@
 
 #include "State.h"
 
+#include <stdexcept>
+
+using std::domain_error;
+
 namespace app {
 
+State::State()
+: ctrl(0) {
+
+}
+
 State::~State() {
 
 }
 
 
-void State::EnterState(Application &ctrl, SDL_Surface *screen) {
-	OnEnterState(ctrl, screen);
+void State::EnterState(Application &c, SDL_Surface *screen) {
+	ctrl = &c;
+	OnEnterState(c, screen);
 }
 
-void State::ExitState(Application &ctrl, SDL_Surface *screen) {
-	OnExitState(ctrl, screen);
+void State::ExitState(Application &c, SDL_Surface *screen) {
+	OnExitState(c, screen);
+	ctrl = 0;
 }
 
 void State::ResumeState(Application &ctrl, SDL_Surface *screen) {
@@ -34,4 +45,21 @@ void State::Resize(int width, int height) {
 	OnResize(width, height);
 }
 
+
+Application &State::Ctrl() {
+	if (ctrl) {
+		return *ctrl;
+	} else {
+		throw domain_error("call to app::State::Ctrl() without application context");
+	}
+}
+
+const Application &State::Ctrl() const {
+	if (ctrl) {
+		return *ctrl;
+	} else {
+		throw domain_error("call to app::State::Ctrl() without application context");
+	}
+}
+
 }
diff --git a/src/app/State.h b/src/app/State.h
index a84afde..2a4b5e1 100644
--- a/src/app/State.h
+++ b/src/app/State.h
@@ -19,6 +19,7 @@ namespace app {
 class State {
 
 public:
+	State();
 	virtual ~State();
 
 public:
@@ -41,6 +42,13 @@ public:
 	/// Draw a picture of the world.
 	virtual void Render(SDL_Surface *) = 0;
 
+protected:
+	/// Get a handle to the application this state is running on.
+	/// Do not call this while the state is off the stack (e.g. in c'tor/d'tor)
+	/// or you'll get a std::domain_error (potentially evil in d'tor)!
+	Application &Ctrl();
+	const Application &Ctrl() const;
+
 private:
 	/// Do some setup that needs an application and/or screen handle and thus
 	/// can not be done by the constructor.
@@ -72,6 +80,7 @@ public:
 	Timers<float> &PhysicsTimers() { return physicsTimers; }
 
 private:
+	Application *ctrl;
 	Timers<Uint32> graphicsTimers;
 	Timers<float> physicsTimers;
 
diff --git a/src/battle/states/PerformAttacks.cpp b/src/battle/states/PerformAttacks.cpp
index 50c7b14..a1a5b8b 100644
--- a/src/battle/states/PerformAttacks.cpp
+++ b/src/battle/states/PerformAttacks.cpp
@@ -30,7 +30,6 @@ using std::vector;
 namespace battle {
 
 void PerformAttacks::OnEnterState(Application &c, SDL_Surface *screen) {
-	ctrl = &c;
 	battle->CalculateAttackOrder();
 	numberAnimation.reserve(battle->MaxMonsters() > battle->NumHeroes() + 1 ? battle->MaxMonsters() : battle->NumHeroes() + 1);
 	numberPosition.reserve(numberAnimation.size());
@@ -38,7 +37,6 @@ void PerformAttacks::OnEnterState(Application &c, SDL_Surface *screen) {
 
 void PerformAttacks::OnExitState(Application &c, SDL_Surface *screen) {
 	battle->ClearAllAttacks();
-	ctrl = 0;
 }
 
 void PerformAttacks::OnResumeState(Application &ctrl, SDL_Surface *screen) {
@@ -62,7 +60,7 @@ void PerformAttacks::HandleEvents(const Input &input) {
 	battle->ApplyDamage();
 	battle->NextAttack();
 	if (battle->AttacksFinished()) {
-		ctrl->PopState();
+		Ctrl().PopState();
 		return;
 	}
 
diff --git a/src/battle/states/PerformAttacks.h b/src/battle/states/PerformAttacks.h
index e52160c..2fe9a06 100644
--- a/src/battle/states/PerformAttacks.h
+++ b/src/battle/states/PerformAttacks.h
@@ -24,7 +24,7 @@ class PerformAttacks
 
 public:
 	explicit PerformAttacks(BattleState *battle)
-	: ctrl(0), battle(battle), moveAnimation(0), targetAnimation(0), titleBarText(0), cursor(-1) { }
+	: battle(battle), moveAnimation(0), targetAnimation(0), titleBarText(0), cursor(-1) { }
 
 public:
 	virtual void HandleEvents(const app::Input &);
@@ -52,7 +52,6 @@ private:
 	void RenderTargetAnimation(SDL_Surface *screen, const geometry::Vector<int> &offset) const;
 
 private:
-	app::Application *ctrl;
 	BattleState *battle;
 	graphics::AnimationRunner moveAnimation;
 	graphics::AnimationRunner targetAnimation;
diff --git a/src/battle/states/RunState.cpp b/src/battle/states/RunState.cpp
index dbf3868..cf113f2 100644
--- a/src/battle/states/RunState.cpp
+++ b/src/battle/states/RunState.cpp
@@ -23,11 +23,11 @@ using geometry::Vector;
 namespace battle {
 
 void RunState::OnEnterState(Application &c, SDL_Surface *screen) {
-	ctrl = &c;
+
 }
 
 void RunState::OnExitState(Application &c, SDL_Surface *screen) {
-	ctrl = 0;
+
 }
 
 void RunState::OnResumeState(Application &ctrl, SDL_Surface *screen) {
@@ -47,7 +47,7 @@ void RunState::OnResize(int width, int height) {
 void RunState::HandleEvents(const Input &input) {
 	if (timer.Finished()) {
 		battle->SetRunaway();
-		ctrl->PopState(); // pop self
+		Ctrl().PopState(); // pop self
 	}
 }
 
diff --git a/src/battle/states/RunState.h b/src/battle/states/RunState.h
index 0f2818d..9cee764 100644
--- a/src/battle/states/RunState.h
+++ b/src/battle/states/RunState.h
@@ -19,7 +19,7 @@ class RunState
 
 public:
 	explicit RunState(BattleState *battle)
-	: ctrl(0), battle(battle){ }
+	: battle(battle){ }
 
 public:
 
@@ -39,7 +39,6 @@ private:
 	void RenderTitleBar(SDL_Surface *screen, const geometry::Vector<int> &offset);
 
 private:
-	app::Application *ctrl;
 	BattleState *battle;
 	app::Timer<Uint32> timer;
 
diff --git a/src/battle/states/SelectAttackType.cpp b/src/battle/states/SelectAttackType.cpp
index c41eb67..31a0be0 100644
--- a/src/battle/states/SelectAttackType.cpp
+++ b/src/battle/states/SelectAttackType.cpp
@@ -28,11 +28,11 @@ using geometry::Vector;
 namespace battle {
 
 void SelectAttackType::OnEnterState(Application &c, SDL_Surface *screen) {
-	ctrl = &c;
+
 }
 
 void SelectAttackType::OnExitState(Application &c, SDL_Surface *screen) {
-	ctrl = 0;
+
 }
 
 void SelectAttackType::OnResumeState(Application &ctrl, SDL_Surface *screen) {
@@ -86,11 +86,11 @@ void SelectAttackType::HandleEvents(const Input &input) {
 					ac.Selection().SetSingle();
 				}
 				ac.Selection().Reset();
-				ctrl->PushState(new SelectTarget(battle, this, &ac.Selection(), battle->Res().weaponTargetCursor));
+				Ctrl().PushState(new SelectTarget(battle, this, &ac.Selection(), battle->Res().weaponTargetCursor));
 				break;
 			case AttackChoice::MAGIC:
 				if (battle->ActiveHero().CanUseMagic()) {
-					ctrl->PushState(new SelectSpell(battle, this));
+					Ctrl().PushState(new SelectSpell(battle, this));
 				}
 				break;
 			case AttackChoice::DEFEND:
@@ -98,10 +98,10 @@ void SelectAttackType::HandleEvents(const Input &input) {
 				battle->NextHero();
 				break;
 			case AttackChoice::IKARI:
-				ctrl->PushState(new SelectIkari(battle, this));
+				Ctrl().PushState(new SelectIkari(battle, this));
 				break;
 			case AttackChoice::ITEM:
-				ctrl->PushState(new SelectItem(battle, this));
+				Ctrl().PushState(new SelectItem(battle, this));
 				break;
 			default:
 				throw std::logic_error("selected invalid attack type");
@@ -110,14 +110,14 @@ void SelectAttackType::HandleEvents(const Input &input) {
 		ac.Reset();
 		battle->PreviousHero();
 		if (battle->BeforeFirstHero()) {
-			ctrl->ChangeState(new SelectMoveAction(battle));
+			Ctrl().ChangeState(new SelectMoveAction(battle));
 		} else {
 			battle->ActiveHero().GetAttackChoice().Reset();
 		}
 	}
 
 	if (battle->AttackSelectionDone()) {
-		ctrl->PopState();
+		Ctrl().PopState();
 	}
 }
 
diff --git a/src/battle/states/SelectAttackType.h b/src/battle/states/SelectAttackType.h
index 557602f..3f98327 100644
--- a/src/battle/states/SelectAttackType.h
+++ b/src/battle/states/SelectAttackType.h
@@ -19,7 +19,7 @@ class SelectAttackType
 
 public:
 	explicit SelectAttackType(BattleState *battle)
-	: ctrl(0), battle(battle) { }
+	: battle(battle) { }
 
 public:
 	virtual void HandleEvents(const app::Input &);
@@ -38,7 +38,6 @@ private:
 	void RenderMenu(SDL_Surface *screen, const geometry::Vector<int> &offset);
 
 private:
-	app::Application *ctrl;
 	BattleState *battle;
 
 };
diff --git a/src/battle/states/SelectIkari.cpp b/src/battle/states/SelectIkari.cpp
index 1a36e41..604689c 100644
--- a/src/battle/states/SelectIkari.cpp
+++ b/src/battle/states/SelectIkari.cpp
@@ -25,11 +25,11 @@ using graphics::Frame;
 namespace battle {
 
 void SelectIkari::OnEnterState(Application &c, SDL_Surface *screen) {
-	ctrl = &c;
+
 }
 
 void SelectIkari::OnExitState(Application &c, SDL_Surface *screen) {
-	ctrl = 0;
+
 }
 
 void SelectIkari::OnResumeState(Application &ctrl, SDL_Surface *screen) {
@@ -65,19 +65,19 @@ void SelectIkari::HandleEvents(const Input &input) {
 				ac.SetType(AttackChoice::IKARI);
 				ac.SetItem(battle->ActiveHero().IkariMenu().Selected());
 				battle->NextHero();
-				ctrl->PopState();
+				Ctrl().PopState();
 			} else {
 				if (ikari->GetTargetingMode().TargetsSingle()) {
 					ac.Selection().SetSingle();
 				} else {
 					ac.Selection().SetMultiple();
 				}
-				ctrl->PushState(new SelectTarget(battle, parent, &ac.Selection(), ikari->IsMagical() ? battle->Res().magicTargetCursor : battle->Res().weaponTargetCursor));
+				Ctrl().PushState(new SelectTarget(battle, parent, &ac.Selection(), ikari->IsMagical() ? battle->Res().magicTargetCursor : battle->Res().weaponTargetCursor));
 			}
 		}
 	}
 	if (input.JustPressed(Input::ACTION_B)) {
-		ctrl->PopState(); // return control to parent
+		Ctrl().PopState(); // return control to parent
 	}
 	if (input.JustPressed(Input::PAD_UP)) {
 		battle->ActiveHero().IkariMenu().PreviousRow();
diff --git a/src/battle/states/SelectIkari.h b/src/battle/states/SelectIkari.h
index a7383a0..136436f 100644
--- a/src/battle/states/SelectIkari.h
+++ b/src/battle/states/SelectIkari.h
@@ -20,7 +20,7 @@ class SelectIkari
 
 public:
 	SelectIkari(BattleState *battle, SelectAttackType *parent)
-	: ctrl(0), battle(battle), parent(parent) { }
+	: battle(battle), parent(parent) { }
 
 public:
 	virtual void HandleEvents(const app::Input &);
@@ -41,7 +41,6 @@ private:
 	void RenderMenu(SDL_Surface *, const geometry::Vector<int> &offset);
 
 private:
-	app::Application *ctrl;
 	BattleState *battle;
 	SelectAttackType *parent;
 
diff --git a/src/battle/states/SelectItem.cpp b/src/battle/states/SelectItem.cpp
index 35a0c61..fe6ce7b 100644
--- a/src/battle/states/SelectItem.cpp
+++ b/src/battle/states/SelectItem.cpp
@@ -24,11 +24,11 @@ using graphics::Frame;
 namespace battle {
 
 void SelectItem::OnEnterState(Application &c, SDL_Surface *screen) {
-	ctrl = &c;
+
 }
 
 void SelectItem::OnExitState(Application &c, SDL_Surface *screen) {
-	ctrl = 0;
+
 }
 
 void SelectItem::OnResumeState(Application &ctrl, SDL_Surface *screen) {
@@ -64,19 +64,19 @@ void SelectItem::HandleEvents(const Input &input) {
 				ac.SetType(AttackChoice::ITEM);
 				ac.SetItem(item);
 				battle->NextHero();
-				ctrl->PopState();
+				Ctrl().PopState();
 			} else {
 				if (item->GetTargetingMode().TargetsSingle()) {
 					ac.Selection().SetSingle();
 				} else {
 					ac.Selection().SetMultiple();
 				}
-				ctrl->PushState(new SelectTarget(battle, parent, &ac.Selection(), battle->Res().itemTargetCursor));
+				Ctrl().PushState(new SelectTarget(battle, parent, &ac.Selection(), battle->Res().itemTargetCursor));
 			}
 		}
 	}
 	if (input.JustPressed(Input::ACTION_B)) {
-		ctrl->PopState(); // return control to parent
+		Ctrl().PopState(); // return control to parent
 	}
 	if (input.JustPressed(Input::PAD_UP)) {
 		battle->ItemMenu().PreviousRow();
diff --git a/src/battle/states/SelectItem.h b/src/battle/states/SelectItem.h
index e3d2168..52429aa 100644
--- a/src/battle/states/SelectItem.h
+++ b/src/battle/states/SelectItem.h
@@ -19,7 +19,7 @@ class SelectItem
 
 public:
 	SelectItem(BattleState *battle, SelectAttackType *parent)
-	: ctrl(0), battle(battle), parent(parent) { }
+	: battle(battle), parent(parent) { }
 
 public:
 	virtual void HandleEvents(const app::Input &);
@@ -40,7 +40,6 @@ private:
 	void RenderMenu(SDL_Surface *, const geometry::Vector<int> &offset);
 
 private:
-	app::Application *ctrl;
 	BattleState *battle;
 	SelectAttackType *parent;
 
diff --git a/src/battle/states/SelectMoveAction.cpp b/src/battle/states/SelectMoveAction.cpp
index 072b03d..bb71487 100644
--- a/src/battle/states/SelectMoveAction.cpp
+++ b/src/battle/states/SelectMoveAction.cpp
@@ -22,11 +22,11 @@ using geometry::Vector;
 namespace battle {
 
 void SelectMoveAction::OnEnterState(Application &c, SDL_Surface *screen) {
-	ctrl = &c;
+
 }
 
 void SelectMoveAction::OnExitState(Application &c, SDL_Surface *screen) {
-	ctrl = 0;
+
 }
 
 void SelectMoveAction::OnResumeState(Application &ctrl, SDL_Surface *screen) {
@@ -55,14 +55,14 @@ void SelectMoveAction::HandleEvents(const Input &input) {
 	if (input.JustPressed(Input::ACTION_A)) {
 		switch (battle->GetMoveMenu().Selected()) {
 			case MoveMenu::ATTACK:
-				ctrl->ChangeState(new SelectAttackType(battle));
+				Ctrl().ChangeState(new SelectAttackType(battle));
 				battle->NextHero();
 				break;
 			case MoveMenu::CHANGE:
-				ctrl->PushState(new SwapHeroes(battle, this));
+				Ctrl().PushState(new SwapHeroes(battle, this));
 				break;
 			case MoveMenu::RUN:
-				ctrl->ChangeState(new RunState(battle));
+				Ctrl().ChangeState(new RunState(battle));
 				break;
 		}
 	}
diff --git a/src/battle/states/SelectMoveAction.h b/src/battle/states/SelectMoveAction.h
index bb04fb5..cd54aed 100644
--- a/src/battle/states/SelectMoveAction.h
+++ b/src/battle/states/SelectMoveAction.h
@@ -19,7 +19,7 @@ class SelectMoveAction
 
 public:
 	explicit SelectMoveAction(BattleState *battle)
-	: ctrl(0), battle(battle) { }
+	: battle(battle) { }
 
 public:
 	virtual void HandleEvents(const app::Input &);
@@ -38,7 +38,6 @@ private:
 	void RenderMenu(SDL_Surface *screen, const geometry::Vector<int> &offset);
 
 private:
-	app::Application *ctrl;
 	BattleState *battle;
 
 };
diff --git a/src/battle/states/SelectSpell.cpp b/src/battle/states/SelectSpell.cpp
index 6ea4675..623181e 100644
--- a/src/battle/states/SelectSpell.cpp
+++ b/src/battle/states/SelectSpell.cpp
@@ -25,11 +25,11 @@ using graphics::Frame;
 namespace battle {
 
 void SelectSpell::OnEnterState(Application &c, SDL_Surface *screen) {
-	ctrl = &c;
+
 }
 
 void SelectSpell::OnExitState(Application &c, SDL_Surface *screen) {
-	ctrl = 0;
+
 }
 
 void SelectSpell::OnResumeState(Application &ctrl, SDL_Surface *screen) {
@@ -65,19 +65,19 @@ void SelectSpell::HandleEvents(const Input &input) {
 				ac.SetType(AttackChoice::MAGIC);
 				ac.SetSpell(spell);
 				battle->NextHero();
-				ctrl->PopState();
+				Ctrl().PopState();
 			} else {
 				if (spell->GetTargetingMode().TargetsSingle()) {
 					ac.Selection().SetSingle();
 				} else {
 					ac.Selection().SetMultiple();
 				}
-				ctrl->PushState(new SelectTarget(battle, parent, &ac.Selection(), battle->Res().magicTargetCursor));
+				Ctrl().PushState(new SelectTarget(battle, parent, &ac.Selection(), battle->Res().magicTargetCursor));
 			}
 		}
 	}
 	if (input.JustPressed(Input::ACTION_B)) {
-		ctrl->PopState(); // return control to parent
+		Ctrl().PopState(); // return control to parent
 	}
 	if (input.JustPressed(Input::PAD_UP)) {
 		battle->ActiveHero().SpellMenu().PreviousRow();
diff --git a/src/battle/states/SelectSpell.h b/src/battle/states/SelectSpell.h
index 7a0bad4..a1bbac7 100644
--- a/src/battle/states/SelectSpell.h
+++ b/src/battle/states/SelectSpell.h
@@ -19,7 +19,7 @@ class SelectSpell
 
 public:
 	SelectSpell(BattleState *battle, SelectAttackType *parent)
-	: ctrl(0), battle(battle), parent(parent) { }
+	: battle(battle), parent(parent) { }
 
 public:
 	virtual void HandleEvents(const app::Input &);
@@ -40,7 +40,6 @@ private:
 	void RenderMenu(SDL_Surface *, const geometry::Vector<int> &offset);
 
 private:
-	app::Application *ctrl;
 	BattleState *battle;
 	SelectAttackType *parent;
 
diff --git a/src/battle/states/SelectTarget.cpp b/src/battle/states/SelectTarget.cpp
index 4645f6d..740e46c 100644
--- a/src/battle/states/SelectTarget.cpp
+++ b/src/battle/states/SelectTarget.cpp
@@ -20,11 +20,11 @@ using std::vector;
 namespace battle {
 
 void SelectTarget::OnEnterState(Application &c, SDL_Surface *screen) {
-	ctrl = &c;
+
 }
 
 void SelectTarget::OnExitState(Application &c, SDL_Surface *screen) {
-	ctrl = 0;
+
 }
 
 void SelectTarget::OnResumeState(Application &ctrl, SDL_Surface *screen) {
@@ -44,11 +44,11 @@ void SelectTarget::OnResize(int width, int height) {
 void SelectTarget::HandleEvents(const Input &input) {
 	if (input.JustPressed(Input::ACTION_A)) {
 		if (selection->CurrentIsSelected()) {
-			ctrl->PopState(); // return control to parent
+			Ctrl().PopState(); // return control to parent
 		} else {
 			selection->Select();
 			if (selection->SelectSingle()) {
-				ctrl->PopState(); // return control to parent
+				Ctrl().PopState(); // return control to parent
 			}
 		}
 	}
@@ -57,7 +57,7 @@ void SelectTarget::HandleEvents(const Input &input) {
 			selection->Unselect();
 		} else {
 			selection->UnselectAll();
-			ctrl->PopState(); // return control to parent
+			Ctrl().PopState(); // return control to parent
 		}
 	}
 
diff --git a/src/battle/states/SelectTarget.h b/src/battle/states/SelectTarget.h
index 4549036..01ebba7 100644
--- a/src/battle/states/SelectTarget.h
+++ b/src/battle/states/SelectTarget.h
@@ -20,7 +20,7 @@ class SelectTarget
 
 public:
 	SelectTarget(BattleState *battle, SelectAttackType *parent, TargetSelection *selection, const graphics::Sprite *cursorIcon)
-	: ctrl(0), battle(battle), parent(parent), selection(selection), cursorIcon(cursorIcon), flipFlop(true) { }
+	: battle(battle), parent(parent), selection(selection), cursorIcon(cursorIcon), flipFlop(true) { }
 
 public:
 	virtual void HandleEvents(const app::Input &);
@@ -39,7 +39,6 @@ private:
 	void RenderCursors(SDL_Surface *screen, const geometry::Vector<int> &offset);
 
 private:
-	app::Application *ctrl;
 	BattleState *battle;
 	SelectAttackType *parent;
 	TargetSelection *selection;
diff --git a/src/battle/states/SwapHeroes.cpp b/src/battle/states/SwapHeroes.cpp
index 678b5c8..0dcd0bd 100644
--- a/src/battle/states/SwapHeroes.cpp
+++ b/src/battle/states/SwapHeroes.cpp
@@ -20,11 +20,11 @@ using std::vector;
 namespace battle {
 
 void SwapHeroes::OnEnterState(Application &c, SDL_Surface *screen) {
-	ctrl = &c;
+
 }
 
 void SwapHeroes::OnExitState(Application &c, SDL_Surface *screen) {
-	ctrl = 0;
+
 }
 
 void SwapHeroes::OnResumeState(Application &ctrl, SDL_Surface *screen) {
@@ -54,7 +54,7 @@ void SwapHeroes::HandleEvents(const Input &input) {
 		if (cursor == selected) {
 			selected = -1;
 		} else {
-			ctrl->PopState();
+			Ctrl().PopState();
 		}
 	}
 
diff --git a/src/battle/states/SwapHeroes.h b/src/battle/states/SwapHeroes.h
index a5f5c62..1710721 100644
--- a/src/battle/states/SwapHeroes.h
+++ b/src/battle/states/SwapHeroes.h
@@ -19,7 +19,7 @@ class SwapHeroes
 
 public:
 	SwapHeroes(BattleState *battle, SelectMoveAction *parent)
-	: ctrl(0), battle(battle), parent(parent), cursor(0), selected(-1), flipFlop(true) { }
+	: battle(battle), parent(parent), cursor(0), selected(-1), flipFlop(true) { }
 
 public:
 	virtual void HandleEvents(const app::Input &);
@@ -44,7 +44,6 @@ private:
 	void RenderCursors(SDL_Surface *screen, const geometry::Vector<int> &offset);
 
 private:
-	app::Application *ctrl;
 	BattleState *battle;
 	SelectMoveAction *parent;
 	int cursor;
diff --git a/src/graphics/ColorFade.cpp b/src/graphics/ColorFade.cpp
index 196b0d8..f194665 100644
--- a/src/graphics/ColorFade.cpp
+++ b/src/graphics/ColorFade.cpp
@@ -16,8 +16,7 @@ using app::Input;
 namespace graphics {
 
 ColorFade::ColorFade(State *slave, Uint32 color, int duration, bool in, bool interactive)
-: ctrl(0)
-, slave(slave)
+: slave(slave)
 , blinds(0)
 , color(color)
 , duration(duration)
@@ -31,7 +30,6 @@ ColorFade::ColorFade(State *slave, Uint32 color, int duration, bool in, bool int
 }
 
 void ColorFade::OnEnterState(Application &c, SDL_Surface *screen) {
-	ctrl = &c;
 	if (leadIn > 0) {
 		timer = GraphicsTimers().StartCountdown(leadIn);
 	} else {
@@ -94,10 +92,10 @@ void ColorFade::HandleEvents(const Input &input) {
 			if (leadOut > 0) {
 				timer = GraphicsTimers().StartCountdown(leadOut);
 			} else {
-				ctrl->PopState();
+				Ctrl().PopState();
 			}
 		} else {
-			ctrl->PopState();
+			Ctrl().PopState();
 		}
 	}
 }
diff --git a/src/graphics/ColorFade.h b/src/graphics/ColorFade.h
index 2694272..5e14663 100644
--- a/src/graphics/ColorFade.h
+++ b/src/graphics/ColorFade.h
@@ -45,7 +45,6 @@ private:
 
 private:
 	app::Timer<Uint32> timer;
-	app::Application *ctrl;
 	app::State *slave;
 	SDL_Surface *blinds;
 	Uint32 color;
diff --git a/src/map/MapState.cpp b/src/map/MapState.cpp
index 7e42e13..8e70acd 100644
--- a/src/map/MapState.cpp
+++ b/src/map/MapState.cpp
@@ -31,7 +31,6 @@ namespace map {
 
 MapState::MapState(GameConfig *g, Map *map)
 : game(g)
-, ctrl(0)
 , map(map)
 , controlled(0)
 , pushed(0)
@@ -48,7 +47,6 @@ MapState::MapState(GameConfig *g, Map *map)
 
 
 void MapState::OnEnterState(Application &c, SDL_Surface *screen) {
-	ctrl = &c;
 	camera.Resize(screen->w, screen->h);
 	LoadMap(map);
 }
@@ -307,9 +305,9 @@ bool MapState::CheckMonster() {
 				ColorFade *fadeOut(new ColorFade(this, 0, 500));
 				fadeOut->SetLeadOutTime(500);
 
-				ctrl->PushState(fadeIn);
-				ctrl->PushState(battleState);
-				ctrl->PushState(fadeOut);
+				Ctrl().PushState(fadeIn);
+				Ctrl().PushState(battleState);
+				Ctrl().PushState(fadeOut);
 				// TODO: move entity erase to happen after the transition or battle
 				entities.erase(e);
 				return true;
@@ -445,11 +443,11 @@ bool MapState::ZCompare(const Entity *lhs, const Entity *rhs) {
 void MapState::HandleSyscall(common::ScriptRunner &r) {
 	switch (r.Integer0()) {
 		case TRANSITION: {
-			ctrl->PushState(new ColorFade(this, 0, 500, true));
-			ctrl->PushState(new TransitionState(this, reinterpret_cast<Map *>(r.Address0()), r.Vector0()));
+			Ctrl().PushState(new ColorFade(this, 0, 500, true));
+			Ctrl().PushState(new TransitionState(this, reinterpret_cast<Map *>(r.Address0()), r.Vector0()));
 			ColorFade *fadeOut(new ColorFade(this, 0, 500, false));
 			fadeOut->SetLeadOutTime(500);
-			ctrl->PushState(fadeOut);
+			Ctrl().PushState(fadeOut);
 			break;
 		}
 	}
diff --git a/src/map/MapState.h b/src/map/MapState.h
index fcea893..9cff10c 100644
--- a/src/map/MapState.h
+++ b/src/map/MapState.h
@@ -82,7 +82,6 @@ private:
 
 private:
 	common::GameConfig *game;
-	app::Application *ctrl;
 	Map *map;
 	Entity *controlled;
 	Entity *pushed;
diff --git a/src/map/TransitionState.cpp b/src/map/TransitionState.cpp
index 1a2afb5..b339381 100644
--- a/src/map/TransitionState.cpp
+++ b/src/map/TransitionState.cpp
@@ -18,15 +18,14 @@ using geometry::Vector;
 namespace map {
 
 TransitionState::TransitionState(MapState *ms, Map *map, const Vector<int> &coordinates)
-: ctrl(0)
-, ms(ms)
+: ms(ms)
 , map(map)
 , coordinates(coordinates) {
 
 }
 
 void TransitionState::OnEnterState(Application &c, SDL_Surface *screen) {
-	ctrl = &c;
+
 }
 
 void TransitionState::OnExitState(Application &, SDL_Surface *screen) {
@@ -49,7 +48,7 @@ void TransitionState::OnResize(int width, int height) {
 
 void TransitionState::HandleEvents(const Input &input) {
 	ms->Transition(map, coordinates);
-	ctrl->PopState();
+	Ctrl().PopState();
 }
 
 
diff --git a/src/map/TransitionState.h b/src/map/TransitionState.h
index 0dfa7cf..134e54a 100644
--- a/src/map/TransitionState.h
+++ b/src/map/TransitionState.h
@@ -35,7 +35,6 @@ private:
 	virtual void OnResize(int width, int height);
 
 private:
-	app::Application *ctrl;
 	MapState *ms;
 	Map *map;
 	const geometry::Vector<int> &coordinates;
-- 
2.39.2


From 5ca18f73987fb3935ab34654cbbecf5eca4704cb Mon Sep 17 00:00:00 2001
From: Daniel Karbach <daniel.karbach@localhorst.tv>
Date: Wed, 17 Oct 2012 21:34:48 +0200
Subject: [PATCH 16/16] removed now superfluous Application parameter to State
 callbacks

---
 src/app/Application.cpp                | 14 +++++++-------
 src/app/State.cpp                      | 12 ++++++------
 src/app/State.h                        | 12 ++++++------
 src/battle/BattleState.cpp             | 18 +++++++++---------
 src/battle/BattleState.h               |  8 ++++----
 src/battle/states/PerformAttacks.cpp   |  8 ++++----
 src/battle/states/PerformAttacks.h     |  8 ++++----
 src/battle/states/RunState.cpp         |  8 ++++----
 src/battle/states/RunState.h           |  8 ++++----
 src/battle/states/SelectAttackType.cpp | 10 +++++-----
 src/battle/states/SelectAttackType.h   |  8 ++++----
 src/battle/states/SelectIkari.cpp      | 10 +++++-----
 src/battle/states/SelectIkari.h        |  8 ++++----
 src/battle/states/SelectItem.cpp       | 10 +++++-----
 src/battle/states/SelectItem.h         |  8 ++++----
 src/battle/states/SelectMoveAction.cpp |  8 ++++----
 src/battle/states/SelectMoveAction.h   |  8 ++++----
 src/battle/states/SelectSpell.cpp      | 10 +++++-----
 src/battle/states/SelectSpell.h        |  8 ++++----
 src/battle/states/SelectTarget.cpp     |  8 ++++----
 src/battle/states/SelectTarget.h       |  8 ++++----
 src/battle/states/SwapHeroes.cpp       |  8 ++++----
 src/battle/states/SwapHeroes.h         |  8 ++++----
 src/graphics/ColorFade.cpp             |  8 ++++----
 src/graphics/ColorFade.h               |  8 ++++----
 src/map/MapState.cpp                   |  8 ++++----
 src/map/MapState.h                     |  8 ++++----
 src/map/TransitionState.cpp            |  8 ++++----
 src/map/TransitionState.h              |  8 ++++----
 29 files changed, 132 insertions(+), 132 deletions(-)

diff --git a/src/app/Application.cpp b/src/app/Application.cpp
index f773cfc..90ed288 100644
--- a/src/app/Application.cpp
+++ b/src/app/Application.cpp
@@ -85,32 +85,32 @@ void Application::PopState() {
 
 void Application::RealChangeState(State *s) {
 	if (!states.empty()) {
-		states.top()->PauseState(*this, screen.Screen());
+		states.top()->PauseState(screen.Screen());
 		states.top()->ExitState(*this, screen.Screen());
 		states.pop();
 	}
 	states.push(s);
 	s->EnterState(*this, screen.Screen());
-	s->ResumeState(*this, screen.Screen());
+	s->ResumeState(screen.Screen());
 }
 
 void Application::RealPushState(State *s) {
 	if (!states.empty()) {
-		states.top()->PauseState(*this, screen.Screen());
+		states.top()->PauseState(screen.Screen());
 	}
 	states.push(s);
 	s->EnterState(*this, screen.Screen());
-	s->ResumeState(*this, screen.Screen());
+	s->ResumeState(screen.Screen());
 }
 
 void Application::RealPopState() {
 	if (states.empty()) return;
-	states.top()->PauseState(*this, screen.Screen());
+	states.top()->PauseState(screen.Screen());
 	states.top()->ExitState(*this, screen.Screen());
 	delete states.top();
 	states.pop();
 	if (!states.empty()) {
-		states.top()->ResumeState(*this, screen.Screen());
+		states.top()->ResumeState(screen.Screen());
 	}
 }
 
@@ -120,7 +120,7 @@ void Application::Quit() {
 
 void Application::PopAllStates() {
 	while (!states.empty()) {
-		states.top()->PauseState(*this, screen.Screen());
+		states.top()->PauseState(screen.Screen());
 		states.top()->ExitState(*this, screen.Screen());
 		delete states.top();
 		states.pop();
diff --git a/src/app/State.cpp b/src/app/State.cpp
index f1c7712..2c8f0c3 100644
--- a/src/app/State.cpp
+++ b/src/app/State.cpp
@@ -25,20 +25,20 @@ State::~State() {
 
 void State::EnterState(Application &c, SDL_Surface *screen) {
 	ctrl = &c;
-	OnEnterState(c, screen);
+	OnEnterState(screen);
 }
 
 void State::ExitState(Application &c, SDL_Surface *screen) {
-	OnExitState(c, screen);
+	OnExitState(screen);
 	ctrl = 0;
 }
 
-void State::ResumeState(Application &ctrl, SDL_Surface *screen) {
-	OnResumeState(ctrl, screen);
+void State::ResumeState(SDL_Surface *screen) {
+	OnResumeState(screen);
 }
 
-void State::PauseState(Application &ctrl, SDL_Surface *screen) {
-	OnPauseState(ctrl, screen);
+void State::PauseState(SDL_Surface *screen) {
+	OnPauseState(screen);
 }
 
 void State::Resize(int width, int height) {
diff --git a/src/app/State.h b/src/app/State.h
index 2a4b5e1..4e1fd7f 100644
--- a/src/app/State.h
+++ b/src/app/State.h
@@ -28,9 +28,9 @@ public:
 	/// Called by Application when popping this state.
 	void ExitState(Application &ctrl, SDL_Surface *screen);
 	/// Called by Application when this state becomes the top state.
-	void ResumeState(Application &ctrl, SDL_Surface *screen);
+	void ResumeState(SDL_Surface *screen);
 	/// Called by Application when this state no longer is the top state.
-	void PauseState(Application &ctrl, SDL_Surface *screen);
+	void PauseState(SDL_Surface *screen);
 
 	/// Called by Application on SDL window resize events.
 	void Resize(int width, int height);
@@ -54,14 +54,14 @@ private:
 	/// can not be done by the constructor.
 	/// Called when the state first enters the stack.
 	/// @param ctrl the Application running the state
-	virtual void OnEnterState(Application &ctrl, SDL_Surface *screen) = 0;
+	virtual void OnEnterState(SDL_Surface *screen) = 0;
 	/// Do some cleanup.
 	/// Called when the state is popped from the stack.
-	virtual void OnExitState(Application &ctrl, SDL_Surface *screen) = 0;
+	virtual void OnExitState(SDL_Surface *screen) = 0;
 	/// Called when the state becomes the active one.
-	virtual void OnResumeState(Application &ctrl, SDL_Surface *screen) = 0;
+	virtual void OnResumeState(SDL_Surface *screen) = 0;
 	/// Called when the state becomes inactive.
-	virtual void OnPauseState(Application &ctrl, SDL_Surface *screen) = 0;
+	virtual void OnPauseState(SDL_Surface *screen) = 0;
 
 	/// Adapt the state's graphics to given dimensions.
 	/// NOTE: currently, this is only called for the stack top and not
diff --git a/src/battle/BattleState.cpp b/src/battle/BattleState.cpp
index d442f22..be1ef34 100644
--- a/src/battle/BattleState.cpp
+++ b/src/battle/BattleState.cpp
@@ -79,7 +79,7 @@ void BattleState::OnResize(int w, int h) {
 }
 
 
-void BattleState::OnEnterState(Application &ctrl, SDL_Surface *screen) {
+void BattleState::OnEnterState(SDL_Surface *screen) {
 	for (int i(0); i < 4; ++i) {
 		heroes[i].Position() = heroesLayout->CalculatePosition(i, background->w, background->h);
 		heroes[i].SpellMenu() = *res->spellMenuProperties;
@@ -130,28 +130,28 @@ void BattleState::LoadInventory() {
 	ClearAllAttacks();
 }
 
-void BattleState::OnExitState(Application &ctrl, SDL_Surface *screen) {
+void BattleState::OnExitState(SDL_Surface *screen) {
 
 }
 
-void BattleState::OnResumeState(Application &ctrl, SDL_Surface *screen) {
+void BattleState::OnResumeState(SDL_Surface *screen) {
 	if (ranAway) {
-		ctrl.PopState(); // quit the battle scene
+		Ctrl().PopState(); // quit the battle scene
 		return;
 	}
 	if (Victory()) {
-		ctrl.PopState();
+		Ctrl().PopState();
 		return;
 	}
 	if (Defeat()) {
-		ctrl.PopState();
+		Ctrl().PopState();
 		return;
 	}
 	// TODO: this should not push a state while quitting
 	if (AttackSelectionDone()) {
-		ctrl.PushState(new PerformAttacks(this));
+		Ctrl().PushState(new PerformAttacks(this));
 	} else {
-		ctrl.PushState(new SelectMoveAction(this));
+		Ctrl().PushState(new SelectMoveAction(this));
 	}
 }
 
@@ -169,7 +169,7 @@ bool BattleState::Defeat() const {
 	return true;
 }
 
-void BattleState::OnPauseState(Application &ctrl, SDL_Surface *screen) {
+void BattleState::OnPauseState(SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/BattleState.h b/src/battle/BattleState.h
index cc9eaf1..e76440e 100644
--- a/src/battle/BattleState.h
+++ b/src/battle/BattleState.h
@@ -131,10 +131,10 @@ public:
 	void RenderSmallHeroTags(SDL_Surface *screen, const geometry::Vector<int> &offset);
 
 private:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(SDL_Surface *screen);
+	virtual void OnExitState(SDL_Surface *screen);
+	virtual void OnResumeState(SDL_Surface *screen);
+	virtual void OnPauseState(SDL_Surface *screen);
 
 	virtual void OnResize(int width, int height);
 
diff --git a/src/battle/states/PerformAttacks.cpp b/src/battle/states/PerformAttacks.cpp
index a1a5b8b..665756f 100644
--- a/src/battle/states/PerformAttacks.cpp
+++ b/src/battle/states/PerformAttacks.cpp
@@ -29,21 +29,21 @@ using std::vector;
 
 namespace battle {
 
-void PerformAttacks::OnEnterState(Application &c, SDL_Surface *screen) {
+void PerformAttacks::OnEnterState(SDL_Surface *screen) {
 	battle->CalculateAttackOrder();
 	numberAnimation.reserve(battle->MaxMonsters() > battle->NumHeroes() + 1 ? battle->MaxMonsters() : battle->NumHeroes() + 1);
 	numberPosition.reserve(numberAnimation.size());
 }
 
-void PerformAttacks::OnExitState(Application &c, SDL_Surface *screen) {
+void PerformAttacks::OnExitState(SDL_Surface *screen) {
 	battle->ClearAllAttacks();
 }
 
-void PerformAttacks::OnResumeState(Application &ctrl, SDL_Surface *screen) {
+void PerformAttacks::OnResumeState(SDL_Surface *screen) {
 
 }
 
-void PerformAttacks::OnPauseState(Application &ctrl, SDL_Surface *screen) {
+void PerformAttacks::OnPauseState(SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/PerformAttacks.h b/src/battle/states/PerformAttacks.h
index 2fe9a06..06ce1b8 100644
--- a/src/battle/states/PerformAttacks.h
+++ b/src/battle/states/PerformAttacks.h
@@ -32,10 +32,10 @@ public:
 	virtual void Render(SDL_Surface *);
 
 private:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(SDL_Surface *screen);
+	virtual void OnExitState(SDL_Surface *screen);
+	virtual void OnResumeState(SDL_Surface *screen);
+	virtual void OnPauseState(SDL_Surface *screen);
 
 	virtual void OnResize(int width, int height);
 
diff --git a/src/battle/states/RunState.cpp b/src/battle/states/RunState.cpp
index cf113f2..311e0f3 100644
--- a/src/battle/states/RunState.cpp
+++ b/src/battle/states/RunState.cpp
@@ -22,19 +22,19 @@ using geometry::Vector;
 
 namespace battle {
 
-void RunState::OnEnterState(Application &c, SDL_Surface *screen) {
+void RunState::OnEnterState(SDL_Surface *screen) {
 
 }
 
-void RunState::OnExitState(Application &c, SDL_Surface *screen) {
+void RunState::OnExitState(SDL_Surface *screen) {
 
 }
 
-void RunState::OnResumeState(Application &ctrl, SDL_Surface *screen) {
+void RunState::OnResumeState(SDL_Surface *screen) {
 	timer = GraphicsTimers().StartCountdown(2500);
 }
 
-void RunState::OnPauseState(Application &ctrl, SDL_Surface *screen) {
+void RunState::OnPauseState(SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/RunState.h b/src/battle/states/RunState.h
index 9cee764..cf91f9a 100644
--- a/src/battle/states/RunState.h
+++ b/src/battle/states/RunState.h
@@ -28,10 +28,10 @@ public:
 	virtual void Render(SDL_Surface *);
 
 private:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(SDL_Surface *screen);
+	virtual void OnExitState(SDL_Surface *screen);
+	virtual void OnResumeState(SDL_Surface *screen);
+	virtual void OnPauseState(SDL_Surface *screen);
 
 	virtual void OnResize(int width, int height);
 
diff --git a/src/battle/states/SelectAttackType.cpp b/src/battle/states/SelectAttackType.cpp
index 31a0be0..fade232 100644
--- a/src/battle/states/SelectAttackType.cpp
+++ b/src/battle/states/SelectAttackType.cpp
@@ -27,26 +27,26 @@ using geometry::Vector;
 
 namespace battle {
 
-void SelectAttackType::OnEnterState(Application &c, SDL_Surface *screen) {
+void SelectAttackType::OnEnterState(SDL_Surface *screen) {
 
 }
 
-void SelectAttackType::OnExitState(Application &c, SDL_Surface *screen) {
+void SelectAttackType::OnExitState(SDL_Surface *screen) {
 
 }
 
-void SelectAttackType::OnResumeState(Application &ctrl, SDL_Surface *screen) {
+void SelectAttackType::OnResumeState(SDL_Surface *screen) {
 	if (battle->ActiveHero().GetAttackChoice().Selection().HasSelected()) {
 		battle->ActiveHero().GetAttackChoice().SetType(battle->GetAttackTypeMenu().Selected());
 		battle->NextHero();
 	}
 	if (battle->AttackSelectionDone()) {
 		// pass through
-		ctrl.PopState();
+		Ctrl().PopState();
 	}
 }
 
-void SelectAttackType::OnPauseState(Application &ctrl, SDL_Surface *screen) {
+void SelectAttackType::OnPauseState(SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SelectAttackType.h b/src/battle/states/SelectAttackType.h
index 3f98327..64a7dbd 100644
--- a/src/battle/states/SelectAttackType.h
+++ b/src/battle/states/SelectAttackType.h
@@ -27,10 +27,10 @@ public:
 	virtual void Render(SDL_Surface *);
 
 private:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(SDL_Surface *screen);
+	virtual void OnExitState(SDL_Surface *screen);
+	virtual void OnResumeState(SDL_Surface *screen);
+	virtual void OnPauseState(SDL_Surface *screen);
 
 	virtual void OnResize(int width, int height);
 
diff --git a/src/battle/states/SelectIkari.cpp b/src/battle/states/SelectIkari.cpp
index 604689c..2860a81 100644
--- a/src/battle/states/SelectIkari.cpp
+++ b/src/battle/states/SelectIkari.cpp
@@ -24,23 +24,23 @@ using graphics::Frame;
 
 namespace battle {
 
-void SelectIkari::OnEnterState(Application &c, SDL_Surface *screen) {
+void SelectIkari::OnEnterState(SDL_Surface *screen) {
 
 }
 
-void SelectIkari::OnExitState(Application &c, SDL_Surface *screen) {
+void SelectIkari::OnExitState(SDL_Surface *screen) {
 
 }
 
-void SelectIkari::OnResumeState(Application &ctrl, SDL_Surface *screen) {
+void SelectIkari::OnResumeState(SDL_Surface *screen) {
 	if (battle->ActiveHero().GetAttackChoice().Selection().HasSelected()) {
 		battle->ActiveHero().GetAttackChoice().SetType(AttackChoice::IKARI);
 		battle->ActiveHero().GetAttackChoice().SetItem(battle->ActiveHero().IkariMenu().Selected());
-		ctrl.PopState();
+		Ctrl().PopState();
 	}
 }
 
-void SelectIkari::OnPauseState(Application &ctrl, SDL_Surface *screen) {
+void SelectIkari::OnPauseState(SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SelectIkari.h b/src/battle/states/SelectIkari.h
index 136436f..8603a57 100644
--- a/src/battle/states/SelectIkari.h
+++ b/src/battle/states/SelectIkari.h
@@ -28,10 +28,10 @@ public:
 	virtual void Render(SDL_Surface *);
 
 private:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(SDL_Surface *screen);
+	virtual void OnExitState(SDL_Surface *screen);
+	virtual void OnResumeState(SDL_Surface *screen);
+	virtual void OnPauseState(SDL_Surface *screen);
 
 	virtual void OnResize(int width, int height);
 
diff --git a/src/battle/states/SelectItem.cpp b/src/battle/states/SelectItem.cpp
index fe6ce7b..6ca4396 100644
--- a/src/battle/states/SelectItem.cpp
+++ b/src/battle/states/SelectItem.cpp
@@ -23,23 +23,23 @@ using graphics::Frame;
 
 namespace battle {
 
-void SelectItem::OnEnterState(Application &c, SDL_Surface *screen) {
+void SelectItem::OnEnterState(SDL_Surface *screen) {
 
 }
 
-void SelectItem::OnExitState(Application &c, SDL_Surface *screen) {
+void SelectItem::OnExitState(SDL_Surface *screen) {
 
 }
 
-void SelectItem::OnResumeState(Application &ctrl, SDL_Surface *screen) {
+void SelectItem::OnResumeState(SDL_Surface *screen) {
 	if (battle->ActiveHero().GetAttackChoice().Selection().HasSelected()) {
 		battle->ActiveHero().GetAttackChoice().SetType(AttackChoice::ITEM);
 		battle->ActiveHero().GetAttackChoice().SetItem(battle->ItemMenu().Selected());
-		ctrl.PopState();
+		Ctrl().PopState();
 	}
 }
 
-void SelectItem::OnPauseState(Application &ctrl, SDL_Surface *screen) {
+void SelectItem::OnPauseState(SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SelectItem.h b/src/battle/states/SelectItem.h
index 52429aa..1942ff4 100644
--- a/src/battle/states/SelectItem.h
+++ b/src/battle/states/SelectItem.h
@@ -27,10 +27,10 @@ public:
 	virtual void Render(SDL_Surface *);
 
 private:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(SDL_Surface *screen);
+	virtual void OnExitState(SDL_Surface *screen);
+	virtual void OnResumeState(SDL_Surface *screen);
+	virtual void OnPauseState(SDL_Surface *screen);
 
 	virtual void OnResize(int width, int height);
 
diff --git a/src/battle/states/SelectMoveAction.cpp b/src/battle/states/SelectMoveAction.cpp
index bb71487..52b670b 100644
--- a/src/battle/states/SelectMoveAction.cpp
+++ b/src/battle/states/SelectMoveAction.cpp
@@ -21,19 +21,19 @@ using geometry::Vector;
 
 namespace battle {
 
-void SelectMoveAction::OnEnterState(Application &c, SDL_Surface *screen) {
+void SelectMoveAction::OnEnterState(SDL_Surface *screen) {
 
 }
 
-void SelectMoveAction::OnExitState(Application &c, SDL_Surface *screen) {
+void SelectMoveAction::OnExitState(SDL_Surface *screen) {
 
 }
 
-void SelectMoveAction::OnResumeState(Application &ctrl, SDL_Surface *screen) {
+void SelectMoveAction::OnResumeState(SDL_Surface *screen) {
 
 }
 
-void SelectMoveAction::OnPauseState(Application &ctrl, SDL_Surface *screen) {
+void SelectMoveAction::OnPauseState(SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SelectMoveAction.h b/src/battle/states/SelectMoveAction.h
index cd54aed..a48633d 100644
--- a/src/battle/states/SelectMoveAction.h
+++ b/src/battle/states/SelectMoveAction.h
@@ -27,10 +27,10 @@ public:
 	virtual void Render(SDL_Surface *);
 
 private:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(SDL_Surface *screen);
+	virtual void OnExitState(SDL_Surface *screen);
+	virtual void OnResumeState(SDL_Surface *screen);
+	virtual void OnPauseState(SDL_Surface *screen);
 
 	virtual void OnResize(int width, int height);
 
diff --git a/src/battle/states/SelectSpell.cpp b/src/battle/states/SelectSpell.cpp
index 623181e..d7941c8 100644
--- a/src/battle/states/SelectSpell.cpp
+++ b/src/battle/states/SelectSpell.cpp
@@ -24,23 +24,23 @@ using graphics::Frame;
 
 namespace battle {
 
-void SelectSpell::OnEnterState(Application &c, SDL_Surface *screen) {
+void SelectSpell::OnEnterState(SDL_Surface *screen) {
 
 }
 
-void SelectSpell::OnExitState(Application &c, SDL_Surface *screen) {
+void SelectSpell::OnExitState(SDL_Surface *screen) {
 
 }
 
-void SelectSpell::OnResumeState(Application &ctrl, SDL_Surface *screen) {
+void SelectSpell::OnResumeState(SDL_Surface *screen) {
 	if (battle->ActiveHero().GetAttackChoice().Selection().HasSelected()) {
 		battle->ActiveHero().GetAttackChoice().SetType(AttackChoice::MAGIC);
 		battle->ActiveHero().GetAttackChoice().SetSpell(battle->ActiveHero().SpellMenu().Selected());
-		ctrl.PopState();
+		Ctrl().PopState();
 	}
 }
 
-void SelectSpell::OnPauseState(Application &ctrl, SDL_Surface *screen) {
+void SelectSpell::OnPauseState(SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SelectSpell.h b/src/battle/states/SelectSpell.h
index a1bbac7..514a2b8 100644
--- a/src/battle/states/SelectSpell.h
+++ b/src/battle/states/SelectSpell.h
@@ -27,10 +27,10 @@ public:
 	virtual void Render(SDL_Surface *);
 
 private:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(SDL_Surface *screen);
+	virtual void OnExitState(SDL_Surface *screen);
+	virtual void OnResumeState(SDL_Surface *screen);
+	virtual void OnPauseState(SDL_Surface *screen);
 
 	virtual void OnResize(int width, int height);
 
diff --git a/src/battle/states/SelectTarget.cpp b/src/battle/states/SelectTarget.cpp
index 740e46c..1961738 100644
--- a/src/battle/states/SelectTarget.cpp
+++ b/src/battle/states/SelectTarget.cpp
@@ -19,19 +19,19 @@ using std::vector;
 
 namespace battle {
 
-void SelectTarget::OnEnterState(Application &c, SDL_Surface *screen) {
+void SelectTarget::OnEnterState(SDL_Surface *screen) {
 
 }
 
-void SelectTarget::OnExitState(Application &c, SDL_Surface *screen) {
+void SelectTarget::OnExitState(SDL_Surface *screen) {
 
 }
 
-void SelectTarget::OnResumeState(Application &ctrl, SDL_Surface *screen) {
+void SelectTarget::OnResumeState(SDL_Surface *screen) {
 
 }
 
-void SelectTarget::OnPauseState(Application &ctrl, SDL_Surface *screen) {
+void SelectTarget::OnPauseState(SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SelectTarget.h b/src/battle/states/SelectTarget.h
index 01ebba7..388aef3 100644
--- a/src/battle/states/SelectTarget.h
+++ b/src/battle/states/SelectTarget.h
@@ -28,10 +28,10 @@ public:
 	virtual void Render(SDL_Surface *);
 
 private:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(SDL_Surface *screen);
+	virtual void OnExitState(SDL_Surface *screen);
+	virtual void OnResumeState(SDL_Surface *screen);
+	virtual void OnPauseState(SDL_Surface *screen);
 
 	virtual void OnResize(int width, int height);
 
diff --git a/src/battle/states/SwapHeroes.cpp b/src/battle/states/SwapHeroes.cpp
index 0dcd0bd..357e324 100644
--- a/src/battle/states/SwapHeroes.cpp
+++ b/src/battle/states/SwapHeroes.cpp
@@ -19,19 +19,19 @@ using std::vector;
 
 namespace battle {
 
-void SwapHeroes::OnEnterState(Application &c, SDL_Surface *screen) {
+void SwapHeroes::OnEnterState(SDL_Surface *screen) {
 
 }
 
-void SwapHeroes::OnExitState(Application &c, SDL_Surface *screen) {
+void SwapHeroes::OnExitState(SDL_Surface *screen) {
 
 }
 
-void SwapHeroes::OnResumeState(Application &ctrl, SDL_Surface *screen) {
+void SwapHeroes::OnResumeState(SDL_Surface *screen) {
 
 }
 
-void SwapHeroes::OnPauseState(Application &ctrl, SDL_Surface *screen) {
+void SwapHeroes::OnPauseState(SDL_Surface *screen) {
 
 }
 
diff --git a/src/battle/states/SwapHeroes.h b/src/battle/states/SwapHeroes.h
index 1710721..198e4d3 100644
--- a/src/battle/states/SwapHeroes.h
+++ b/src/battle/states/SwapHeroes.h
@@ -27,10 +27,10 @@ public:
 	virtual void Render(SDL_Surface *);
 
 private:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(SDL_Surface *screen);
+	virtual void OnExitState(SDL_Surface *screen);
+	virtual void OnResumeState(SDL_Surface *screen);
+	virtual void OnPauseState(SDL_Surface *screen);
 
 	virtual void OnResize(int width, int height);
 
diff --git a/src/graphics/ColorFade.cpp b/src/graphics/ColorFade.cpp
index f194665..8afd87b 100644
--- a/src/graphics/ColorFade.cpp
+++ b/src/graphics/ColorFade.cpp
@@ -29,7 +29,7 @@ ColorFade::ColorFade(State *slave, Uint32 color, int duration, bool in, bool int
 
 }
 
-void ColorFade::OnEnterState(Application &c, SDL_Surface *screen) {
+void ColorFade::OnEnterState(SDL_Surface *screen) {
 	if (leadIn > 0) {
 		timer = GraphicsTimers().StartCountdown(leadIn);
 	} else {
@@ -38,18 +38,18 @@ void ColorFade::OnEnterState(Application &c, SDL_Surface *screen) {
 	}
 }
 
-void ColorFade::OnExitState(Application &, SDL_Surface *screen) {
+void ColorFade::OnExitState(SDL_Surface *screen) {
 	if (blinds) {
 		SDL_FreeSurface(blinds);
 		blinds = 0;
 	}
 }
 
-void ColorFade::OnResumeState(Application &ctrl, SDL_Surface *screen) {
+void ColorFade::OnResumeState(SDL_Surface *screen) {
 	UpdateBlinds(screen->w, screen->h);
 }
 
-void ColorFade::OnPauseState(Application &ctrl, SDL_Surface *screen) {
+void ColorFade::OnPauseState(SDL_Surface *screen) {
 
 }
 
diff --git a/src/graphics/ColorFade.h b/src/graphics/ColorFade.h
index 5e14663..079d30e 100644
--- a/src/graphics/ColorFade.h
+++ b/src/graphics/ColorFade.h
@@ -32,10 +32,10 @@ public:
 	virtual void Render(SDL_Surface *);
 
 private:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(SDL_Surface *screen);
+	virtual void OnExitState(SDL_Surface *screen);
+	virtual void OnResumeState(SDL_Surface *screen);
+	virtual void OnPauseState(SDL_Surface *screen);
 
 	virtual void OnResize(int width, int height);
 
diff --git a/src/map/MapState.cpp b/src/map/MapState.cpp
index 8e70acd..500acea 100644
--- a/src/map/MapState.cpp
+++ b/src/map/MapState.cpp
@@ -46,20 +46,20 @@ MapState::MapState(GameConfig *g, Map *map)
 }
 
 
-void MapState::OnEnterState(Application &c, SDL_Surface *screen) {
+void MapState::OnEnterState(SDL_Surface *screen) {
 	camera.Resize(screen->w, screen->h);
 	LoadMap(map);
 }
 
-void MapState::OnExitState(Application &ctrl, SDL_Surface *screen) {
+void MapState::OnExitState(SDL_Surface *screen) {
 
 }
 
-void MapState::OnResumeState(Application &ctrl, SDL_Surface *screen) {
+void MapState::OnResumeState(SDL_Surface *screen) {
 	camera.Resize(screen->w, screen->h);
 }
 
-void MapState::OnPauseState(Application &ctrl, SDL_Surface *screen) {
+void MapState::OnPauseState(SDL_Surface *screen) {
 
 }
 
diff --git a/src/map/MapState.h b/src/map/MapState.h
index 9cff10c..1b53d77 100644
--- a/src/map/MapState.h
+++ b/src/map/MapState.h
@@ -45,10 +45,10 @@ public:
 	virtual void HandleSyscall(common::ScriptRunner &);
 
 private:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(SDL_Surface *screen);
+	virtual void OnExitState(SDL_Surface *screen);
+	virtual void OnResumeState(SDL_Surface *screen);
+	virtual void OnPauseState(SDL_Surface *screen);
 
 	virtual void OnResize(int width, int height);
 
diff --git a/src/map/TransitionState.cpp b/src/map/TransitionState.cpp
index b339381..4490f83 100644
--- a/src/map/TransitionState.cpp
+++ b/src/map/TransitionState.cpp
@@ -24,19 +24,19 @@ TransitionState::TransitionState(MapState *ms, Map *map, const Vector<int> &coor
 
 }
 
-void TransitionState::OnEnterState(Application &c, SDL_Surface *screen) {
+void TransitionState::OnEnterState(SDL_Surface *screen) {
 
 }
 
-void TransitionState::OnExitState(Application &, SDL_Surface *screen) {
+void TransitionState::OnExitState(SDL_Surface *screen) {
 
 }
 
-void TransitionState::OnResumeState(Application &ctrl, SDL_Surface *screen) {
+void TransitionState::OnResumeState(SDL_Surface *screen) {
 
 }
 
-void TransitionState::OnPauseState(Application &ctrl, SDL_Surface *screen) {
+void TransitionState::OnPauseState(SDL_Surface *screen) {
 
 }
 
diff --git a/src/map/TransitionState.h b/src/map/TransitionState.h
index 134e54a..1790d71 100644
--- a/src/map/TransitionState.h
+++ b/src/map/TransitionState.h
@@ -27,10 +27,10 @@ public:
 	virtual void Render(SDL_Surface *);
 
 private:
-	virtual void OnEnterState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnExitState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnResumeState(app::Application &ctrl, SDL_Surface *screen);
-	virtual void OnPauseState(app::Application &ctrl, SDL_Surface *screen);
+	virtual void OnEnterState(SDL_Surface *screen);
+	virtual void OnExitState(SDL_Surface *screen);
+	virtual void OnResumeState(SDL_Surface *screen);
+	virtual void OnPauseState(SDL_Surface *screen);
 
 	virtual void OnResize(int width, int height);
 
-- 
2.39.2