V0.8.3

Currently translated at 100.0% (14998 of 14998 strings)

.gitignore

@@ -0,0 +1 @@
+/AndorsTrail/.idea/workspace.xml

.travis.yml

@@ -0,0 +1,14 @@
+dist: bionic
+sudo: required
+cache:
+  directories:
+  - $HOME/pbuilder-bases
+matrix:
+  include:
+  - env: TARGET_OS=stretch
+before_install:
+- "$TRAVIS_BUILD_DIR/travis/$TRAVIS_OS_NAME.$TARGET_OS.before_install"
+install:
+- "$TRAVIS_BUILD_DIR/travis/$TRAVIS_OS_NAME.$TARGET_OS.install"
+script:
+- "$TRAVIS_BUILD_DIR/travis/$TRAVIS_OS_NAME.$TARGET_OS.script"

AndorsTrail/.classpath

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
-	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
-	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
-	<classpathentry kind="output" path="bin/classes"/>
-</classpath>

AndorsTrail/.gitignore

@@ -1,8 +1,15 @@
 # Android ignores
+app/src/main/res
+app/src/main/assets
 gen/
 bin/
 target/
 local.properties
+app/build/intermediates/
+build/
+debug/
+release/
+.gradle/
 
 #IntelliJ
 .idea/
@@ -14,3 +21,35 @@ out/test/
 # Other
 .metadata
 .svn/
+
+
+#copied from  https://github.com/github/gitignore/blob/main/Gradle.gitignore
+.gradle
+**/build/
+!src/**/build/
+
+# Ignore Gradle GUI config
+gradle-app.setting
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar
+
+# Avoid ignore Gradle wrappper properties
+!gradle-wrapper.properties
+
+# Cache of project
+.gradletasknamecache
+
+# Eclipse Gradle plugin generated files
+# Eclipse Core
+.project
+# JDT-specific (Eclipse Java Development Tools)
+.classpath
+#copied from  https://github.com/github/gitignore/blob/main/Gradle.gitignore
+
+
+/AndorsTrail/.gradle
+/AndorsTrail/gradle/wrapper
+/AndorsTrail/app/build/
+/AndorsTrail/app/debug/
+/AndorsTrail/app/release/

AndorsTrail/.project

@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>AndorsTrail</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>

AndorsTrail/.svnignore

@@ -1,4 +0,0 @@
-gen
-bin
-.metadata
-.git

AndorsTrail/AndorsTrail.iml

@@ -1,36 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="EclipseModuleManager" forced_jdk="true">
-    <conelement value="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK" />
-    <conelement value="com.android.ide.eclipse.adt.LIBRARIES" />
-    <src_description expected_position="1">
-      <src_folder value="file://$MODULE_DIR$/src" expected_position="0" />
-      <src_folder value="file://$MODULE_DIR$/gen" expected_position="1" />
-    </src_description>
-  </component>
-  <component name="FacetManager">
-    <facet type="android" name="Android">
-      <configuration />
-    </facet>
-  </component>
-  <component name="NewModuleRootManager" inherit-compiler-output="false">
-    <output url="file://$MODULE_DIR$/bin/classes" />
-    <exclude-output />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/gen" isTestSource="false" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="module-library">
-      <library>
-        <CLASSES>
-          <root url="jar://$MODULE_DIR$/libs/android-support-v4.jar!/" />
-        </CLASSES>
-        <JAVADOC />
-        <SOURCES />
-      </library>
-    </orderEntry>
-  </component>
-</module>
-

AndorsTrail/AndroidManifest.xml

@@ -1,65 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-
-<manifest 
-	xmlns:android="http://schemas.android.com/apk/res/android" 
-	package="com.gpl.rpg.AndorsTrail"
-	android:versionCode="40"
-	android:versionName="0.7.1dev"
-	android:installLocation="auto"
-	>
-	<uses-sdk 
-		android:minSdkVersion="4" 
-		android:targetSdkVersion="17"
-		/>
-	
-	<supports-screens
-		android:smallScreens="true" 
-		android:normalScreens="true"
-		android:largeScreens="true"
-		android:xlargeScreens="true"
-		android:anyDensity="true"
-		/>
-	
-	<uses-permission 
-	    android:name="android.permission.WRITE_EXTERNAL_STORAGE" 
-	    />
-		
-	<application 
-		android:name=".AndorsTrailApplication" 
-		android:label="@string/app_name" 
-		android:icon="@drawable/icon"
-		android:description="@string/app_description"
-        android:allowBackup="true"
-		>
-		<activity 
-		    android:name=".activity.StartScreenActivity" 
-		    android:clearTaskOnLaunch="true"
-		    >
-			<intent-filter>
-				<action android:name="android.intent.action.MAIN" />
-				<category android:name="android.intent.category.LAUNCHER" />
-			</intent-filter>
-		</activity>
-   		<activity 
-			android:name=".activity.MainActivity" 
-			android:label="@string/app_name" 
-			android:theme="@style/Theme.NoBackground"
-			/>
-		<activity android:name=".activity.HeroinfoActivity" />
-		<activity android:name=".activity.MonsterInfoActivity" android:theme="@android:style/Theme.Dialog" />
-		<activity android:name=".activity.ItemInfoActivity" android:theme="@android:style/Theme.Dialog" />
-		<activity android:name=".activity.LevelUpActivity" android:theme="@android:style/Theme.Dialog" />
-		<activity android:name=".activity.MonsterEncounterActivity" android:theme="@android:style/Theme.Dialog" />
-		<activity android:name=".activity.ConversationActivity" android:theme="@android:style/Theme.Dialog" />
-		<activity android:name=".activity.ShopActivity" />
-		<activity android:name=".activity.AboutActivity" />
-		<activity android:name=".activity.LoadingActivity" />
-		<activity android:name=".activity.Preferences" />
-		<activity android:name=".activity.LoadSaveActivity" android:theme="@android:style/Theme.Dialog" />
-		<activity android:name=".activity.ActorConditionInfoActivity" android:theme="@android:style/Theme.Dialog" />
-		<activity android:name=".activity.BulkSelectionInterface" android:theme="@android:style/Theme.Dialog" />
-		<activity android:name=".activity.SkillInfoActivity" android:theme="@android:style/Theme.Dialog" />
-		<activity android:name=".activity.DisplayWorldMapActivity" />
-	</application>
-	
-</manifest>

AndorsTrail/app/build.gradle

@@ -0,0 +1,52 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 30
+    buildToolsVersion "30.0.3"
+
+    defaultConfig {
+        applicationId "com.gpl.rpg.AndorsTrail"
+        minSdkVersion 14
+        targetSdkVersion 30
+    }
+
+    buildTypes {
+        release {
+            manifestPlaceholders icon_name: 'icon', fileproviderPath: 'AndorsTrail'
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
+        }
+        debug {
+            manifestPlaceholders icon_name: 'icon_beta', fileproviderPath: 'AndorsTrail.beta2'
+            applicationIdSuffix 'beta2'
+        }
+    }
+}
+
+dependencies {
+    implementation 'com.android.support:support-v4:28.0.0'
+}
+
+task copyRes(type: Copy) {
+    description "Copies the res folder to the modules res folder (& renames .tmx to .xml)"
+    from "${rootDir}/res"
+    into "${projectDir}/src/main/res"
+    rename "(.*)\\.tmx", "\$1.xml"
+}
+
+task copyTranslation(type: Copy) {
+    description("Copies the translation files to the modules translations folder")
+    from "${rootDir}/assets/translation"
+    into "${projectDir}/src/main/assets/translation"
+}
+
+task cleanup(type: Delete) {
+    description("Deletes the assets/translation and the res folder from the modules folder")
+    delete "${projectDir}/src/main/res", "${projectDir}/src/main/assets/translation"
+}
+
+afterEvaluate {
+    preBuild.dependsOn project.tasks.copyRes
+    preBuild.dependsOn project.tasks.copyTranslation
+    clean.dependsOn project.tasks.cleanup
+}

AndorsTrail/app/lint.xml

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <lint>
     <issue id="MissingTranslation" severity="ignore" />
     <issue id="TypographyDashes" severity="ignore" />

AndorsTrail/app/src/main/AndroidManifest.xml

@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<manifest 
+	xmlns:android="http://schemas.android.com/apk/res/android" 
+	package="com.gpl.rpg.AndorsTrail"
+	android:versionCode="67"
+	android:versionName="0.8.3"
+	android:installLocation="auto"
+	>
+	<uses-sdk 
+		android:minSdkVersion="4"
+		android:targetSdkVersion="30"
+		/>
+	
+	<supports-screens
+		android:smallScreens="true" 
+		android:normalScreens="true"
+		android:largeScreens="true"
+		android:xlargeScreens="true"
+		android:anyDensity="true"
+		/>
+	
+	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+	<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+
+
+	<application 
+		android:name="com.gpl.rpg.AndorsTrail.AndorsTrailApplication"
+		android:label="@string/app_name" 
+		android:icon="@drawable/${icon_name}"
+		android:description="@string/app_description"
+        android:allowBackup="true"
+        android:theme="@style/AndorsTrailTheme_Blue"
+		android:requestLegacyExternalStorage="true"
+		android:hasFragileUserData="true"
+		android:preserveLegacyExternalStorage="true"
+		>
+		<activity 
+		    android:name="com.gpl.rpg.AndorsTrail.activity.StartScreenActivity"
+		    android:clearTaskOnLaunch="true"
+		    >
+			<intent-filter>
+				<action android:name="android.intent.action.MAIN" />
+				<category android:name="android.intent.category.LAUNCHER" />
+			</intent-filter>
+		</activity>
+   		<activity 
+			android:name="com.gpl.rpg.AndorsTrail.activity.MainActivity"
+			android:label="@string/app_name" 
+			android:theme="@style/AndorsTrailTheme_Blue.NoBackground"
+			/>
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.HeroinfoActivity" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.MonsterInfoActivity" android:theme="@style/AndorsTrailDialogTheme_Blue" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.ItemInfoActivity" android:theme="@style/AndorsTrailDialogTheme_Blue" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.LevelUpActivity" android:theme="@style/AndorsTrailDialogTheme_Blue" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.MonsterEncounterActivity" android:theme="@style/AndorsTrailDialogTheme_Blue" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.ConversationActivity" android:theme="@style/AndorsTrailDialogTheme_Blue" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.ShopActivity" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.AboutActivity" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.LoadingActivity" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.Preferences" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.LoadSaveActivity" android:theme="@style/AndorsTrailDialogTheme_Blue" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.ActorConditionInfoActivity" android:theme="@style/AndorsTrailDialogTheme_Blue" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.BulkSelectionInterface" android:theme="@style/AndorsTrailDialogTheme_Blue" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.SkillInfoActivity" android:theme="@style/AndorsTrailDialogTheme_Blue" />
+		<activity android:name="com.gpl.rpg.AndorsTrail.activity.DisplayWorldMapActivity" />
+
+        <provider
+        android:name="android.support.v4.content.FileProvider"
+        android:authorities="${applicationId}.fileprovider"
+        android:grantUriPermissions="true"
+        android:exported="false">
+        <meta-data
+            android:name="android.support.FILE_PROVIDER_PATHS"
+            android:resource="@xml/fileprovider" />
+		</provider>
+	</application>
+	
+</manifest>

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/AndorsTrailApplication.java

@@ -0,0 +1,169 @@
+package com.gpl.rpg.AndorsTrail;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Locale;
+
+import com.gpl.rpg.AndorsTrail.context.ControllerContext;
+import com.gpl.rpg.AndorsTrail.context.WorldContext;
+import com.gpl.rpg.AndorsTrail.controller.Constants;
+import com.gpl.rpg.AndorsTrail.util.AndroidStorage;
+import com.gpl.rpg.AndorsTrail.util.Pair;
+
+import android.app.Activity;
+import android.app.Application;
+import android.content.Context;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.os.Environment;
+import android.view.Window;
+import android.view.WindowManager;
+
+public final class AndorsTrailApplication extends Application {
+
+	public static final boolean DEVELOPMENT_DEBUGRESOURCES = false;
+	public static final boolean DEVELOPMENT_FORCE_STARTNEWGAME = false;
+	public static final boolean DEVELOPMENT_FORCE_CONTINUEGAME = false;
+	public static final boolean DEVELOPMENT_DEBUGBUTTONS = false;
+	public static final boolean DEVELOPMENT_FASTSPEED = false;
+	public static final boolean DEVELOPMENT_VALIDATEDATA = false;
+	public static final boolean DEVELOPMENT_DEBUGMESSAGES = false;
+	public static final String CURRENT_VERSION_DISPLAY = "0.8.3";
+	public static final boolean IS_RELEASE_VERSION = !CURRENT_VERSION_DISPLAY.matches(".*[a-d].*");
+	public static final boolean DEVELOPMENT_INCOMPATIBLE_SAVEGAMES = DEVELOPMENT_DEBUGRESOURCES || DEVELOPMENT_DEBUGBUTTONS || DEVELOPMENT_FASTSPEED || !IS_RELEASE_VERSION;
+	public static final int DEVELOPMENT_INCOMPATIBLE_SAVEGAME_VERSION = 999;
+	public static final int CURRENT_VERSION = DEVELOPMENT_INCOMPATIBLE_SAVEGAMES ? DEVELOPMENT_INCOMPATIBLE_SAVEGAME_VERSION : 67;
+
+	private final AndorsTrailPreferences preferences = new AndorsTrailPreferences();
+	private WorldContext world = new WorldContext();
+	private ControllerContext controllers = new ControllerContext(this, world);
+	private WorldSetup setup = new WorldSetup(world, controllers, this);
+	public WorldContext getWorld() { return world; }
+	public WorldSetup getWorldSetup() { return setup; }
+	public AndorsTrailPreferences getPreferences() { return preferences; }
+	public ControllerContext getControllerContext() { return controllers; }
+
+	public static AndorsTrailApplication getApplicationFromActivity(Activity activity) {
+		return ((AndorsTrailApplication) activity.getApplication());
+	}
+	public static AndorsTrailApplication getApplicationFromActivityContext(Context context) {
+		return getApplicationFromActivity(getActivityFromActivityContext(context));
+	}
+	private static Activity getActivityFromActivityContext(Context context) {
+		return (Activity) context;
+	}
+
+	public boolean isInitialized() { return world.model != null; }
+
+	public void setWindowParameters(Activity activity) {
+		activity.requestWindowFeature(Window.FEATURE_NO_TITLE);
+		if (preferences.fullscreen) {
+			activity.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+		} else {
+			activity.getWindow().setFlags(0, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+		}
+	}
+
+	//Get default locale at startup, as somehow it seems that changing the app's 
+	//configured locale impacts the value returned by Locale.getDefault() nowadays.
+	private final Locale defaultLocale = Locale.getDefault();
+
+	private Pair<String, Locale> lastLocale = null;
+
+	public boolean setLocale(Activity context) {
+		Resources res = context.getResources();
+		Configuration conf = res.getConfiguration();
+
+		Locale targetLocale;
+
+		if (lastLocale != null && lastLocale.first == preferences.language) {
+			targetLocale = lastLocale.second;
+		} else {
+			targetLocale = localeForLanguageTag(preferences.language);
+			lastLocale = new Pair<String, Locale>(preferences.language, targetLocale);
+		}
+
+		if (targetLocale.equals(conf.locale)) {
+			return false;
+		}
+
+		conf.locale = targetLocale;
+		res.updateConfiguration(conf, res.getDisplayMetrics());
+		this.getResources().updateConfiguration(conf, res.getDisplayMetrics());
+		
+		return true;
+	}
+
+	// Supports language or language_COUNTRY in short form e.g. "en" or "en_US"
+	private Locale localeForLanguageTag(String languageTag) {
+		Locale locale = null;
+		if (languageTag != null && !languageTag.equalsIgnoreCase("default")) {
+			final int pos = languageTag.indexOf('-');
+			if (pos == -1) {
+				locale = new Locale(languageTag);
+			}
+			else locale = new Locale(languageTag.substring(0, pos), languageTag.substring(pos+1));
+		}
+		if (locale == null) {
+			locale = defaultLocale;
+		}
+		return locale;
+	}
+
+	/**
+	 * Logging to text file system as found on https://stackoverflow.com/questions/19565685/saving-logcat-to-a-text-file-in-android-device
+	 */
+	
+	public void onCreate() {
+		super.onCreate();
+
+		if ( DEVELOPMENT_DEBUGMESSAGES && isExternalStorageWritable() ) {
+			File appDirectory = AndroidStorage.getStorageDirectory(getApplicationContext(), Constants.FILENAME_SAVEGAME_DIRECTORY);
+			File logDirectory = new File( appDirectory, "log" );
+			File logFile = new File( logDirectory, "logcat" + System.currentTimeMillis() + ".txt" );
+
+			// create app folder
+			if ( !appDirectory.exists() ) {
+				appDirectory.mkdir();
+			}
+
+			// create log folder
+			if ( !logDirectory.exists() ) {
+				logDirectory.mkdir();
+			}
+
+			// clear the previous logcat and then write the new one to the file
+			try {
+				Process process = Runtime.getRuntime().exec("logcat -c");
+				process = Runtime.getRuntime().exec("logcat -f " + logFile+" *:W");
+			} catch ( IOException e ) {
+				e.printStackTrace();
+			}
+
+		}
+	}
+
+	/* Checks if external storage is available for read and write */
+	public boolean isExternalStorageWritable() {
+		String state = Environment.getExternalStorageState();
+		if ( Environment.MEDIA_MOUNTED.equals( state ) ) {
+			return true;
+		}
+		return false;
+	}
+
+	/* Checks if external storage is available to at least read */
+	public boolean isExternalStorageReadable() {
+		String state = Environment.getExternalStorageState();
+		if ( Environment.MEDIA_MOUNTED.equals( state ) ||
+				Environment.MEDIA_MOUNTED_READ_ONLY.equals( state ) ) {
+			return true;
+		}
+		return false;
+	}
+	public void discardWorld() {
+		world = new WorldContext();
+		controllers = new ControllerContext(this, world);
+		setup = new WorldSetup(world, controllers, getApplicationContext());
+	}
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/AndorsTrailPreferences.java

@@ -25,6 +25,11 @@ public final class AndorsTrailPreferences {
 	public static final int DPAD_POSITION_UPPER_LEFT = 6;
 	public static final int DPAD_POSITION_UPPER_RIGHT = 7;
 	public static final int DPAD_POSITION_UPPER_CENTER = 8;
+	public static final int DPAD_TRANSPARENCY_30_PERCENT = 0;
+	public static final int DPAD_TRANSPARENCY_40_PERCENT = 1;
+	public static final int DPAD_TRANSPARENCY_50_PERCENT = 2;
+	public static final int DPAD_TRANSPARENCY_60_PERCENT = 3;
+	public static final int DPAD_TRANSPARENCY_70_PERCENT = 4;
 	public static final int CONFIRM_OVERWRITE_SAVEGAME_ALWAYS = 0;
 	public static final int CONFIRM_OVERWRITE_SAVEGAME_WHEN_PLAYERNAME_DIFFERS = 1;
 	public static final int CONFIRM_OVERWRITE_SAVEGAME_NEVER = 2;
@@ -35,6 +40,7 @@ public final class AndorsTrailPreferences {
 	public static final int QUICKSLOTS_POSITION_HORIZONTAL_BOTTOM_LEFT = 4;
 	public static final int QUICKSLOTS_POSITION_HORIZONTAL_BOTTOM_RIGHT = 5;
 	public static final int QUICKSLOTS_POSITION_VERTICAL_BOTTOM_RIGHT = 6;
+	public static final int ATTACKSPEED_DEFAULT_MILLISECONDS = 1000;
 
 	public boolean confirmRest = true;
 	public boolean confirmAttack = true;
@@ -45,13 +51,17 @@ public final class AndorsTrailPreferences {
 	public int movementAggressiveness = MOVEMENTAGGRESSIVENESS_NORMAL;
 	public float scalingFactor = 1.0f;
 	public int dpadPosition;
+	public int dpadTransparency;
 	public boolean dpadMinimizeable = true;
 	public boolean optimizedDrawing = false;
+	public boolean highQualityFilters = true;
 	public boolean enableUiAnimations = true;
 	public int displayOverwriteSavegame = CONFIRM_OVERWRITE_SAVEGAME_ALWAYS;
 	public int quickslotsPosition = QUICKSLOTS_POSITION_HORIZONTAL_CENTER_BOTTOM;
 	public boolean showQuickslotsWhenToolboxIsVisible = false;
-	public boolean useLocalizedResources = true;
+	public String language = "default";
+
+	public int selectedTheme = 0;
 
 	public void read(final Context androidContext) {
 		AndorsTrailPreferences dest = this;
@@ -65,14 +75,16 @@ public final class AndorsTrailPreferences {
 			dest.movementMethod = Integer.parseInt(prefs.getString("movementmethod", Integer.toString(MOVEMENTMETHOD_STRAIGHT)));
 			dest.scalingFactor = Float.parseFloat(prefs.getString("scaling_factor", "1.0f"));
 			dest.dpadPosition = Integer.parseInt(prefs.getString("dpadposition", Integer.toString(DPAD_POSITION_DISABLED)));
+			dest.dpadTransparency = Integer.parseInt(prefs.getString("dpadtransparency", Integer.toString(DPAD_TRANSPARENCY_50_PERCENT)));
 			dest.dpadMinimizeable = prefs.getBoolean("dpadMinimizeable", true);
 			dest.optimizedDrawing = prefs.getBoolean("optimized_drawing", false);
+			dest.highQualityFilters = prefs.getBoolean("high_quality_filters", true);
 			dest.enableUiAnimations = prefs.getBoolean("enableUiAnimations", true);
 			dest.displayOverwriteSavegame = Integer.parseInt(prefs.getString("display_overwrite_savegame", Integer.toString(CONFIRM_OVERWRITE_SAVEGAME_ALWAYS)));
 			dest.quickslotsPosition = Integer.parseInt(prefs.getString("quickslots_placement", Integer.toString(QUICKSLOTS_POSITION_HORIZONTAL_CENTER_BOTTOM)));
 			dest.showQuickslotsWhenToolboxIsVisible = prefs.getBoolean("showQuickslotsWhenToolboxIsVisible", false);
-			dest.useLocalizedResources = prefs.getBoolean("useLocalizedResources", true);
-
+			dest.language = prefs.getString("language", "default");
+			dest.selectedTheme = Integer.parseInt(prefs.getString("selectedTheme", Integer.toString(0)));
 			// This might be implemented as a skill in the future.
 			//dest.movementAggressiveness = Integer.parseInt(prefs.getString("movementaggressiveness", Integer.toString(MOVEMENTAGGRESSIVENESS_NORMAL)));
 		} catch (Exception e) {
@@ -85,13 +97,16 @@ public final class AndorsTrailPreferences {
 			dest.movementAggressiveness = MOVEMENTAGGRESSIVENESS_NORMAL;
 			dest.scalingFactor = 1.0f;
 			dest.dpadPosition = DPAD_POSITION_DISABLED;
+			dest.dpadTransparency = DPAD_TRANSPARENCY_50_PERCENT;
 			dest.dpadMinimizeable = true;
 			dest.optimizedDrawing = false;
+			dest.highQualityFilters = true;
 			dest.enableUiAnimations = true;
 			dest.displayOverwriteSavegame = CONFIRM_OVERWRITE_SAVEGAME_ALWAYS;
 			dest.quickslotsPosition = QUICKSLOTS_POSITION_HORIZONTAL_CENTER_BOTTOM;
 			dest.showQuickslotsWhenToolboxIsVisible = false;
-			dest.useLocalizedResources = true;
+			dest.language = "default";
+			dest.selectedTheme = 0;
 		}
 	}
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/Dialogs.java

@@ -1,22 +1,40 @@
 package com.gpl.rpg.AndorsTrail;
 
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+
+import android.annotation.TargetApi;
 import android.app.Activity;
-import android.app.AlertDialog;
 import android.app.Dialog;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.DialogInterface.OnDismissListener;
 import android.content.Intent;
-import android.graphics.drawable.BitmapDrawable;
+import android.content.pm.PackageManager;
 import android.net.Uri;
+import android.os.Build;
 import android.os.Bundle;
+import android.support.v4.app.Fragment;
 import android.view.View;
+import android.view.ViewGroup;
 import android.widget.AdapterView;
 import android.widget.AdapterView.OnItemClickListener;
 import android.widget.ArrayAdapter;
 import android.widget.ListView;
 import android.widget.Toast;
-import com.gpl.rpg.AndorsTrail.activity.*;
+
+import com.gpl.rpg.AndorsTrail.activity.ActorConditionInfoActivity;
+import com.gpl.rpg.AndorsTrail.activity.BulkSelectionInterface;
+import com.gpl.rpg.AndorsTrail.activity.ConversationActivity;
+import com.gpl.rpg.AndorsTrail.activity.ItemInfoActivity;
+import com.gpl.rpg.AndorsTrail.activity.LevelUpActivity;
+import com.gpl.rpg.AndorsTrail.activity.LoadSaveActivity;
+import com.gpl.rpg.AndorsTrail.activity.MainActivity;
+import com.gpl.rpg.AndorsTrail.activity.MonsterEncounterActivity;
+import com.gpl.rpg.AndorsTrail.activity.MonsterInfoActivity;
+import com.gpl.rpg.AndorsTrail.activity.SkillInfoActivity;
+import com.gpl.rpg.AndorsTrail.activity.fragment.StartScreenActivity_MainMenu;
 import com.gpl.rpg.AndorsTrail.context.ControllerContext;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.model.ability.ActorConditionType;
@@ -26,28 +44,26 @@ import com.gpl.rpg.AndorsTrail.model.item.Inventory;
 import com.gpl.rpg.AndorsTrail.model.item.ItemType;
 import com.gpl.rpg.AndorsTrail.model.item.Loot;
 import com.gpl.rpg.AndorsTrail.model.map.MapObject;
-import com.gpl.rpg.AndorsTrail.resource.tiles.TileManager;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory.CustomDialog;
 import com.gpl.rpg.AndorsTrail.view.ItemContainerAdapter;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-
 public final class Dialogs {
 
-	private static void showDialogAndPause(Dialog d, final ControllerContext context) {
+	private static void showDialogAndPause(CustomDialog d, final ControllerContext context) {
 		showDialogAndPause(d, context, null);
 	}
-	private static void showDialogAndPause(Dialog d, final ControllerContext context, final OnDismissListener onDismiss) {
+	private static void showDialogAndPause(CustomDialog d, final ControllerContext context, final OnDismissListener onDismiss) {
 		context.gameRoundController.pause();
-		d.setOnDismissListener(new OnDismissListener() {
+		CustomDialogFactory.setDismissListener(d, new OnDismissListener() {
 			@Override
 			public void onDismiss(DialogInterface arg0) {
 				if (onDismiss != null) onDismiss.onDismiss(arg0);
 				context.gameRoundController.resume();
 			}
 		});
-		d.show();
+		CustomDialogFactory.show(d);
 	}
 
 	public static void showKeyArea(final MainActivity currentActivity, final ControllerContext context, String phraseID) {
@@ -58,10 +74,19 @@ public final class Dialogs {
 		showConversation(currentActivity, context, phraseID, null);
 	}
 
+	public static void showMapScriptMessage(final MainActivity currentActivity, final ControllerContext context, String phraseID) {
+		showConversation(currentActivity, context, phraseID, null, false);
+	}
+
 	public static void showConversation(final MainActivity currentActivity, final ControllerContext context, final String phraseID, final Monster npc) {
+		showConversation(currentActivity, context, phraseID, npc, true);
+	}
+
+	private static void showConversation(final MainActivity currentActivity, final ControllerContext context, final String phraseID, final Monster npc, boolean applyScriptEffectsForFirstPhrase) {
 		context.gameRoundController.pause();
 		Intent intent = new Intent(currentActivity, ConversationActivity.class);
 		intent.setData(Uri.parse("content://com.gpl.rpg.AndorsTrail/conversation/" + phraseID));
+		intent.putExtra("applyScriptEffectsForFirstPhrase", applyScriptEffectsForFirstPhrase);
 		addMonsterIdentifiers(intent, npc);
 		currentActivity.startActivityForResult(intent, MainActivity.INTENTREQUEST_CONVERSATION);
 	}
@@ -85,7 +110,7 @@ public final class Dialogs {
 		if (!params.containsKey("x")) return null;
 		int x = params.getInt("x");
 		int y = params.getInt("y");
-		return world.model.currentMap.getMonsterAt(x, y);
+		return world.model.currentMaps.map.getMonsterAt(x, y);
 	}
 
 	public static void showMonsterEncounter(final MainActivity currentActivity, final ControllerContext context, final Monster monster) {
@@ -162,12 +187,23 @@ public final class Dialogs {
 
 	public static void showGroundLoot(final MainActivity mainActivity, final ControllerContext controllers, final WorldContext world, final Loot loot, final String msg) {
 		showLoot(mainActivity, controllers, world, loot, Collections.singletonList(loot), R.string.dialog_groundloot_title, msg);
- 	}
+	}
 
 	private static void showLoot(final MainActivity mainActivity, final ControllerContext controllers, final WorldContext world, final Loot combinedLoot, final Iterable<Loot> lootBags, final int title, final String msg) {
 		final ListView itemList = new ListView(mainActivity);
+		itemList.setBackgroundResource(android.R.color.transparent);
 		itemList.setLayoutParams(new ListView.LayoutParams(ListView.LayoutParams.MATCH_PARENT, ListView.LayoutParams.WRAP_CONTENT));
-		itemList.setPadding(20, 0, 20, 20);
+		//		itemList.setPadding(20, 0, 20, 20);
+		itemList.setAdapter(new ItemContainerAdapter(mainActivity, world.tileManager, combinedLoot.items, world.model.player));
+
+		final CustomDialog d = CustomDialogFactory.createDialog(mainActivity,
+				mainActivity.getResources().getString(title), 
+				mainActivity.getResources().getDrawable(R.drawable.ui_icon_equipment), 
+				msg, 
+				combinedLoot.items.isEmpty() ? null : itemList, 
+				true,
+				false);
+
 		itemList.setOnItemClickListener(new OnItemClickListener() {
 			@Override
 			public void onItemClick(AdapterView<?> parent, View v, int position, long id) {
@@ -181,31 +217,29 @@ public final class Dialogs {
 						break;
 					}
 				}
-				if (removeFromCombinedLoot) combinedLoot.items.removeItem(itemTypeID);
+				if (removeFromCombinedLoot) {
+					combinedLoot.items.removeItem(itemTypeID);
+				}
+				if (((ItemContainerAdapter) parent.getAdapter()).isEmpty()) {
+					ViewGroup vg = (ViewGroup) d.findViewById(R.id.dialog_content_container);
+					vg.setVisibility(View.GONE);
+				}
 				ItemType type = world.itemTypes.getItemType(itemTypeID);
 				world.model.player.inventory.addItem(type);
 				((ItemContainerAdapter) itemList.getAdapter()).notifyDataSetChanged();
 			}
 		});
-		itemList.setAdapter(new ItemContainerAdapter(mainActivity, world.tileManager, combinedLoot.items, world.model.player));
 
-		AlertDialog.Builder db = new AlertDialog.Builder(mainActivity)
-		.setTitle(title)
-		.setMessage(msg)
-		.setIcon(new BitmapDrawable(mainActivity.getResources(), world.tileManager.preloadedTiles.getBitmap(TileManager.iconID_groundbag)))
-		.setNegativeButton(R.string.dialog_close, null)
-		.setView(itemList);
-
-		if (!combinedLoot.items.isEmpty()) {
-			db.setPositiveButton(R.string.dialog_loot_pickall, new DialogInterface.OnClickListener() {
+		if (!itemList.getAdapter().isEmpty()) {
+			CustomDialogFactory.addButton(d, R.string.dialog_loot_pickall, new View.OnClickListener() {
 				@Override
-				public void onClick(DialogInterface dialog, int which) {
+				public void onClick(View v) {
 					controllers.itemController.pickupAll(lootBags);
 				}
 			});
 		}
 
-		final Dialog d = db.create();
+		CustomDialogFactory.addDismissButton(d, R.string.dialog_close);
 
 		showDialogAndPause(d, controllers, new OnDismissListener() {
 			@Override
@@ -215,10 +249,31 @@ public final class Dialogs {
 		});
 	}
 
+	public static void showHeroDied(final MainActivity mainActivity, final ControllerContext controllers) {
+		final CustomDialog d = CustomDialogFactory.createDialog(mainActivity,
+				mainActivity.getResources().getString(R.string.dialog_game_over_title),
+				mainActivity.getResources().getDrawable(R.drawable.ui_icon_combat),
+				mainActivity.getResources().getString(R.string.dialog_game_over_text),
+				null,
+				true,
+				false);
+
+		CustomDialogFactory.addDismissButton(d, android.R.string.ok);
+
+		showDialogAndPause(d, controllers, new OnDismissListener() {
+			@Override
+			public void onDismiss(DialogInterface arg0) {
+				mainActivity.finish();
+			}
+		});
+	}
+
+
 	public static Intent getIntentForItemInfo(final Context ctx, String itemTypeID, ItemInfoActivity.ItemInfoAction actionType, String buttonText, boolean buttonEnabled, Inventory.WearSlot inventorySlot) {
 		Intent intent = new Intent(ctx, ItemInfoActivity.class);
 		intent.putExtra("buttonText", buttonText);
 		intent.putExtra("buttonEnabled", buttonEnabled);
+		intent.putExtra("moreActions", (actionType == ItemInfoActivity.ItemInfoAction.equip || actionType == ItemInfoActivity.ItemInfoAction.use || actionType == ItemInfoActivity.ItemInfoAction.none));
 		intent.putExtra("itemTypeID", itemTypeID);
 		intent.putExtra("actionType", actionType.name());
 		if (inventorySlot != null) intent.putExtra("inventorySlot", inventorySlot.name());
@@ -232,36 +287,82 @@ public final class Dialogs {
 	}
 
 	public static void showConfirmRest(final Activity currentActivity, final ControllerContext controllerContext, final MapObject area) {
-		Dialog d = new AlertDialog.Builder(currentActivity)
-		.setTitle(R.string.dialog_rest_title)
-		.setMessage(R.string.dialog_rest_confirm_message)
-		.setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
+		final CustomDialog d = CustomDialogFactory.createDialog(currentActivity,
+				currentActivity.getResources().getString(R.string.dialog_rest_title), 
+				null, 
+				currentActivity.getResources().getString(R.string.dialog_rest_confirm_message), 
+				null, 
+				true);
+
+		CustomDialogFactory.addButton(d, android.R.string.yes, new View.OnClickListener() {
 			@Override
-			public void onClick(DialogInterface dialog, int which) {
+			public void onClick(View v) {
 				controllerContext.mapController.rest(area);
 			}
-		})
-		.setNegativeButton(android.R.string.no, null)
-		.create();
+		});
+
+		CustomDialogFactory.addDismissButton(d, android.R.string.no);
 
 		showDialogAndPause(d, controllerContext);
 	}
 	public static void showRested(final Activity currentActivity, final ControllerContext controllerContext) {
-		Dialog d = new AlertDialog.Builder(currentActivity)
-		.setTitle(R.string.dialog_rest_title)
-		.setMessage(R.string.dialog_rest_message)
-		.setNeutralButton(android.R.string.ok, null)
-		.create();
+		//		Dialog d = new AlertDialog.Builder(new ContextThemeWrapper(currentActivity, R.style.AndorsTrailStyle))
+		//		.setTitle(R.string.dialog_rest_title)
+		//		.setMessage(R.string.dialog_rest_message)
+		//		.setNeutralButton(android.R.string.ok, null)
+		//		.create();
+		final CustomDialog d = CustomDialogFactory.createDialog(currentActivity,
+				currentActivity.getResources().getString(R.string.dialog_rest_title), 
+				null, 
+				currentActivity.getResources().getString(R.string.dialog_rest_message), 
+				null, 
+				true);
+
+
+		CustomDialogFactory.addDismissButton(d, android.R.string.ok);
 
 		showDialogAndPause(d, controllerContext);
 	}
 
-	public static void showNewVersion(final Activity currentActivity) {
-		new AlertDialog.Builder(currentActivity)
-		.setTitle(R.string.dialog_newversion_title)
-		.setMessage(R.string.dialog_newversion_message)
-		.setNeutralButton(android.R.string.ok, null)
-		.show();
+	public static void showNewVersion(final Activity currentActivity, final OnDismissListener onDismiss) {
+		//		new AlertDialog.Builder(new ContextThemeWrapper(currentActivity, R.style.AndorsTrailStyle))
+		//		.setTitle(R.string.dialog_newversion_title)
+		//		.setMessage(R.string.dialog_newversion_message)
+		//		.setNeutralButton(android.R.string.ok, null)
+		//		.show();
+
+		String text = currentActivity.getResources().getString(R.string.dialog_newversion_message);
+		
+		if (!hasPermissions(currentActivity) && Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+			text += currentActivity.getResources().getString(R.string.dialog_newversion_permission_information);
+		}
+
+		final CustomDialog d = CustomDialogFactory.createDialog(currentActivity,
+				currentActivity.getResources().getString(R.string.dialog_newversion_title), 
+				null, 
+				text,
+				null, 
+				true);
+
+		CustomDialogFactory.addDismissButton(d, android.R.string.ok);
+		CustomDialogFactory.setDismissListener(d, new OnDismissListener() {
+			@Override
+			public void onDismiss(DialogInterface arg0) {
+				if (onDismiss != null) onDismiss.onDismiss(arg0);
+			}
+		});
+		CustomDialogFactory.show(d);
+	}
+
+	@TargetApi(23)
+	private static boolean hasPermissions(final Activity activity) {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+			if (activity.getApplicationContext().checkSelfPermission(android.Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED
+					|| activity.getApplicationContext().checkSelfPermission(android.Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
+				return false;
+			}
+		}
+		return true;
 	}
 
 	public static boolean showSave(final Activity mainActivity, final ControllerContext controllerContext, final WorldContext world) {
@@ -269,17 +370,45 @@ public final class Dialogs {
 			Toast.makeText(mainActivity, R.string.menu_save_saving_not_allowed_in_combat, Toast.LENGTH_SHORT).show();
 			return false;
 		}
-		controllerContext.gameRoundController.pause();
-		Intent intent = new Intent(mainActivity, LoadSaveActivity.class);
-		intent.setData(Uri.parse("content://com.gpl.rpg.AndorsTrail/save"));
-		mainActivity.startActivityForResult(intent, MainActivity.INTENTREQUEST_SAVEGAME);
-		return true;
+
+		if (!world.model.statistics.hasUnlimitedSaves()) {
+			final CustomDialog d = CustomDialogFactory.createDialog(mainActivity,
+					mainActivity.getResources().getString(R.string.menu_save_switch_character_title),
+					null,
+					mainActivity.getResources().getString(R.string.menu_save_switch_character),
+					null,
+					true);
+			CustomDialogFactory.addButton(d, android.R.string.ok, new View.OnClickListener() {
+				@Override
+				public void onClick(View v) {
+					controllerContext.gameRoundController.pause();
+					Intent intent = new Intent(mainActivity, LoadSaveActivity.class);
+					intent.setData(Uri.parse("content://com.gpl.rpg.AndorsTrail/save"));
+					mainActivity.startActivityForResult(intent, MainActivity.INTENTREQUEST_SAVEGAME);
+				}
+			});
+			CustomDialogFactory.addDismissButton(d, android.R.string.cancel);
+			CustomDialogFactory.show(d);
+			return false;
+		} else {
+			controllerContext.gameRoundController.pause();
+			Intent intent = new Intent(mainActivity, LoadSaveActivity.class);
+			intent.setData(Uri.parse("content://com.gpl.rpg.AndorsTrail/save"));
+			mainActivity.startActivityForResult(intent, MainActivity.INTENTREQUEST_SAVEGAME);
+			return true;
+		}
 	}
 
 	public static void showLoad(final Activity currentActivity) {
 		Intent intent = new Intent(currentActivity, LoadSaveActivity.class);
 		intent.setData(Uri.parse("content://com.gpl.rpg.AndorsTrail/load"));
-		currentActivity.startActivityForResult(intent, StartScreenActivity.INTENTREQUEST_LOADGAME);
+		currentActivity.startActivityForResult(intent, StartScreenActivity_MainMenu.INTENTREQUEST_LOADGAME);
+	}
+
+	public static void showLoad(final Fragment currentFragment) {
+		Intent intent = new Intent(currentFragment.getActivity(), LoadSaveActivity.class);
+		intent.setData(Uri.parse("content://com.gpl.rpg.AndorsTrail/load"));
+		currentFragment.startActivityForResult(intent, StartScreenActivity_MainMenu.INTENTREQUEST_LOADGAME);
 	}
 
 	public static void showActorConditionInfo(final Context context, ActorConditionType conditionType) {
@@ -316,22 +445,31 @@ public final class Dialogs {
 	}
 
 	public static void showCombatLog(final Context context, final ControllerContext controllerContext, final WorldContext world) {
-		final String[] combatLogMessages = world.model.combatLog.getAllMessages();
+		String[] combatLogMessages = world.model.combatLog.getAllMessages();
 
-		final ListView itemList = new ListView(context);
+		View view = null;
+		ListView itemList = null;
+		itemList = new ListView(context);
 		itemList.setLayoutParams(new ListView.LayoutParams(ListView.LayoutParams.MATCH_PARENT, ListView.LayoutParams.WRAP_CONTENT));
-		itemList.setPadding(20, 0, 20, 20);
 		itemList.setStackFromBottom(true);
 		itemList.setTranscriptMode(ListView.TRANSCRIPT_MODE_ALWAYS_SCROLL);
 		itemList.setChoiceMode(ListView.CHOICE_MODE_NONE);
+		itemList.setBackgroundColor(ThemeHelper.getThemeColor(context, R.attr.ui_theme_stdframe_bg_color));
+		if (combatLogMessages.length <= 0) {
+			combatLogMessages = new String[] {context.getResources().getString(R.string.combat_log_noentries)};
+		}
 		itemList.setAdapter(new ArrayAdapter<String>(context, R.layout.combatlog_row, android.R.id.text1, combatLogMessages));
+		view = itemList;
 
-		final Dialog d = new AlertDialog.Builder(context)
-				.setTitle(R.string.combat_log_title)
-				.setIcon(R.drawable.ui_icon_combat)
-				.setNegativeButton(R.string.dialog_close, null)
-				.setView(itemList)
-				.create();
+		final CustomDialog d = CustomDialogFactory.createDialog(context,
+				context.getResources().getString(R.string.combat_log_title), 
+				context.getResources().getDrawable(R.drawable.ui_icon_combat), 
+				null, 
+				view, 
+				true);
+
+
+		CustomDialogFactory.addDismissButton(d, R.string.dialog_close);
 
 		showDialogAndPause(d, controllerContext);
 	}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/WorldSetup.java

@@ -1,16 +1,17 @@
 package com.gpl.rpg.AndorsTrail;
 
+import java.lang.ref.WeakReference;
+
 import android.content.Context;
 import android.content.res.Resources;
 import android.os.AsyncTask;
+
 import com.gpl.rpg.AndorsTrail.context.ControllerContext;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.model.ModelContainer;
 import com.gpl.rpg.AndorsTrail.resource.ResourceLoader;
 import com.gpl.rpg.AndorsTrail.savegames.Savegames;
 
-import java.lang.ref.WeakReference;
-
 public final class WorldSetup {
 
 	private final WorldContext world;
@@ -26,7 +27,10 @@ public final class WorldSetup {
 	public int loadFromSlot = Savegames.SLOT_QUICKSAVE;
 	public boolean isSceneReady = false;
 	public String newHeroName;
-	private int loadResult;
+	public int newHeroIcon;
+	public int newHeroStartLives;
+	public boolean newHeroUnlimitedSaves;
+	private Savegames.LoadSavegameResult loadResult;
 
 	public WorldSetup(WorldContext world, ControllerContext controllers, Context androidContext) {
 		this.world = world;
@@ -53,10 +57,14 @@ public final class WorldSetup {
 			isInitializingResources = true;
 		}
 
+		//Load resources essential to the app synchroneously
+		ResourceLoader.loadResourcesSync(world, r);
+		
+		//And the rest asynchroneously
 		(new AsyncTask<Void, Void, Void>() {
 			@Override
 			protected Void doInBackground(Void... arg0) {
-				ResourceLoader.loadResources(world, r);
+				ResourceLoader.loadResourcesAsync(world, r);
 				return null;
 			}
 
@@ -102,10 +110,10 @@ public final class WorldSetup {
 			@Override
 			protected Void doInBackground(Void... arg0) {
 				synchronized (onlyOneThreadAtATimeMayLoadSavegames) {
-					if (world.model != null) world.reset();
+					if (world.model != null) world.resetForNewGame();
 					if (createNewCharacter) {
 						createNewWorld();
-						loadResult = Savegames.LOAD_RESULT_SUCCESS;
+						loadResult = Savegames.LoadSavegameResult.success;
 					} else {
 						loadResult = continueWorld();
 					}
@@ -126,7 +134,7 @@ public final class WorldSetup {
 					onSceneLoadedListener = null;
 					if (o == null) return;
 
-					if (loadResult == Savegames.LOAD_RESULT_SUCCESS) {
+					if (loadResult == Savegames.LoadSavegameResult.success) {
 						o.onSceneLoaded();
 					} else {
 						o.onSceneLoadFailed(loadResult);
@@ -136,15 +144,15 @@ public final class WorldSetup {
 		}).execute();
 	}
 
-	private int continueWorld() {
+	private Savegames.LoadSavegameResult continueWorld() {
 		Context ctx = androidContext.get();
 		return Savegames.loadWorld(world, controllers, ctx, loadFromSlot);
 	}
 
 	private void createNewWorld() {
 		Context ctx = androidContext.get();
-		world.model = new ModelContainer();
-		world.model.player.initializeNewPlayer(world.itemTypes, world.dropLists, newHeroName);
+		world.model = new ModelContainer(newHeroStartLives, newHeroUnlimitedSaves);
+		world.model.player.initializeNewPlayer(world.dropLists, newHeroName, newHeroIcon);
 
 		controllers.actorStatsController.recalculatePlayerStats(world.model.player);
 		controllers.movementController.respawnPlayer(ctx.getResources());
@@ -152,9 +160,9 @@ public final class WorldSetup {
 	}
 
 
-	public interface OnSceneLoadedListener {
+	public static interface OnSceneLoadedListener {
 		void onSceneLoaded();
-		void onSceneLoadFailed(int loadResult);
+		void onSceneLoadFailed(Savegames.LoadSavegameResult loadResult);
 	}
 	public interface OnResourcesLoadedListener {
 		void onResourcesLoaded();

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/AboutActivity.java

@@ -1,6 +1,5 @@
 package com.gpl.rpg.AndorsTrail.activity;
 
-import android.app.Activity;
 import android.content.res.Resources;
 import android.graphics.drawable.Drawable;
 import android.os.Bundle;
@@ -11,14 +10,17 @@ import android.view.View;
 import android.view.View.OnClickListener;
 import android.widget.Button;
 import android.widget.TextView;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.R;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
 
-public final class AboutActivity extends Activity implements ImageGetter {
+public final class AboutActivity extends AndorsTrailBaseActivity implements ImageGetter {
 
 	/** Called when the activity is first created. */
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getBaseTheme());
 		super.onCreate(savedInstanceState);
 
 		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/ActorConditionInfoActivity.java

@@ -1,6 +1,5 @@
 package com.gpl.rpg.AndorsTrail.activity;
 
-import android.app.Activity;
 import android.content.res.Resources;
 import android.os.Bundle;
 import android.view.View;
@@ -9,17 +8,20 @@ import android.view.Window;
 import android.widget.Button;
 import android.widget.LinearLayout;
 import android.widget.TextView;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.model.ability.ActorConditionType;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
 import com.gpl.rpg.AndorsTrail.view.AbilityModifierInfoView;
 import com.gpl.rpg.AndorsTrail.view.ItemEffectsView_OnUse;
 
-public final class ActorConditionInfoActivity extends Activity {
+public final class ActorConditionInfoActivity extends AndorsTrailBaseActivity {
 
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getDialogTheme());
 		super.onCreate(savedInstanceState);
 		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
 		if (!app.isInitialized()) { finish(); return; }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/AndorsTrailBaseActivity.java

@@ -0,0 +1,23 @@
+package com.gpl.rpg.AndorsTrail.activity;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
+
+public abstract class AndorsTrailBaseActivity extends Activity {
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
+        app.setLocale(this);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
+        app.setLocale(this);
+    }
+}
+

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/AndorsTrailBaseFragmentActivity.java

@@ -0,0 +1,22 @@
+package com.gpl.rpg.AndorsTrail.activity;
+
+import android.os.Bundle;
+import android.support.v4.app.FragmentActivity;
+
+import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
+
+public abstract class AndorsTrailBaseFragmentActivity extends FragmentActivity {
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
+        app.setLocale(this);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
+        app.setLocale(this);
+    }
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/BulkSelectionInterface.java

@@ -1,8 +1,6 @@
 package com.gpl.rpg.AndorsTrail.activity;
 
-import android.app.Activity;
-import android.app.AlertDialog;
-import android.content.DialogInterface;
+import android.app.Dialog;
 import android.content.Intent;
 import android.content.res.Resources;
 import android.os.Bundle;
@@ -17,17 +15,21 @@ import android.widget.Button;
 import android.widget.EditText;
 import android.widget.SeekBar;
 import android.widget.TextView;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.controller.ItemController;
 import com.gpl.rpg.AndorsTrail.model.item.ItemType;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory.CustomDialog;
 
 /**
  * @author ejwessel
  * Creates the BulkSelectionInterface dialog that allows for buy/drop/selling
  */
-public final class BulkSelectionInterface extends Activity implements TextWatcher {
+public final class BulkSelectionInterface extends AndorsTrailBaseActivity implements TextWatcher {
 
 	// class variables
 	public static enum BulkInterfaceType {
@@ -70,6 +72,7 @@ public final class BulkSelectionInterface extends Activity implements TextWatche
 	 */
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getDialogTheme());
 		super.onCreate(savedInstanceState);
 		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
 		if (!app.isInitialized()) { finish(); return; }
@@ -192,18 +195,33 @@ public final class BulkSelectionInterface extends Activity implements TextWatche
 					final String displayType = ItemInfoActivity.getDisplayTypeString(res, itemType).toLowerCase();
 					final String message = res.getString(R.string.bulkselection_sell_confirmation, itemType.getName(world.model.player), displayType);
 
-					new AlertDialog.Builder(v.getContext())
-						.setIcon(android.R.drawable.ic_dialog_info)
-						.setTitle(R.string.bulkselection_sell_confirmation_title)
-						.setMessage(message)
-						.setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
+//					new AlertDialog.Builder(v.getContext())
+//						.setIcon(android.R.drawable.ic_dialog_info)
+//						.setTitle(R.string.bulkselection_sell_confirmation_title)
+//						.setMessage(message)
+//						.setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
+//							@Override
+//							public void onClick(DialogInterface dialog, int which) {
+//								itemsResult(intent);
+//							}
+//									})
+//						.setNegativeButton(android.R.string.no, null)
+//						.show();
+					final CustomDialog d = CustomDialogFactory.createDialog(v.getContext(),
+							v.getContext().getResources().getString(R.string.bulkselection_sell_confirmation_title),
+							v.getContext().getResources().getDrawable(android.R.drawable.ic_dialog_info),
+							message,
+							null,
+							true);
+					CustomDialogFactory.addButton(d, android.R.string.yes,  new View.OnClickListener() {
 							@Override
-							public void onClick(DialogInterface dialog, int which) {
+							public void onClick(View v) {
 								itemsResult(intent);
 							}
-									})
-						.setNegativeButton(android.R.string.no, null)
-						.show();
+					});
+					CustomDialogFactory.addDismissButton(d, android.R.string.no);
+					CustomDialogFactory.show(d);
+					
 				} else {
 					itemsResult(intent);
 				}
@@ -289,7 +307,7 @@ public final class BulkSelectionInterface extends Activity implements TextWatche
 		if (s.equals("")) return 0;
 		try {
 			return Integer.parseInt(s);
-		} catch (NumberFormatException e) {	}
+		} catch (NumberFormatException ignored) { }
 		return 0;
 	}
 

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/ConversationActivity.java

@@ -1,10 +1,12 @@
 package com.gpl.rpg.AndorsTrail.activity;
 
-import android.app.Activity;
+import java.util.ArrayList;
+
 import android.content.Context;
 import android.content.Intent;
 import android.content.res.Resources;
 import android.graphics.Color;
+import android.os.Build;
 import android.os.Bundle;
 import android.os.Parcel;
 import android.os.Parcelable;
@@ -16,9 +18,17 @@ import android.view.View.OnClickListener;
 import android.view.View.OnKeyListener;
 import android.view.ViewGroup;
 import android.view.Window;
-import android.widget.*;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.CompoundButton;
 import android.widget.CompoundButton.OnCheckedChangeListener;
+import android.widget.ImageView;
+import android.widget.ListView;
+import android.widget.RadioButton;
+import android.widget.RadioGroup;
+import android.widget.TextView;
 import android.widget.TextView.BufferType;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.Dialogs;
 import com.gpl.rpg.AndorsTrail.R;
@@ -32,24 +42,20 @@ import com.gpl.rpg.AndorsTrail.model.item.Loot;
 import com.gpl.rpg.AndorsTrail.model.quest.Quest;
 import com.gpl.rpg.AndorsTrail.model.quest.QuestLogEntry;
 import com.gpl.rpg.AndorsTrail.model.quest.QuestProgress;
+import com.gpl.rpg.AndorsTrail.resource.tiles.TileCollection;
 import com.gpl.rpg.AndorsTrail.resource.tiles.TileManager;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
 
-import java.util.ArrayList;
-
-public final class ConversationActivity extends Activity implements OnKeyListener
+public final class ConversationActivity
+		extends AndorsTrailBaseActivity
+		implements OnKeyListener
 		, ConversationController.ConversationStatemachine.ConversationStateListener {
-	public static final int ACTIVITYRESULT_ATTACK = Activity.RESULT_FIRST_USER + 1;
-	public static final int ACTIVITYRESULT_REMOVE = Activity.RESULT_FIRST_USER + 2;
-	private static final int playerNameColor = Color.argb(255, 0xbb, 0x22, 0x22);
-	private static final int NPCNameColor = Color.argb(255, 0xbb, 0xbb, 0x22);
-	private static final int playerPhraseColor = 0;
-	private static final int NPCPhraseColor = 0;
-	private static final int rewardColor = Color.argb(255, 0x99, 0x99, 0x55);
 
 	private WorldContext world;
 	private Player player;
-	private ArrayList<ConversationStatement> conversationHistory = new ArrayList<ConversationStatement>();
+	private final ArrayList<ConversationStatement> conversationHistory = new ArrayList<ConversationStatement>();
 	private ConversationController.ConversationStatemachine conversationState;
+	private int numberOfNewMessage = 0;
 
 	private StatementContainerAdapter listAdapter;
 	private Button nextButton;
@@ -59,22 +65,27 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getDialogTheme());
 		super.onCreate(savedInstanceState);
 		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
 		if (!app.isInitialized()) { finish(); return; }
 		this.world = app.getWorld();
 		this.player = world.model.player;
-		this.conversationState = new ConversationController.ConversationStatemachine(world, app.getControllerContext(), getResources(), this);
+		this.conversationState = new ConversationController.ConversationStatemachine(world, app.getControllerContext(), this);
 
 		requestWindowFeature(Window.FEATURE_NO_TITLE);
 
 		setContentView(R.layout.conversation);
 
+		if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+			setFinishOnTouchOutside(false);
+		}
+
 		replyGroup = new RadioGroup(this);
 		replyGroup.setLayoutParams(new ListView.LayoutParams(ListView.LayoutParams.MATCH_PARENT, ListView.LayoutParams.WRAP_CONTENT));
 		statementList = (ListView) findViewById(R.id.conversation_statements);
 		statementList.addFooterView(replyGroup);
-		listAdapter = new StatementContainerAdapter(this, conversationHistory, world.tileManager);
+		listAdapter = new StatementContainerAdapter(this, conversationHistory, world.tileManager, world.model.currentMaps.tiles);
 		statementList.setAdapter(listAdapter);
 
 		nextButton = (Button) findViewById(R.id.conversation_next);
@@ -106,17 +117,22 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 		statementList.setFocusable(false);
 		statementList.setFocusableInTouchMode(false);
 
+		String phraseID;
+		boolean applyScriptEffectsForFirstPhrase;
+		boolean displayLastMessage = true;
 		if (savedInstanceState != null) {
 			conversationState.setCurrentNPC(Dialogs.getMonsterFromBundle(savedInstanceState, world));
 			ArrayList<ConversationStatement> savedConversationHistory = savedInstanceState.getParcelableArrayList("conversationHistory");
 			if (savedConversationHistory != null) conversationHistory.addAll(savedConversationHistory);
-			final String phraseID = savedInstanceState.getString("phraseID");
-			conversationState.proceedToRestoredState(phraseID);
+			phraseID = savedInstanceState.getString("phraseID");
+			applyScriptEffectsForFirstPhrase = false;
+			displayLastMessage = false;
 		} else {
 			conversationState.setCurrentNPC(Dialogs.getMonsterFromIntent(getIntent(), world));
-			final String phraseID = getIntent().getData().getLastPathSegment();
-			conversationState.proceedToPhrase(phraseID);
+			phraseID = getIntent().getData().getLastPathSegment();
+			applyScriptEffectsForFirstPhrase = getIntent().getBooleanExtra("applyScriptEffectsForFirstPhrase", true);
 		}
+		conversationState.proceedToPhrase(getResources(), phraseID, applyScriptEffectsForFirstPhrase, displayLastMessage);
 	}
 
 	@Override
@@ -126,11 +142,16 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 	}
 
 	private int getSelectedReplyIndex() {
+		int j = 0;
 		for (int i = 0; i < replyGroup.getChildCount(); ++i) {
 			final View v = replyGroup.getChildAt(i);
 			if (v == null) continue;
+			if (!(v instanceof RadioButton)) {
+				continue;
+			}
 			final RadioButton rb = (RadioButton) v;
-			if (rb.isChecked()) return i;
+			if (rb.isChecked()) return j;
+			j++;
 		}
 		return -1;
 	}
@@ -139,27 +160,36 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 		int replyCount = replyGroup.getChildCount();
 		if (replyCount <= 0) return;
 		if (i < 0) i = 0;
-		else if (i >= replyCount) i = replyCount - 1;
+		else if (i >= (replyCount-1)) i = replyCount-1;
 
-		View v = replyGroup.getChildAt(i);
-		if (v == null) return;
-		RadioButton rb = (RadioButton) v;
-		rb.setChecked(true);
+		for (int j = 0; j < replyGroup.getChildCount(); ++j) {
+			View v = replyGroup.getChildAt(j);
+			if (v == null) continue;
+			if (!(v instanceof RadioButton)) {
+				continue;
+			}
+			i--;
+			if (i < 0) {
+				RadioButton rb = (RadioButton) v;
+				rb.setChecked(true);
+				break;
+			}
+		}
 	}
 
 	@Override
 	public boolean onKeyDown(int keyCode, KeyEvent event) {
-		if (handleKeypress(keyCode, event)) return true;
+		if (handleKeypress(keyCode)) return true;
 		else return super.onKeyDown(keyCode, event);
 	}
 
 	@Override
 	public boolean onKey(View arg0, int keyCode, KeyEvent event) {
 		if (event.getAction() != KeyEvent.ACTION_DOWN) return false;
-		return handleKeypress(keyCode, event);
+		return handleKeypress(keyCode);
 	}
 
-	public boolean handleKeypress(int keyCode, KeyEvent event) {
+	public boolean handleKeypress(int keyCode) {
 		int selectedReplyIndex = getSelectedReplyIndex();
 		switch (keyCode) {
 		case KeyEvent.KEYCODE_DPAD_UP:
@@ -192,6 +222,9 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 		for (int i = 0; i < replyGroup.getChildCount(); ++i) {
 			final View v = replyGroup.getChildAt(i);
 			if (v == null) continue;
+			if (!(v instanceof RadioButton)) {
+				continue;
+			}
 			final RadioButton rb = (RadioButton) v;
 			if (rb.isChecked()) {
 				return rb;
@@ -200,21 +233,42 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 		return null; // No reply was found. This is probably an error.
 	}
 
+	private void greyAllConversationStatement(){
+		int numberOfMessage = this.conversationHistory.size();
+		while(numberOfNewMessage != 0){
+			ConversationStatement conversation = conversationHistory.get(numberOfMessage - numberOfNewMessage);
+			if(conversation.hasActor()){
+				conversation.textColor = getSpanColor(R.attr.ui_theme_dialogue_dark_color);
+				if(conversation.isPlayerActor){
+					conversation.nameColor = getSpanColor(R.attr.ui_theme_playername_light_color);
+				} else {
+					conversation.nameColor = getSpanColor(R.attr.ui_theme_npcname_dark_color);
+				}
+			} else if (conversation.isReward) {
+				conversation.textColor = getSpanColor(R.attr.ui_theme_reward_light_color);
+			} else {
+				conversation.textColor = getSpanColor(R.attr.ui_theme_dialogue_dark_color);;
+			}
+			numberOfNewMessage--;
+		}
+	}
+
 	private void nextButtonClicked() {
+		greyAllConversationStatement();
 		RadioButton rb = getSelectedReplyButton();
 		replyGroup.removeAllViews();
 		nextButton.setEnabled(false);
 		if (conversationState.hasOnlyOneNextReply()) {
-			conversationState.playerSelectedNextStep();
+			conversationState.playerSelectedNextStep(getResources());
 		} else {
 			if (rb == null) return;
 			Reply r = (Reply) rb.getTag();
-			addConversationStatement(player, rb.getText().toString(), playerPhraseColor);
-			conversationState.playerSelectedReply(r);
+			addConversationStatement(player, rb.getText().toString(), getSpanColor(R.attr.ui_theme_dialogue_light_color), false);
+			conversationState.playerSelectedReply(getResources(), r);
 		}
 	}
 
-	private void addConversationStatement(Actor actor, String text, int textColor) {
+	private void addConversationStatement(Actor actor, String text, int textColor, boolean isReward) {
 		ConversationStatement s = new ConversationStatement();
 		if (actor != null) {
 			s.iconID = actor.iconID;
@@ -223,10 +277,12 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 			s.iconID = ConversationStatement.NO_ICON;
 		}
 		s.text = text;
-		s.nameColor = actor == player ? playerNameColor : NPCNameColor;
+		s.nameColor = actor == player ? getSpanColor(R.attr.ui_theme_playername_light_color) : getSpanColor(R.attr.ui_theme_npcname_light_color);
 		s.textColor = textColor;
 		s.isPlayerActor = actor != null && actor == player;
+		s.isReward = isReward;
 		conversationHistory.add(s);
+		numberOfNewMessage++;
 		statementList.clearFocus();
 		listAdapter.notifyDataSetChanged();
 		statementList.requestLayout();
@@ -248,6 +304,7 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 		public int nameColor;
 		public int textColor;
 		public boolean isPlayerActor;
+		public boolean isReward;
 
 		public boolean hasActor() {
 			return iconID != NO_ICON;
@@ -264,10 +321,12 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 			dest.writeInt(nameColor);
 			dest.writeInt(textColor);
 			dest.writeByte((byte) (isPlayerActor ? 1 : 0));
+			dest.writeByte((byte) (isReward ? 1 : 0));
 		}
 
 		@SuppressWarnings("unused")
 		public static final Parcelable.Creator<ConversationStatement> CREATOR = new Parcelable.Creator<ConversationStatement>() {
+			@Override
 			public ConversationStatement createFromParcel(Parcel in) {
 				ConversationStatement result = new ConversationStatement();
 				result.actorName = in.readString();
@@ -276,9 +335,11 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 				result.nameColor = in.readInt();
 				result.textColor = in.readInt();
 				result.isPlayerActor = in.readByte() == 1;
+				result.isReward = in.readByte() == 1;
 				return result;
 			}
 
+			@Override
 			public ConversationStatement[] newArray(int size) {
 				return new ConversationStatement[size];
 			}
@@ -288,10 +349,12 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 	private static final class StatementContainerAdapter extends ArrayAdapter<ConversationStatement> {
 
 		private final TileManager tileManager;
+		private final TileCollection tiles;
 
-		public StatementContainerAdapter(Context context, ArrayList<ConversationStatement> items, TileManager tileManager) {
+		public StatementContainerAdapter(Context context, ArrayList<ConversationStatement> items, TileManager tileManager, TileCollection tiles) {
 			super(context, 0, items);
 			this.tileManager = tileManager;
+			this.tiles = tiles;
 		}
 
 		@Override
@@ -306,7 +369,7 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 			if (statement.hasActor()) {
 				final Resources res = getContext().getResources();
 				if (statement.isPlayerActor) tileManager.setImageViewTileForPlayer(res, tv, statement.iconID);
-				else tileManager.setImageViewTileForMonster(res, tv, statement.iconID);
+				else tileManager.setImageViewTileForMonster(res, tv, statement.iconID, tiles);
 
 				tv.setText(statement.actorName + ": " + statement.text, BufferType.SPANNABLE);
 				Spannable sp = (Spannable) tv.getText();
@@ -340,15 +403,15 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 	}
 
 	@Override
-	public void onTextPhraseReached(String message, Actor actor) {
-		addConversationStatement(actor, message, NPCPhraseColor);
+	public void onTextPhraseReached(String message, Actor actor, String phraseID) {
+		addConversationStatement(actor, message, getSpanColor(R.attr.ui_theme_dialogue_light_color), false);
 	}
 
 	@Override
-	public void onPlayerReceivedRewards(ConversationController.PhraseRewards phraseRewards) {
-		Loot loot = phraseRewards.loot;
+	public void onScriptEffectsApplied(ConversationController.ScriptEffectResult scriptEffectResult) {
+		Loot loot = scriptEffectResult.loot;
 
-		for (QuestProgress reward : phraseRewards.questProgress) {
+		for (QuestProgress reward : scriptEffectResult.questProgress) {
 			Quest q = world.quests.getQuest(reward.questID);
 			if (!q.showInLog) continue;
 			QuestLogEntry logEntry = q.getQuestLogEntry(reward.progress);
@@ -377,7 +440,7 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 	}
 
 	private void addRewardMessage(String text) {
-		addConversationStatement(null, text, rewardColor);
+		addConversationStatement(null, text, getSpanColor(R.attr.ui_theme_reward_light_color), true);
 	}
 
 	@Override
@@ -395,13 +458,11 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 
 	@Override
 	public void onConversationEndedWithCombat(Monster npc) {
-		ConversationActivity.this.setResult(ACTIVITYRESULT_ATTACK);
 		ConversationActivity.this.finish();
 	}
 
 	@Override
 	public void onConversationEndedWithRemoval(Monster npc) {
-		ConversationActivity.this.setResult(ACTIVITYRESULT_REMOVE);
 		ConversationActivity.this.finish();
 	}
 
@@ -413,6 +474,7 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 	@Override
 	public void onConversationHasReply(Reply r, String message) {
 		RadioGroup.LayoutParams layoutParams = new RadioGroup.LayoutParams(RadioGroup.LayoutParams.MATCH_PARENT, RadioGroup.LayoutParams.WRAP_CONTENT);
+		layoutParams.setMargins(0, getResources().getDimensionPixelOffset(R.dimen.conversation_replyseparator_margintop), 0, getResources().getDimensionPixelOffset(R.dimen.conversation_replyseparator_marginbottom));
 		RadioButton rb = new RadioButton(this);
 		rb.setLayoutParams(layoutParams);
 		rb.setText(message);
@@ -421,6 +483,18 @@ public final class ConversationActivity extends Activity implements OnKeyListene
 		rb.setShadowLayer(1, 1, 1, Color.BLACK);
 		rb.setFocusable(false);
 		rb.setFocusableInTouchMode(false);
+		if (replyGroup.getChildCount() == 0) { //Add a separator before first item
+			ImageView iv = new ImageView(this);
+			iv.setBackgroundResource(ThemeHelper.getThemeResource(this, R.attr.ui_theme_listseparator_drawable));
+			RadioGroup.LayoutParams ivLayoutParams = new RadioGroup.LayoutParams(RadioGroup.LayoutParams.MATCH_PARENT, RadioGroup.LayoutParams.WRAP_CONTENT);
+			ivLayoutParams.setMargins(0, getResources().getDimensionPixelOffset(R.dimen.conversation_replyseparator_margintop), 0, getResources().getDimensionPixelOffset(R.dimen.conversation_replyseparator_marginbottom));
+			iv.setLayoutParams(ivLayoutParams);
+			replyGroup.addView(iv, ivLayoutParams);
+		}
 		replyGroup.addView(rb, layoutParams);
 	}
+	
+	private int getSpanColor(int resId) {
+		return ThemeHelper.getThemeColor(this, resId);
+	}
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/DebugInterface.java

@@ -0,0 +1,341 @@
+package com.gpl.rpg.AndorsTrail.activity;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
+import com.gpl.rpg.AndorsTrail.R;
+import com.gpl.rpg.AndorsTrail.context.ControllerContext;
+import com.gpl.rpg.AndorsTrail.context.WorldContext;
+import com.gpl.rpg.AndorsTrail.controller.Constants;
+import com.gpl.rpg.AndorsTrail.model.item.ItemType;
+import com.gpl.rpg.AndorsTrail.model.map.MapObject;
+import com.gpl.rpg.AndorsTrail.model.map.PredefinedMap;
+import com.gpl.rpg.AndorsTrail.view.MainView;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.RelativeLayout;
+import android.widget.Toast;
+
+public final class DebugInterface {
+	private final ControllerContext controllerContext;
+	private final MainActivity mainActivity;
+	private final Resources res;
+	private final WorldContext world;
+
+	private DebugButton[] buttons;
+	private List<DebugButton> tpButtons  = new ArrayList<DebugButton>();
+	private List<DebugButton> tpButtons2 = new ArrayList<DebugButton>();
+
+	public DebugInterface(ControllerContext controllers, WorldContext world, MainActivity mainActivity) {
+		this.controllerContext = controllers;
+		this.world = world;
+		this.res = mainActivity.getResources();
+		this.mainActivity = mainActivity;
+	}
+
+	public void addDebugButtons() {
+		if (!AndorsTrailApplication.DEVELOPMENT_DEBUGBUTTONS) return;
+
+		List<DebugButton> buttonList = new ArrayList<DebugButton>();
+		buttonList.addAll(Arrays.asList(new DebugButton[] {
+				new DebugButton("dbg", new OnClickListener() {
+					boolean hidden = false;
+					@Override
+					public void onClick(View arg0) {
+						hidden = !hidden;
+						for (int i = 1; i < buttons.length; i++) {
+							buttons[i].b.setVisibility(hidden ? View.GONE : View.VISIBLE);
+						}
+						for (DebugButton b : tpButtons) {
+							b.b.setVisibility(View.GONE);
+						}
+						for (DebugButton b : tpButtons2) {
+							b.b.setVisibility(View.GONE);
+						}
+					}
+				})
+				,new DebugButton("teleport", new OnClickListener() {
+			public void onClick(View arg0) {
+				for (int i = 0; i < buttons.length; i++) {
+					buttons[i].b.setVisibility(View.GONE);
+				}
+				for (DebugButton tpButton : tpButtons) {
+					tpButton.b.setVisibility(View.VISIBLE);
+				}
+			}
+		})
+				,new DebugButton("dmg", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				world.model.player.damagePotential.set(500, 500);
+				world.model.player.attackChance = 500;
+				world.model.player.attackCost = 1;
+				showToast(mainActivity, "DEBUG: damagePotential=500, chance=500%, cost=1", Toast.LENGTH_SHORT);
+			}
+		})
+				/*,new DebugButton("dmg=1", new OnClickListener() {
+                    @Override
+                    public void onClick(View arg0) {
+                        world.model.player.damagePotential.set(1, 1);
+                        showToast(mainActivity, "DEBUG: damagePotential=1", Toast.LENGTH_SHORT);
+                    }
+                })*/
+				,new DebugButton("itm", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				for (ItemType item : world.itemTypes.UNITTEST_getAllItemTypes().values()) {
+					world.model.player.inventory.addItem(item, 10);
+				}
+				world.model.player.inventory.gold += 50000;
+				showToast(mainActivity, "DEBUG: added items", Toast.LENGTH_SHORT);
+			}
+		})
+				,new DebugButton("xp", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.actorStatsController.addExperience(10000);
+				showToast(mainActivity, "DEBUG: given 10000 exp", Toast.LENGTH_SHORT);
+			}
+		})
+				,new DebugButton("rst", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				for(PredefinedMap map : world.maps.getAllMaps()) {
+					map.resetTemporaryData();
+				}
+				showToast(mainActivity, "DEBUG: maps respawned", Toast.LENGTH_SHORT);
+			}
+		})
+				,new DebugButton("hp", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				world.model.player.baseTraits.maxHP = 500;
+				world.model.player.health.max = world.model.player.baseTraits.maxHP;
+				controllerContext.actorStatsController.setActorMaxHealth(world.model.player);
+				world.model.player.conditions.clear();
+				showToast(mainActivity, "DEBUG: hp set to max", Toast.LENGTH_SHORT);
+			}
+		})
+				,new DebugButton("skl", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				world.model.player.availableSkillIncreases += 10;
+				showToast(mainActivity, "DEBUG: 10 skill points", Toast.LENGTH_SHORT);
+			}
+		})
+				,new DebugButton("spd", new OnClickListener() {
+			boolean fast = Constants.MINIMUM_INPUT_INTERVAL == Constants.MINIMUM_INPUT_INTERVAL_FAST;
+			@Override
+			public void onClick(View arg0) {
+				fast = !fast;
+				if (fast) {
+					Constants.MINIMUM_INPUT_INTERVAL = Constants.MINIMUM_INPUT_INTERVAL_FAST;
+				} else {
+					Constants.MINIMUM_INPUT_INTERVAL = Constants.MINIMUM_INPUT_INTERVAL_STD;
+				}
+				MainView.SCROLL_DURATION = Constants.MINIMUM_INPUT_INTERVAL;
+				AndorsTrailApplication.getApplicationFromActivity(mainActivity).getControllerContext().movementController.resetMovementHandler();
+			}
+		})
+				,new DebugButton("map", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				showToast(mainActivity, "DEBUG: map=" + world.model.currentMaps.map.name , Toast.LENGTH_SHORT);
+			}
+		})
+		}));
+
+		tpButtons.addAll(Arrays.asList(new DebugButton[] {
+				new DebugButton("teleport", new OnClickListener() {
+					@Override
+					public void onClick(View arg0) {
+						for (DebugButton tpButton : tpButtons2) {
+							tpButton.b.setVisibility(View.VISIBLE);
+						}
+						for (DebugButton tpButton : tpButtons) {
+							tpButton.b.setVisibility(View.GONE);
+						}
+					}
+				})
+				,new DebugButton("cg", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "crossglen", "hall", 0, 0);
+			}
+		})
+				,new DebugButton("vg", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "vilegard_s", "tavern", 0, 0);
+			}
+		})
+				,new DebugButton("cr", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "houseatcrossroads4", "down", 0, 0);
+			}
+		})
+				,new DebugButton("lf", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "loneford9", "south", 0, 0);
+			}
+		})
+				,new DebugButton("fh", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "fallhaven_ne", "clothes", 0, 0);
+			}
+		})
+				,new DebugButton("prm", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "blackwater_mountain29", "south", 0, 0);
+			}
+		})
+				,new DebugButton("bwm", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "blackwater_mountain43", "south", 0, 0);
+			}
+		})
+				,new DebugButton("rmg", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "remgard0", "east", 0, 0);
+			}
+		})
+				,new DebugButton("chr", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "waytolostmine2", "minerhouse4", 0, 0);
+			}
+		})
+				,new DebugButton("ldr", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "lodarhouse0", "lodarhouse", 0, 0);
+			}
+		})
+				,new DebugButton("sf", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "wild20", "south2", 0, 0);
+			}
+		})
+				,new DebugButton("gm", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "guynmart_wood_1", "farmhouse", 0, 0);
+			}
+		})
+		}));
+		buttonList.addAll(tpButtons);
+
+		tpButtons2.addAll(Arrays.asList(new DebugButton[] {
+				new DebugButton("teleport", new OnClickListener() {
+					@Override
+					public void onClick(View arg0) {
+						for (int i = 0; i < buttons.length; i++) {
+							buttons[i].b.setVisibility(View.VISIBLE);
+						}
+						for (DebugButton tpButton : tpButtons) {
+							tpButton.b.setVisibility(View.GONE);
+						}
+						for (DebugButton tpButton : tpButtons2) {
+							tpButton.b.setVisibility(View.GONE);
+						}
+					}
+				})
+				,new DebugButton("brv", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "brimhaven4", "south2", 0, 0);
+			}
+		})
+				,new DebugButton("aru", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "mountainlake5", "north", 0, 0);
+			}
+		})
+				,new DebugButton("ws", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "woodsettlement0", "east", 0, 0);
+			}
+		})
+				,new DebugButton("sul", new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				controllerContext.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, "sullengard2", "south", 0, 0);
+			}
+		})
+		}));
+		buttonList.addAll(tpButtons2);
+
+		buttons = buttonList.toArray(new DebugButton[buttonList.size()]);
+		addDebugButtons(buttons);
+
+		for (DebugButton b : tpButtons) {
+			b.b.setVisibility(View.GONE);
+		}
+		for (DebugButton b : tpButtons2) {
+			b.b.setVisibility(View.GONE);
+		}
+	}
+
+	private void showToast(Context context, String msg, int duration) {
+		Toast.makeText(context, msg, duration).show();
+	}
+
+	private static class DebugButton {
+		public final String text;
+		public final OnClickListener listener;
+		public Button b = null;
+		public DebugButton(String text, OnClickListener listener) {
+			this.text = text;
+			this.listener = listener;
+		}
+		public void makeButton(Context c, int id) {
+			b = new Button(c);
+			b.setText(text);
+			b.setTextSize(10);//res.getDimension(R.dimen.actionbar_text));
+			b.setId(id);
+			b.setOnClickListener(listener);
+		}
+	}
+
+	private void addDebugButton(DebugButton button, int id, RelativeLayout layout) {
+		if (!AndorsTrailApplication.DEVELOPMENT_DEBUGBUTTONS) return;
+
+		RelativeLayout.LayoutParams lp = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT, res.getDimensionPixelSize(R.dimen.smalltext_buttonheight));
+		if (id == 1)
+			lp.addRule(RelativeLayout.ALIGN_PARENT_LEFT);
+		else
+			lp.addRule(RelativeLayout.RIGHT_OF, id - 1);
+		lp.addRule(RelativeLayout.ABOVE, R.id.main_statusview);
+		button.makeButton(mainActivity, id);
+		button.b.setLayoutParams(lp);
+		layout.addView(button.b);
+	}
+
+	private void addDebugButtons(DebugButton[] buttons) {
+		if (!AndorsTrailApplication.DEVELOPMENT_DEBUGBUTTONS) return;
+
+		if (buttons == null || buttons.length <= 0) return;
+		RelativeLayout layout = (RelativeLayout) mainActivity.findViewById(R.id.main_container);
+
+		int id = 1;
+		for (DebugButton b : buttons) {
+			addDebugButton(b, id, layout);
+			++id;
+		}
+	}
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/DisplayWorldMapActivity.java

@@ -0,0 +1,168 @@
+package com.gpl.rpg.AndorsTrail.activity;
+
+import java.io.File;
+
+import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
+import com.gpl.rpg.AndorsTrail.R;
+import com.gpl.rpg.AndorsTrail.context.WorldContext;
+import com.gpl.rpg.AndorsTrail.controller.WorldMapController;
+import com.gpl.rpg.AndorsTrail.model.map.PredefinedMap;
+import com.gpl.rpg.AndorsTrail.model.map.WorldMapSegment;
+import com.gpl.rpg.AndorsTrail.model.map.WorldMapSegment.WorldMapSegmentMap;
+import com.gpl.rpg.AndorsTrail.util.AndroidStorage;
+import com.gpl.rpg.AndorsTrail.util.Coord;
+import com.gpl.rpg.AndorsTrail.util.L;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
+
+import android.annotation.SuppressLint;
+import android.os.Bundle;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import android.widget.Button;
+import android.widget.Toast;
+
+public final class DisplayWorldMapActivity extends AndorsTrailBaseActivity {
+	private WorldContext world;
+
+	private WebView displayworldmap_webview;
+	private String worldMapSegmentName;
+
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getBaseTheme());
+		super.onCreate(savedInstanceState);
+
+		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
+		if (!app.isInitialized()) { finish(); return; }
+		this.world = app.getWorld();
+
+		app.setWindowParameters(this);
+
+		setContentView(R.layout.displayworldmap);
+
+		displayworldmap_webview = (WebView) findViewById(R.id.displayworldmap_webview);
+		displayworldmap_webview.setBackgroundColor(ThemeHelper.getThemeColor(this, R.attr.ui_theme_displayworldmap_bg_color));
+		displayworldmap_webview.getSettings().setBuiltInZoomControls(true);
+		displayworldmap_webview.getSettings().setUseWideViewPort(true);
+		displayworldmap_webview.setVerticalScrollBarEnabled(true);
+		displayworldmap_webview.setHorizontalScrollBarEnabled(true);
+		displayworldmap_webview.getSettings().setAllowFileAccess(true);
+		enableJavascript();
+
+		Button b = (Button) findViewById(R.id.displayworldmap_close);
+		b.setOnClickListener(new OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				DisplayWorldMapActivity.this.finish();
+			}
+		});
+
+		b = (Button) findViewById(R.id.displayworldmap_recenter);
+		b.setOnClickListener(new OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				recenter();
+			}
+		});
+
+		worldMapSegmentName = getIntent().getStringExtra("worldMapSegmentName");
+	}
+
+	@SuppressLint("SetJavaScriptEnabled")
+	public void enableJavascript() {
+		displayworldmap_webview.getSettings().setJavaScriptEnabled(true);
+	}
+
+	@Override
+	public void onResume() {
+		super.onResume();
+		update();
+	}
+
+	WorldMapSegmentMap map;
+	Coord offsetWorldmapTo;
+	@SuppressLint("NewApi")
+	private void update() {
+		File worldmap = WorldMapController.getCombinedWorldMapFile(this, worldMapSegmentName);
+
+		if (!worldmap.exists()) {
+			Toast.makeText(this, getResources().getString(R.string.menu_button_worldmap_failed), Toast.LENGTH_LONG).show();
+			this.finish();
+		}
+
+		WorldMapSegment segment = world.maps.worldMapSegments.get(worldMapSegmentName);
+		map = segment.maps.get(world.model.currentMaps.map.name);
+		if (map == null) {
+			this.finish();
+			return;
+		}
+		
+		offsetWorldmapTo = new Coord(999999, 999999);
+		for (WorldMapSegmentMap map : segment.maps.values()) {
+			PredefinedMap predefinedMap = world.maps.findPredefinedMap(map.mapName);
+			if (predefinedMap == null) continue;
+			if (!predefinedMap.visited) continue;
+			if (!WorldMapController.fileForMapExists(this, predefinedMap)) continue;
+
+			offsetWorldmapTo.x = Math.min(offsetWorldmapTo.x, map.worldPosition.x);
+			offsetWorldmapTo.y = Math.min(offsetWorldmapTo.y, map.worldPosition.y);
+		}
+
+		String url = AndroidStorage.getUrlForFile(this, worldmap) + '?'
+				+ (world.model.player.position.x + map.worldPosition.x) * WorldMapController.WORLDMAP_DISPLAY_TILESIZE
+				+ ','
+				+ (world.model.player.position.y + map.worldPosition.y-1) * WorldMapController.WORLDMAP_DISPLAY_TILESIZE;
+		L.log("Showing " + url);
+		displayworldmap_webview.loadUrl(url);
+		displayworldmap_webview.setBackgroundColor(ThemeHelper.getThemeColor(this, R.attr.ui_theme_displayworldmap_bg_color));
+		displayworldmap_webview.setWebViewClient(new WebViewClient() {
+			@SuppressLint("NewApi")
+			@Override
+			public void onPageFinished(WebView view, String url)
+			{
+				recenter();
+			}
+		});
+	}
+	
+	private void recenter() {
+		displayworldmap_webview.postDelayed(new Runnable() {
+			@Override
+			public void run() {
+				if (map != null) {
+					//Local map to global worldmap
+					int x = world.model.player.position.x + map.worldPosition.x - offsetWorldmapTo.x;
+					//Tile coord to pixel coord
+					x *= WorldMapController.WORLDMAP_DISPLAY_TILESIZE;
+					x += WorldMapController.WORLDMAP_DISPLAY_TILESIZE/2;
+					//Zoom level
+					x = (int)(x * displayworldmap_webview.getScale());
+					//Center
+					x -= displayworldmap_webview.getWidth() / 2;
+					
+					//Local map to global worldmap
+					int y = world.model.player.position.y + map.worldPosition.y  - offsetWorldmapTo.y;
+					//Tile coord to pixel coord
+					y *= WorldMapController.WORLDMAP_DISPLAY_TILESIZE;
+					y += WorldMapController.WORLDMAP_DISPLAY_TILESIZE/2;
+					//Zoom level
+					y = (int)(y * displayworldmap_webview.getScale());
+					//Center
+					y -= displayworldmap_webview.getHeight() / 2;
+					
+					displayworldmap_webview.scrollTo(x, y);
+				}
+			}
+		}, 100);
+	}
+	
+	@Override
+	public void finish() {
+	    ViewGroup view = (ViewGroup) getWindow().getDecorView();
+	    view.removeAllViews();
+	    super.finish();
+	}
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/HeroinfoActivity.java

@@ -0,0 +1,97 @@
+package com.gpl.rpg.AndorsTrail.activity;
+
+import android.content.res.Resources;
+import android.os.Bundle;
+import android.support.v4.app.FragmentTabHost;
+import android.view.LayoutInflater;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
+import com.gpl.rpg.AndorsTrail.R;
+import com.gpl.rpg.AndorsTrail.activity.fragment.HeroinfoActivity_Inventory;
+import com.gpl.rpg.AndorsTrail.activity.fragment.HeroinfoActivity_Quests;
+import com.gpl.rpg.AndorsTrail.activity.fragment.HeroinfoActivity_Skills;
+import com.gpl.rpg.AndorsTrail.activity.fragment.HeroinfoActivity_Stats;
+import com.gpl.rpg.AndorsTrail.context.WorldContext;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
+
+public final class HeroinfoActivity extends AndorsTrailBaseFragmentActivity {
+	private WorldContext world;
+
+	private FragmentTabHost tabHost;
+
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getBaseTheme());
+		super.onCreate(savedInstanceState);
+		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
+		if (!app.isInitialized()) { finish(); return; }
+		this.world = app.getWorld();
+
+		app.setWindowParameters(this);
+
+		setContentView(R.layout.tabbedlayout);
+
+		Resources res = getResources();
+
+		tabHost = (FragmentTabHost) findViewById(android.R.id.tabhost);
+		tabHost.setup(this, getSupportFragmentManager(), R.id.realtabcontent);
+
+		LayoutInflater inflater = getLayoutInflater();
+		
+		ViewGroup v;
+		
+		v = (ViewGroup) inflater.inflate(R.layout.tabindicator, null);
+		((TextView)v.findViewById(R.id.tabindicator_text)).setText(res.getString(R.string.heroinfo_char));
+		((ImageView)v.findViewById(R.id.tabindicator_icon)).setImageDrawable(res.getDrawable(R.drawable.char_hero));
+		tabHost.addTab(tabHost.newTabSpec("char")
+				.setIndicator(v)
+				,HeroinfoActivity_Stats.class, null);
+		
+		v = (ViewGroup) inflater.inflate(R.layout.tabindicator, null);
+		((TextView)v.findViewById(R.id.tabindicator_text)).setText(res.getString(R.string.heroinfo_quests));
+		((ImageView)v.findViewById(R.id.tabindicator_icon)).setImageDrawable(res.getDrawable(R.drawable.ui_icon_quest));
+		tabHost.addTab(tabHost.newTabSpec("quests")
+				.setIndicator(v)
+				,HeroinfoActivity_Quests.class, null);
+		
+		v = (ViewGroup) inflater.inflate(R.layout.tabindicator, null);
+		((TextView)v.findViewById(R.id.tabindicator_text)).setText(res.getString(R.string.heroinfo_skill));
+		((ImageView)v.findViewById(R.id.tabindicator_icon)).setImageDrawable(res.getDrawable(R.drawable.ui_icon_skill));
+		tabHost.addTab(tabHost.newTabSpec("skills")
+				.setIndicator(v)
+				,HeroinfoActivity_Skills.class, null);
+		
+		v = (ViewGroup) inflater.inflate(R.layout.tabindicator, null);
+		((TextView)v.findViewById(R.id.tabindicator_text)).setText(res.getString(R.string.heroinfo_inv));
+		((ImageView)v.findViewById(R.id.tabindicator_icon)).setImageDrawable(res.getDrawable(R.drawable.ui_icon_equipment));
+		tabHost.addTab(tabHost.newTabSpec("inv")
+				.setIndicator(v)
+				,HeroinfoActivity_Inventory.class, null);
+		String t = world.model.uiSelections.selectedTabHeroInfo;
+		if (t != null && t.length() > 0) {
+			tabHost.setCurrentTabByTag(t);
+		}
+		updateIconForPlayer();
+
+	}
+	
+	@Override
+	protected void onResume() {
+		super.onResume();
+		updateIconForPlayer();
+	}
+	
+	private void updateIconForPlayer() {
+		ImageView iv = (ImageView) tabHost.getTabWidget().getChildTabViewAt(0).findViewById(R.id.tabindicator_icon);
+		world.tileManager.setImageViewTileForPlayer(getResources(), iv, world.model.player.iconID);
+	}
+
+	@Override
+	protected void onPause() {
+		super.onPause();
+		world.model.uiSelections.selectedTabHeroInfo = tabHost.getCurrentTabTag();
+	}
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/ItemInfoActivity.java

@@ -1,5 +1,7 @@
 package com.gpl.rpg.AndorsTrail.activity;
 
+import java.util.Collections;
+
 import android.app.Activity;
 import android.content.Intent;
 import android.content.res.Resources;
@@ -8,22 +10,25 @@ import android.view.View;
 import android.view.View.OnClickListener;
 import android.widget.Button;
 import android.widget.TextView;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.model.item.ItemType;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
 import com.gpl.rpg.AndorsTrail.view.ItemEffectsView;
 
-import java.util.Collections;
-
-public final class ItemInfoActivity extends Activity {
+public final class ItemInfoActivity extends AndorsTrailBaseActivity {
 
 	public static enum ItemInfoAction {
 		none, use, equip, unequip, buy, sell
 	}
+	
+	public static final int RESULT_MORE_ACTIONS = Activity.RESULT_FIRST_USER; 
 
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getDialogTheme());
 		super.onCreate(savedInstanceState);
 		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
 		if (!app.isInitialized()) { finish(); return; }
@@ -38,6 +43,7 @@ public final class ItemInfoActivity extends Activity {
 
 		final String buttonText = params.getString("buttonText");
 		boolean buttonEnabled = params.getBoolean("buttonEnabled");
+		boolean moreButtonEnabled = params.getBoolean("moreActions");
 
 		setContentView(R.layout.iteminfo);
 
@@ -62,6 +68,8 @@ public final class ItemInfoActivity extends Activity {
 				itemType.effects_use == null ? null : Collections.singletonList(itemType.effects_use),
 				itemType.effects_hit == null ? null : Collections.singletonList(itemType.effects_hit),
 				itemType.effects_kill == null ? null : Collections.singletonList(itemType.effects_kill),
+				itemType.effects_hitReceived == null ? null : Collections.singletonList(itemType.effects_hitReceived),
+				null,
 				itemType.isWeapon()
 			);
 
@@ -73,6 +81,21 @@ public final class ItemInfoActivity extends Activity {
 				ItemInfoActivity.this.finish();
 			}
 		});
+		
+		b = (Button) findViewById(R.id.iteminfo_more);
+		if (!moreButtonEnabled) {
+			b.setVisibility(View.GONE);
+		} else {
+			b.setOnClickListener(new OnClickListener() {
+				@Override
+				public void onClick(View arg0) {
+					Intent result = new Intent();
+					result.putExtras(intent);
+					setResult(RESULT_MORE_ACTIONS, intent);
+					ItemInfoActivity.this.finish();
+				}
+			});
+		}
 
 		b = (Button) findViewById(R.id.iteminfo_action);
 		if (buttonText != null && buttonText.length() > 0) {

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/LevelUpActivity.java

@@ -1,6 +1,5 @@
 package com.gpl.rpg.AndorsTrail.activity;
 
-import android.app.Activity;
 import android.content.res.Resources;
 import android.os.Bundle;
 import android.view.View;
@@ -8,6 +7,7 @@ import android.view.View.OnClickListener;
 import android.view.Window;
 import android.widget.Button;
 import android.widget.TextView;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.context.ControllerContext;
@@ -15,8 +15,9 @@ import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.controller.ActorStatsController;
 import com.gpl.rpg.AndorsTrail.controller.Constants;
 import com.gpl.rpg.AndorsTrail.model.actor.Player;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
 
-public final class LevelUpActivity extends Activity {
+public final class LevelUpActivity extends AndorsTrailBaseActivity {
 	private WorldContext world;
 	private ControllerContext controllers;
 	private Player player;
@@ -26,6 +27,7 @@ public final class LevelUpActivity extends Activity {
 
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getDialogTheme());
 		super.onCreate(savedInstanceState);
 		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
 		if (!app.isInitialized()) { finish(); return; }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/LoadSaveActivity.java

@@ -0,0 +1,766 @@
+package com.gpl.rpg.AndorsTrail.activity;
+
+import java.io.DataInputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+import android.Manifest;
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.ClipData;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.support.annotation.RequiresApi;
+import android.support.v4.provider.DocumentFile;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.view.ViewGroup.LayoutParams;
+import android.widget.Button;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
+import com.gpl.rpg.AndorsTrail.AndorsTrailPreferences;
+import com.gpl.rpg.AndorsTrail.R;
+import com.gpl.rpg.AndorsTrail.controller.Constants;
+import com.gpl.rpg.AndorsTrail.model.ModelContainer;
+import com.gpl.rpg.AndorsTrail.resource.tiles.TileManager;
+import com.gpl.rpg.AndorsTrail.savegames.Savegames;
+import com.gpl.rpg.AndorsTrail.savegames.Savegames.FileHeader;
+import com.gpl.rpg.AndorsTrail.util.AndroidStorage;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory.CustomDialog;
+
+public final class LoadSaveActivity extends AndorsTrailBaseActivity implements OnClickListener {
+    private boolean isLoading = true;
+    //region special slot numbers
+    private static final int SLOT_NUMBER_CREATE_NEW_SLOT = -1;
+    public static final int SLOT_NUMBER_EXPORT_SAVEGAMES = -2;
+    public static final int SLOT_NUMBER_IMPORT_SAVEGAMES = -3;
+    public static final int SLOT_NUMBER_IMPORT_WORLDMAP = -4;
+    private static final int SLOT_NUMBER_FIRST_SLOT = 1;
+    //endregion
+    private ModelContainer model;
+    private TileManager tileManager;
+    private AndorsTrailPreferences preferences;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        setTheme(ThemeHelper.getDialogTheme());
+        super.onCreate(savedInstanceState);
+
+        final AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
+        app.setWindowParameters(this);
+        this.model = app.getWorld().model;
+        this.preferences = app.getPreferences();
+        this.tileManager = app.getWorld().tileManager;
+
+        String loadsave = getIntent().getData().getLastPathSegment();
+        isLoading = (loadsave.equalsIgnoreCase("load"));
+
+        setContentView(R.layout.loadsave);
+
+        TextView tv = (TextView) findViewById(R.id.loadsave_title);
+        if (isLoading) {
+            tv.setCompoundDrawablesWithIntrinsicBounds(android.R.drawable.ic_menu_search, 0, 0, 0);
+            tv.setText(R.string.loadsave_title_load);
+        } else {
+            tv.setCompoundDrawablesWithIntrinsicBounds(android.R.drawable.ic_menu_save, 0, 0, 0);
+            tv.setText(R.string.loadsave_title_save);
+        }
+
+        ViewGroup slotList = (ViewGroup) findViewById(R.id.loadsave_slot_list);
+        Button slotTemplateButton = (Button) findViewById(R.id.loadsave_slot_n);
+        LayoutParams params = slotTemplateButton.getLayoutParams();
+        slotList.removeView(slotTemplateButton);
+
+        ViewGroup newSlotContainer = (ViewGroup) findViewById(R.id.loadsave_save_to_new_slot_container);
+        Button createNewSlot = (Button) findViewById(R.id.loadsave_save_to_new_slot);
+
+        Button exportSaves = (Button) findViewById(R.id.loadsave_export_save);
+        Button importSaves = (Button) findViewById(R.id.loadsave_import_save);
+        Button importWorldmap = (Button) findViewById(R.id.loadsave_import_worldmap);
+
+        exportSaves.setTag(SLOT_NUMBER_EXPORT_SAVEGAMES);
+        importSaves.setTag(SLOT_NUMBER_IMPORT_SAVEGAMES);
+        importWorldmap.setTag(SLOT_NUMBER_IMPORT_WORLDMAP);
+
+        ViewGroup exportImportContainer = (ViewGroup) findViewById(R.id.loadsave_export_import_save_container);
+
+
+        addSavegameSlotButtons(slotList, params, Savegames.getUsedSavegameSlots(this));
+
+        checkAndRequestPermissions();
+
+        if (!isLoading) {
+            createNewSlot.setTag(SLOT_NUMBER_CREATE_NEW_SLOT);
+            createNewSlot.setOnClickListener(this);
+            newSlotContainer.setVisibility(View.VISIBLE);
+            exportImportContainer.setVisibility(View.GONE);
+        } else {
+            newSlotContainer.setVisibility(View.GONE);
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                exportSaves.setOnClickListener(this);
+                importSaves.setOnClickListener(this);
+                importWorldmap.setOnClickListener(this);
+                exportImportContainer.setVisibility(View.VISIBLE);
+
+                boolean hasSavegames = !Savegames.getUsedSavegameSlots(this).isEmpty();
+                exportSaves.setEnabled(hasSavegames);
+            }
+            else{
+                exportImportContainer.setVisibility(View.GONE);
+            }
+        }
+    }
+
+    private static final int READ_EXTERNAL_STORAGE_REQUEST = 1;
+    private static final int WRITE_EXTERNAL_STORAGE_REQUEST = 2;
+
+    private void checkAndRequestPermissions() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && Build.VERSION.SDK_INT <= Build.VERSION_CODES.Q) {
+            if (getApplicationContext().checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
+                this.requestPermissions(new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, READ_EXTERNAL_STORAGE_REQUEST);
+            }
+            if (getApplicationContext().checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
+                this.requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, WRITE_EXTERNAL_STORAGE_REQUEST);
+            }
+        }
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+        if (grantResults.length > 0 && grantResults[0] != PackageManager.PERMISSION_GRANTED) {
+            Toast.makeText(this, R.string.storage_permissions_mandatory, Toast.LENGTH_LONG).show();
+            ((AndorsTrailApplication) getApplication()).discardWorld();
+            finish();
+        }
+    }
+
+    private void addSavegameSlotButtons(ViewGroup parent, LayoutParams params, List<Integer> usedSavegameSlots) {
+        int unused = 1;
+        for (int slot : usedSavegameSlots) {
+            final FileHeader header = Savegames.quickload(this, slot);
+            if (header == null) continue;
+
+            while (unused < slot) {
+                Button b = new Button(this);
+                b.setLayoutParams(params);
+                b.setTag(unused);
+                b.setOnClickListener(this);
+                b.setText(getString(R.string.loadsave_empty_slot, unused));
+                tileManager.setImageViewTileForPlayer(getResources(), b, header.iconID);
+                parent.addView(b, params);
+                unused++;
+            }
+            unused++;
+
+            Button b = new Button(this);
+            b.setLayoutParams(params);
+            b.setTag(slot);
+            b.setOnClickListener(this);
+            b.setText(slot + ". " + header.describe());
+            tileManager.setImageViewTileForPlayer(getResources(), b, header.iconID);
+            parent.addView(b, params);
+        }
+    }
+
+    private void cancelLoadSaveActivity(int slot){
+        completeLoadSaveActivity(slot, false);
+    }
+
+    private void completeLoadSaveActivity(int slot) {
+        completeLoadSaveActivity(slot, true);
+    }
+    private void completeLoadSaveActivity(int slot, boolean success) {
+        Intent i = new Intent();
+        if (slot == SLOT_NUMBER_CREATE_NEW_SLOT) {
+            slot = getFirstFreeSlot();
+        } else if (slot == SLOT_NUMBER_EXPORT_SAVEGAMES
+                || slot == SLOT_NUMBER_IMPORT_SAVEGAMES
+                || slot == SLOT_NUMBER_IMPORT_WORLDMAP) {
+            i.putExtra("import_export", true);
+
+            if(slot == SLOT_NUMBER_IMPORT_WORLDMAP){
+                i.putExtra("import_worldmap", true);
+            }
+            if(slot == SLOT_NUMBER_IMPORT_SAVEGAMES){
+                i.putExtra("import_savegames", true);
+            }
+            if(slot == SLOT_NUMBER_EXPORT_SAVEGAMES){
+                i.putExtra("export", true);
+            }
+
+        } else if (slot < SLOT_NUMBER_FIRST_SLOT)
+            slot = SLOT_NUMBER_FIRST_SLOT;
+
+        i.putExtra("slot", slot);
+        if(success) setResult(Activity.RESULT_OK, i);
+        else setResult(Activity.RESULT_CANCELED, i);
+        LoadSaveActivity.this.finish();
+    }
+
+    private int getFirstFreeSlot() {
+        int slot;
+        List<Integer> usedSlots = Savegames.getUsedSavegameSlots(this);
+        if (usedSlots.isEmpty())
+            slot = SLOT_NUMBER_FIRST_SLOT;
+        else slot = Collections.max(usedSlots) + 1;
+        return slot;
+    }
+
+    private String getConfirmOverwriteQuestion(int slot) {
+        if (isLoading)
+            return null;
+
+        return getConfirmOverwriteQuestionIgnoringLoading(slot);
+    }
+
+    private String getConfirmOverwriteQuestionIgnoringLoading(int slot) {
+        if (slot == SLOT_NUMBER_CREATE_NEW_SLOT)
+            return null;//creating a new savegame
+
+        if (!Savegames.getSlotFile(slot, this).exists())
+            return null;//nothing in slot to overwrite
+
+        if (preferences.displayOverwriteSavegame == AndorsTrailPreferences.CONFIRM_OVERWRITE_SAVEGAME_ALWAYS) {
+            return getString(R.string.loadsave_save_overwrite_confirmation_all);
+        }
+        if (preferences.displayOverwriteSavegame == AndorsTrailPreferences.CONFIRM_OVERWRITE_SAVEGAME_NEVER) {
+            return null;
+        }
+
+        final String currentPlayerName = model.player.getName();
+        final FileHeader header = Savegames.quickload(this, slot);
+        if (header == null) return null;
+
+        final String savedPlayerName = header.playerName;
+        if (currentPlayerName.equals(savedPlayerName)) return null; //if the names match
+
+        return getString(R.string.loadsave_save_overwrite_confirmation, savedPlayerName, currentPlayerName);
+    }
+
+    @Override
+    public void onClick(View view) {
+        final int slot = (Integer) view.getTag();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            switch (slot) {
+                case SLOT_NUMBER_IMPORT_WORLDMAP:
+                    clickImportWorldmap();
+                    return;
+                case SLOT_NUMBER_IMPORT_SAVEGAMES:
+                    clickImportSaveGames();
+                    return;
+                case SLOT_NUMBER_EXPORT_SAVEGAMES:
+                    clickExportSaveGames();
+                    return;
+            }
+        }
+        if (!isLoading
+                && slot != SLOT_NUMBER_CREATE_NEW_SLOT
+                && AndorsTrailApplication.CURRENT_VERSION == AndorsTrailApplication.DEVELOPMENT_INCOMPATIBLE_SAVEGAME_VERSION) {
+            if (!isOverwriteTargetInIncompatibleVersion(slot)) {
+                saveOrOverwriteSavegame(slot);
+            }
+        } else if (isLoading) {
+            loadSaveGame(slot);
+        } else {
+            saveOrOverwriteSavegame(slot);
+        }
+    }
+
+    private void saveOrOverwriteSavegame(int slot) {
+        final String message = getConfirmOverwriteQuestion(slot);
+        if (message != null) {
+            showConfirmoverwriteQuestion(slot, message);
+        } else {
+            completeLoadSaveActivity(slot);
+        }
+    }
+
+    private boolean isOverwriteTargetInIncompatibleVersion(int slot) {
+        final FileHeader header = Savegames.quickload(this, slot);
+        if (header != null && header.fileversion != AndorsTrailApplication.DEVELOPMENT_INCOMPATIBLE_SAVEGAME_VERSION) {
+            final CustomDialog d = CustomDialogFactory.createErrorDialog(this, "Overwriting not allowed", "You are currently using a development version of Andor's trail. Overwriting a regular savegame is not allowed in development mode.");
+            CustomDialogFactory.show(d);
+            return true;
+        }
+        return false;
+    }
+
+    //region Imports/Exports
+
+    @RequiresApi(api = Build.VERSION_CODES.P)
+    private void exportSaveGames(Intent data) {
+        Uri uri = data.getData();
+
+        Context context = getApplicationContext();
+        ContentResolver resolver = AndorsTrailApplication.getApplicationFromActivity(this).getContentResolver();
+
+        File storageDir = AndroidStorage.getStorageDirectory(context, Constants.FILENAME_SAVEGAME_DIRECTORY);
+        DocumentFile source = DocumentFile.fromFile(storageDir);
+        DocumentFile target = DocumentFile.fromTreeUri(context, uri);
+        if (target == null) {
+            return;
+        }
+
+        DocumentFile[] files = source.listFiles();
+
+        boolean hasExistingFiles = false;
+        for (DocumentFile file :
+                files) {
+            String fileName = file.getName();
+            if (fileName == null)
+                continue;
+
+            DocumentFile existingFile = target.findFile(fileName);
+            if (existingFile != null) {
+                hasExistingFiles = true;
+                break;
+            }
+        }
+
+        if (hasExistingFiles) {
+            showConfirmOverwriteByExportQuestion(resolver, target, files);
+        } else {
+            exportSaveGamesFolderContentToFolder(resolver, target, files);
+        }
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.P)
+    private void exportSaveGamesFolderContentToFolder(ContentResolver resolver, DocumentFile target, DocumentFile[] files) {
+        DocumentFile[] sourceFiles = new DocumentFile[files.length];
+
+        DocumentFile[] worldmapFiles = null;
+
+        for (int i = 0; i < files.length; i++) {
+            DocumentFile file = files[i];
+            if (file.isFile()) {
+                sourceFiles[i] = file;
+            } else if (file.isDirectory() && Objects.equals(file.getName(), Constants.FILENAME_WORLDMAP_DIRECTORY)) {
+                worldmapFiles = file.listFiles();
+            }
+        }
+        Context context =this;
+        DocumentFile[] finalWorldmapFiles = worldmapFiles;
+        AndroidStorage.copyDocumentFilesToDirAsync(sourceFiles,
+                context,
+                target,
+                (sucess) -> {
+                    if (sucess) {
+                        DocumentFile worldmapFolder = target.createDirectory(Constants.FILENAME_WORLDMAP_DIRECTORY);
+                        AndroidStorage.copyDocumentFilesToDirAsync(finalWorldmapFiles,
+                                context,
+                                worldmapFolder,
+                                (sucessWorldmap) -> completeLoadSaveActivity(SLOT_NUMBER_EXPORT_SAVEGAMES, sucessWorldmap));
+                    } else {
+                        completeLoadSaveActivity(SLOT_NUMBER_EXPORT_SAVEGAMES, false);
+                    }
+                });
+
+    }
+
+
+    @RequiresApi(api = Build.VERSION_CODES.N)
+    private void importSaveGames(Intent data) {
+        Uri uri = data.getData();
+        ClipData uris = data.getClipData();
+
+        if (uri == null && uris == null) {
+            //no file was selected
+            return;
+        }
+
+        Context context = getApplicationContext();
+        ContentResolver resolver = context.getContentResolver();
+
+        File storageDir = AndroidStorage.getStorageDirectory(context, Constants.FILENAME_SAVEGAME_DIRECTORY);
+        DocumentFile appSavegameFolder = DocumentFile.fromFile(storageDir);
+
+        List<Uri> uriList = new ArrayList<>();
+        if (uri != null) {
+            uriList.add(uri);
+        } else {
+            for (int i = 0; i < uris.getItemCount(); i++)
+                uriList.add(uris.getItemAt(i).getUri());
+        }
+        importSaveGamesFromUris(context, resolver, appSavegameFolder, uriList);
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.N)
+    private void importSaveGamesFromUris(Context context, ContentResolver resolver, DocumentFile appSavegameFolder, List<Uri> uriList) {
+        int count = uriList.size();
+
+        ArrayList<DocumentFile> alreadyExistingFiles = new ArrayList<>();
+        ArrayList<DocumentFile> newFiles = new ArrayList<>();
+
+        for (int i = 0; i < count; i++) {
+            Uri item = uriList.get(i);
+            DocumentFile itemFile = DocumentFile.fromSingleUri(context, item);
+            boolean fileAlreadyExists = getExistsSavegameInOwnFiles(itemFile, appSavegameFolder);
+            if (fileAlreadyExists)
+                alreadyExistingFiles.add(itemFile);
+            else
+                newFiles.add(itemFile);
+        }
+
+        if (alreadyExistingFiles.size() > 0) {
+            showConfirmOverwriteByImportQuestion(resolver, appSavegameFolder, alreadyExistingFiles, newFiles);
+        } else {
+            importSaveGames(resolver, appSavegameFolder, newFiles);
+        }
+    }
+
+    private void importSaveGames(ContentResolver resolver, DocumentFile appSavegameFolder, List<DocumentFile> saveFiles) {
+        int size = saveFiles.size();
+        DocumentFile[] sources = new DocumentFile[size];
+        DocumentFile[] targets = new DocumentFile[size];
+
+        boolean saveAsNew = false;
+        for (int i = 0; i < size; i++) {
+            DocumentFile file = saveFiles.get(i);
+            if (file == null) {//null is value a marker that the next should be saved as new
+                saveAsNew = true;
+                continue;
+            }
+
+            int slot = getSlotFromSavegameFileName(file.getName());
+            if (slot == -1) {
+                //invalid file name
+                continue;
+            }
+
+            if (saveAsNew) {
+                slot = getFirstFreeSlot();
+                saveAsNew = false;
+            }
+
+            String targetName = Savegames.getSlotFileName(slot);
+            sources[i] = file;
+            targets[i] = getOrCreateDocumentFile(appSavegameFolder, targetName);
+        }
+
+        AndroidStorage.copyDocumentFilesFromToAsync(sources,
+                this,
+                targets,
+                (sucess) -> completeLoadSaveActivity(SLOT_NUMBER_IMPORT_SAVEGAMES, sucess));
+    }
+
+    private void completeSavegameImportAndCheckIfDone(List<Integer> importsNeedingConfirmation, int slot) {
+        importsNeedingConfirmation.remove((Object) slot);
+        if (importsNeedingConfirmation.isEmpty()) {
+            completeLoadSaveActivity(SLOT_NUMBER_IMPORT_SAVEGAMES);
+        }
+    }
+
+    private boolean getExistsSavegameInOwnFiles(DocumentFile savegameFile, DocumentFile appSavegameFolder) {
+        if (savegameFile == null)
+            return false;
+
+        DocumentFile foundFile = appSavegameFolder.findFile(Objects.requireNonNull(savegameFile.getName()));
+        return foundFile != null && foundFile.exists();
+    }
+
+    private int getSlotFromSavegameFileName(String fileName) {
+        if (fileName == null || !fileName.startsWith(Constants.FILENAME_SAVEGAME_FILENAME_PREFIX)) {
+            //TODO: Maybe output a message that the file didn't have the right name?
+            return -1;
+        }
+        String slotStr = fileName.substring(Constants.FILENAME_SAVEGAME_FILENAME_PREFIX.length());
+
+        int slot;
+        try {
+            slot = Integer.parseInt(slotStr);
+            return slot;
+        } catch (NumberFormatException e) {
+            //TODO: Maybe output a message that the file didn't have the right name?
+            return -1;
+        }
+    }
+
+    private void importSaveGameFile(ContentResolver resolver, DocumentFile appSavegameFolder, DocumentFile itemFile, int slot) {
+        String targetName = Savegames.getSlotFileName(slot);
+        DocumentFile targetFile = getOrCreateDocumentFile(appSavegameFolder, targetName);
+
+        if (targetFile == null || !targetName.equals(targetFile.getName())) {
+            showErrorImportingSaveGameUnknown();//TODO: maybe replace with a more specific error message
+            return;
+        }
+
+        try {
+            AndroidStorage.copyDocumentFile(itemFile, resolver, targetFile);
+        } catch (IOException e) {
+            showErrorImportingSaveGameUnknown();
+            e.printStackTrace();
+        }
+    }
+
+    private DocumentFile getOrCreateDocumentFile(DocumentFile folder, String targetName) {
+        DocumentFile targetFile = folder.findFile(targetName);//try finding the file
+        if (targetFile == null)//no file found, creating new one
+            targetFile = folder.createFile(Constants.NO_FILE_EXTENSION_MIME_TYPE, targetName);
+        return targetFile;
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.P)
+    private void importWorldmap(Intent data) {
+        Uri uri = data.getData();
+
+        Context context = getApplicationContext();
+        ContentResolver resolver = AndorsTrailApplication.getApplicationFromActivity(this).getContentResolver();
+
+        File storageDir = AndroidStorage.getStorageDirectory(context, Constants.FILENAME_SAVEGAME_DIRECTORY);
+        DocumentFile storageFolder = DocumentFile.fromFile(storageDir);
+        DocumentFile ownWorldmapFolder = storageFolder.findFile(Constants.FILENAME_WORLDMAP_DIRECTORY);
+        if (ownWorldmapFolder == null) {
+            ownWorldmapFolder = storageFolder.createDirectory(Constants.FILENAME_WORLDMAP_DIRECTORY);
+        }
+
+        DocumentFile chosenFolder = DocumentFile.fromTreeUri(context, uri);
+        if (chosenFolder == null || !chosenFolder.isDirectory()) {
+            showErrorImportingWorldmapWrongDirectory();
+            return;
+        }
+        if (!Constants.FILENAME_WORLDMAP_DIRECTORY.equals(chosenFolder.getName())) {
+            //user did not select the worldmap folder directly
+            DocumentFile file = chosenFolder.findFile(Constants.FILENAME_WORLDMAP_DIRECTORY);
+            if (file == null || !file.isDirectory() || !Constants.FILENAME_WORLDMAP_DIRECTORY.equals(file.getName())) {
+                //could not find a worldmap folder in the users selection
+                showErrorImportingWorldmapWrongDirectory();
+                return;
+            }
+
+            chosenFolder = file;
+        }
+
+        AndroidStorage.copyDocumentFilesToDirAsync(chosenFolder.listFiles(),
+                this,
+                ownWorldmapFolder,
+                (success) -> completeLoadSaveActivity(SLOT_NUMBER_IMPORT_WORLDMAP, success));
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    private void clickExportSaveGames() {
+        startActivityForResult(AndroidStorage.getNewOpenDirectoryIntent(), -SLOT_NUMBER_EXPORT_SAVEGAMES);
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    private void clickImportSaveGames() {
+        startActivityForResult(AndroidStorage.getNewSelectMultipleSavegameFilesIntent(), -SLOT_NUMBER_IMPORT_SAVEGAMES);
+
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
+    private void clickImportWorldmap() {
+        startActivityForResult(AndroidStorage.getNewOpenDirectoryIntent(), -SLOT_NUMBER_IMPORT_WORLDMAP);
+
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.P)
+    private void showConfirmOverwriteByExportQuestion(ContentResolver resolver, DocumentFile targetFolder, DocumentFile[] files) {
+        final CustomDialog d = CustomDialogFactory.createDialog(this,
+                getString(R.string.loadsave_export_overwrite_confirmation_title),
+                getResources().getDrawable(android.R.drawable.ic_dialog_alert),
+                getString(R.string.loadsave_export_overwrite_confirmation),
+                null,
+                true);
+
+        CustomDialogFactory.addButton(d, android.R.string.yes, v -> exportSaveGamesFolderContentToFolder(resolver, targetFolder, files));
+        CustomDialogFactory.addDismissButton(d, android.R.string.no);
+
+        CustomDialogFactory.show(d);
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.N)
+    private void showConfirmOverwriteByImportQuestion(ContentResolver resolver,
+                                                      DocumentFile appSavegameFolder,
+                                                      List<DocumentFile> alreadyExistingFiles,
+                                                      List<DocumentFile> newFiles) {
+        final String title = getString(R.string.loadsave_import_overwrite_confirmation_title);
+        String message = getString(R.string.loadsave_import_file_exists_question);
+
+        StringBuilder sb = new StringBuilder();
+        sb.append('\n');
+        int amount = alreadyExistingFiles.size();
+
+        Context context = AndorsTrailApplication.getApplicationFromActivity(this).getApplicationContext();
+
+        ArrayList<CustomDialog> dialogs = new ArrayList<CustomDialog>(amount) ;
+
+        for (int i = 0; i < amount ; i++) {
+            DocumentFile alreadyExistingFile = alreadyExistingFiles.get(i);
+            int slot = getSlotFromSavegameFileName(alreadyExistingFile.getName());
+            FileHeader existingFileHeader = Savegames.quickload(context, slot);
+            FileHeader importedFileHeader = null;
+            try (InputStream stream = resolver.openInputStream(alreadyExistingFile.getUri());
+                 DataInputStream dataStream = new DataInputStream(stream)) {
+                importedFileHeader = new FileHeader(dataStream, true);
+            } catch (FileNotFoundException e) {
+                e.printStackTrace();
+                continue;
+            } catch (IOException e) {
+                e.printStackTrace();
+                continue;
+            }
+
+            StringBuilder messageSb = new StringBuilder();
+            String existingFileDescription = getString(R.string.loadsave_import_existing_description, slot, existingFileHeader.describe());
+            String importedFileDescription = getString(R.string.loadsave_import_imported_description, slot, importedFileHeader.describe());
+            messageSb.append(getString(R.string.loadsave_import_file_exists_question, existingFileDescription, importedFileDescription));
+
+
+            String m = messageSb.toString();
+            CustomDialog dialog = CustomDialogFactory.createDialog(this,
+                    title,
+                    getResources().getDrawable(android.R.drawable.ic_dialog_alert),
+                    m,
+                    null,
+                    true,
+                    false,
+                    true);
+
+            CustomDialogFactory.addButton(dialog, R.string.loadsave_import_option_keep_existing, v -> {
+                //do nothing
+                GoToNextConflictOrFinish(resolver, appSavegameFolder, newFiles, dialogs);
+            });
+
+            CustomDialogFactory.addButton(dialog, R.string.loadsave_import_option_keep_imported, v -> {
+                newFiles.add(alreadyExistingFile);
+                GoToNextConflictOrFinish(resolver, appSavegameFolder, newFiles, dialogs);
+            });
+
+            CustomDialogFactory.addButton(dialog, R.string.loadsave_import_option_add_as_new, v -> {
+                newFiles.add(null);//add a null element as marker to know later if the next file should be imported as new or overwrite the existing one
+                newFiles.add(alreadyExistingFile);
+                GoToNextConflictOrFinish(resolver, appSavegameFolder, newFiles, dialogs);
+            });
+
+            CustomDialogFactory.addCancelButton(dialog, android.R.string.cancel);
+            CustomDialogFactory.setCancelListener(dialog, v -> {
+                completeLoadSaveActivity(SLOT_NUMBER_IMPORT_SAVEGAMES, false);
+            });
+
+            dialogs.add(dialog);
+        }
+
+        GoToNextConflictOrFinish(resolver, appSavegameFolder, newFiles, dialogs);
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.N)
+    private void GoToNextConflictOrFinish(ContentResolver resolver, DocumentFile appSavegameFolder, List<DocumentFile> newFiles, ArrayList<CustomDialog> dialogs) {
+        if(dialogs.stream().count() > 0){
+            CustomDialog d = dialogs.remove(0);
+            CustomDialogFactory.show(d);
+        }
+        else{
+            importSaveGames(resolver, appSavegameFolder, newFiles);
+        }
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+
+        if (resultCode != Activity.RESULT_OK)
+            return;
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            switch (-requestCode) {
+                case SLOT_NUMBER_EXPORT_SAVEGAMES:
+                    exportSaveGames(data);
+                    return;
+                case SLOT_NUMBER_IMPORT_SAVEGAMES:
+                    importSaveGames(data);
+                    return;
+                case SLOT_NUMBER_IMPORT_WORLDMAP:
+                    importWorldmap(data);
+                    return;
+            }
+        }
+
+    }
+
+    //endregion
+
+    private void loadSaveGame(int slot) {
+        if (!Savegames.getSlotFile(slot, this).exists()) {
+            showErrorLoadingEmptySlot();
+        } else {
+            final FileHeader header = Savegames.quickload(this, slot);
+            if (header != null && !header.hasUnlimitedSaves) {
+                showSlotGetsDeletedOnLoadWarning(slot);
+            } else {
+                completeLoadSaveActivity(slot);
+            }
+        }
+    }
+
+    //region show Dialogs
+
+    private void showErrorImportingWorldmapWrongDirectory() {
+        final CustomDialog d = CustomDialogFactory.createErrorDialog(this,
+                getString(R.string.loadsave_import_worldmap_unsuccessfull),
+                getString(R.string.loadsave_import_worldmap_wrong_directory));
+        CustomDialogFactory.show(d);
+    }
+
+    private void showErrorImportingSaveGameUnknown() {
+        final CustomDialog d = CustomDialogFactory.createErrorDialog(this,
+                getString(R.string.loadsave_import_save_unsuccessfull),
+                getString(R.string.loadsave_import_save_error_unknown));
+        CustomDialogFactory.show(d);
+    }
+
+    private void showErrorLoadingEmptySlot() {
+        final CustomDialog d = CustomDialogFactory.createErrorDialog(this,
+                getString(R.string.startscreen_error_loading_game),
+                getString(R.string.startscreen_error_loading_empty_slot));
+        CustomDialogFactory.show(d);
+    }
+
+    private void showSlotGetsDeletedOnLoadWarning(final int slot) {
+        final CustomDialog d = CustomDialogFactory.createDialog(this,
+                getString(R.string.startscreen_attention_slot_gets_delete_on_load),
+                getResources().getDrawable(android.R.drawable.ic_dialog_alert),
+                getString(R.string.startscreen_attention_message_slot_gets_delete_on_load),
+                null,
+                true);
+        CustomDialogFactory.addButton(d, android.R.string.ok, v -> completeLoadSaveActivity(slot));
+        CustomDialogFactory.show(d);
+    }
+
+    private void showConfirmoverwriteQuestion(final int slot, String message) {
+        final String title =
+                getString(R.string.loadsave_save_overwrite_confirmation_title) + ' '
+                        + getString(R.string.loadsave_save_overwrite_confirmation_slot, slot);
+        final CustomDialog d = CustomDialogFactory.createDialog(this,
+                title,
+                getResources().getDrawable(android.R.drawable.ic_dialog_alert),
+                message,
+                null,
+                true);
+
+        CustomDialogFactory.addButton(d, android.R.string.yes, v -> completeLoadSaveActivity(slot));
+        CustomDialogFactory.addDismissButton(d, android.R.string.no);
+        CustomDialogFactory.show(d);
+    }
+
+    //endregion
+
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/LoadingActivity.java

@@ -0,0 +1,180 @@
+package com.gpl.rpg.AndorsTrail.activity;
+
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnDismissListener;
+import android.content.Intent;
+import android.graphics.drawable.AnimationDrawable;
+import android.os.Bundle;
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
+import com.gpl.rpg.AndorsTrail.R;
+import com.gpl.rpg.AndorsTrail.WorldSetup;
+import com.gpl.rpg.AndorsTrail.WorldSetup.OnResourcesLoadedListener;
+import com.gpl.rpg.AndorsTrail.WorldSetup.OnSceneLoadedListener;
+import com.gpl.rpg.AndorsTrail.savegames.Savegames;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
+import com.gpl.rpg.AndorsTrail.view.CloudsAnimatorView;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory.CustomDialog;
+
+public final class LoadingActivity extends AndorsTrailBaseActivity implements OnResourcesLoadedListener, OnSceneLoadedListener {
+
+	private WorldSetup setup;
+	private CustomDialog progressDialog;
+	private CloudsAnimatorView clouds_back, clouds_mid, clouds_front;
+	boolean loaded = false;
+
+	private Object semaphore = new Object();
+	
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getBaseTheme());
+		super.onCreate(savedInstanceState);
+		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
+		app.setWindowParameters(this);
+		setContentView(R.layout.startscreen);
+
+		TextView tv = (TextView) findViewById(R.id.startscreen_version);
+		tv.setVisibility(View.GONE);
+		
+		clouds_back = (CloudsAnimatorView) findViewById(R.id.ts_clouds_animator_back);
+		if (clouds_back != null) clouds_back.setCloudsCountAndLayer(40, CloudsAnimatorView.Layer.below);
+		clouds_mid = (CloudsAnimatorView) findViewById(R.id.ts_clouds_animator_mid);
+		if (clouds_mid != null) clouds_mid.setCloudsCountAndLayer(15, CloudsAnimatorView.Layer.center);
+		clouds_front = (CloudsAnimatorView) findViewById(R.id.ts_clouds_animator_front);
+		if (clouds_front != null) clouds_front.setCloudsCountAndLayer(8, CloudsAnimatorView.Layer.above);
+		
+		this.setup = app.getWorldSetup();
+	}
+
+	@Override
+	public void onWindowFocusChanged(boolean hasFocus) {
+		super.onWindowFocusChanged(hasFocus);
+		if (hasFocus) {
+			((AnimationDrawable)((ImageView)findViewById(R.id.title_logo)).getDrawable()).start();
+			ImageView iv = (ImageView) findViewById(R.id.ts_foreground);
+			int ivWidth = iv.getWidth();
+			int drawableWidth = iv.getDrawable().getIntrinsicWidth();
+			float ratio = ((float)ivWidth) / ((float)drawableWidth);
+			
+			if (clouds_back != null) {
+				clouds_back.setScalingRatio(ratio);
+			}
+			if (clouds_mid != null) {
+				clouds_mid.setScalingRatio(ratio);
+			}
+			if (clouds_front != null) {
+				clouds_front.setScalingRatio(ratio);
+			}
+			
+			if (progressDialog == null) {
+				progressDialog = CustomDialogFactory.createDialog(this, getResources().getString(R.string.dialog_loading_message), 
+						getResources().getDrawable(R.drawable.loading_anim), null, null, false, false);
+				synchronized (semaphore) {
+					if (!loaded) {
+						progressDialog.setOwnerActivity(this);
+						CustomDialogFactory.show(progressDialog);
+					}
+				}
+			}
+		}
+	}
+	
+	@Override
+	public void onResume() {
+		super.onResume();
+		
+		setup.setOnResourcesLoadedListener(this);
+		
+
+		final ImageView iv = (ImageView) findViewById(R.id.ts_foreground);
+		iv.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
+			
+			@Override
+			public boolean onPreDraw() {
+				float[] point = new float[]{0f,0.25f * iv.getDrawable().getIntrinsicHeight()};
+				iv.getImageMatrix().mapPoints(point);
+				int imgY = (int) (iv.getTop() + point[1]);
+
+				if (clouds_back != null) {
+					clouds_back.setYMax(imgY);
+				}
+				if (clouds_mid != null) {
+					clouds_mid.setYMax(imgY);
+				}
+				if (clouds_front != null) {
+					clouds_front.setYMax(imgY);
+				}
+				iv.getViewTreeObserver().removeOnPreDrawListener(this);
+				return true;
+			}
+		});
+		
+		
+		if (clouds_back != null)clouds_back.resumeAnimation();
+		if (clouds_mid != null)clouds_mid.resumeAnimation();
+		if (clouds_front != null)clouds_front.resumeAnimation();
+	}
+
+	@Override
+	public void onPause() {
+		super.onPause();
+		setup.setOnResourcesLoadedListener(null);
+		setup.removeOnSceneLoadedListener(this);
+		if (clouds_back != null)clouds_back.pauseAnimation();
+		if (clouds_mid != null)clouds_mid.pauseAnimation();
+		if (clouds_front != null)clouds_front.pauseAnimation();
+	}
+	
+	
+	@Override
+	public void onResourcesLoaded() {
+		loaded = false;
+		setup.startCharacterSetup(this);
+	}
+
+	
+	
+	@Override
+	public void onSceneLoaded() {
+		synchronized (semaphore) {
+			if (progressDialog != null) progressDialog.dismiss();
+			loaded =true;
+		}
+		startActivity(new Intent(this, MainActivity.class));
+		this.finish();
+	}
+
+	@Override
+	public void onSceneLoadFailed(Savegames.LoadSavegameResult loadResult) {
+		synchronized (semaphore) {
+			if (progressDialog != null) progressDialog.dismiss();
+			loaded =true;
+		}
+		if (loadResult == Savegames.LoadSavegameResult.savegameIsFromAFutureVersion) {
+			showLoadingFailedDialog(R.string.dialog_loading_failed_incorrectversion);
+		} else if (loadResult == Savegames.LoadSavegameResult.cheatingDetected) {
+			showLoadingFailedDialog(R.string.dialog_loading_failed_cheat);
+		} else {
+			showLoadingFailedDialog(R.string.dialog_loading_failed_message);
+		}
+	}
+
+	private void showLoadingFailedDialog(int messageResourceID) {
+		final CustomDialog d = CustomDialogFactory.createDialog(this, getResources().getString(R.string.dialog_loading_failed_title), null, getResources().getString(messageResourceID), null, true);
+		CustomDialogFactory.addDismissButton(d, android.R.string.ok);
+		CustomDialogFactory.setDismissListener(d, new OnDismissListener() {
+			@Override
+			public void onDismiss(DialogInterface dialog) {
+				LoadingActivity.this.finish();
+			}
+		});
+		CustomDialogFactory.show(d);
+		
+	}
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/MainActivity.java

@@ -1,14 +1,23 @@
 package com.gpl.rpg.AndorsTrail.activity;
 
+import java.lang.ref.WeakReference;
+import java.util.Collection;
+
 import android.app.Activity;
+import android.app.Dialog;
 import android.content.Intent;
+import android.os.Build;
 import android.os.Bundle;
-import android.view.*;
-import android.view.ContextMenu.ContextMenuInfo;
+import android.view.View;
 import android.view.View.OnClickListener;
+import android.view.View.OnLongClickListener;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.ListView;
 import android.widget.RelativeLayout;
 import android.widget.TextView;
 import android.widget.Toast;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.AndorsTrailPreferences;
 import com.gpl.rpg.AndorsTrail.Dialogs;
@@ -17,26 +26,41 @@ import com.gpl.rpg.AndorsTrail.context.ControllerContext;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.controller.AttackResult;
 import com.gpl.rpg.AndorsTrail.controller.CombatController;
-import com.gpl.rpg.AndorsTrail.controller.MovementController;
+import com.gpl.rpg.AndorsTrail.controller.Constants;
 import com.gpl.rpg.AndorsTrail.controller.listeners.CombatActionListener;
 import com.gpl.rpg.AndorsTrail.controller.listeners.CombatTurnListener;
 import com.gpl.rpg.AndorsTrail.controller.listeners.PlayerMovementListener;
 import com.gpl.rpg.AndorsTrail.controller.listeners.WorldEventListener;
+import com.gpl.rpg.AndorsTrail.model.ability.ActorCondition;
+import com.gpl.rpg.AndorsTrail.model.ability.ActorConditionEffect;
 import com.gpl.rpg.AndorsTrail.model.actor.Monster;
-import com.gpl.rpg.AndorsTrail.model.actor.Player;
-import com.gpl.rpg.AndorsTrail.model.item.ItemContainer.ItemEntry;
 import com.gpl.rpg.AndorsTrail.model.item.Loot;
 import com.gpl.rpg.AndorsTrail.model.map.MapObject;
 import com.gpl.rpg.AndorsTrail.model.map.PredefinedMap;
+import com.gpl.rpg.AndorsTrail.resource.tiles.TileCollection;
 import com.gpl.rpg.AndorsTrail.savegames.Savegames;
 import com.gpl.rpg.AndorsTrail.util.Coord;
-import com.gpl.rpg.AndorsTrail.view.*;
-import com.gpl.rpg.AndorsTrail.view.QuickButton.QuickButtonContextMenuInfo;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
+import com.gpl.rpg.AndorsTrail.view.CombatView;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory.CustomDialog;
+import com.gpl.rpg.AndorsTrail.view.DisplayActiveActorConditionIcons;
+import com.gpl.rpg.AndorsTrail.view.ItemContainerAdapter;
+import com.gpl.rpg.AndorsTrail.view.MainView;
+import com.gpl.rpg.AndorsTrail.view.QuickButton;
+import com.gpl.rpg.AndorsTrail.view.QuickitemView;
+import com.gpl.rpg.AndorsTrail.view.QuickslotsItemContainerAdapter;
+import com.gpl.rpg.AndorsTrail.view.StatusView;
+import com.gpl.rpg.AndorsTrail.view.ToolboxView;
+import com.gpl.rpg.AndorsTrail.view.VirtualDpadView;
 
-import java.lang.ref.WeakReference;
-import java.util.Collection;
-
-public final class MainActivity extends Activity implements PlayerMovementListener, CombatActionListener, CombatTurnListener, WorldEventListener {
+public final class MainActivity
+		extends AndorsTrailBaseActivity
+		implements
+		PlayerMovementListener
+		, CombatActionListener
+		, CombatTurnListener
+		, WorldEventListener {
 
 	public static final int INTENTREQUEST_MONSTERENCOUNTER = 2;
 	public static final int INTENTREQUEST_CONVERSATION = 4;
@@ -54,10 +78,12 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 
 	private TextView statusText;
 	private WeakReference<Toast> lastToast = null;
-	private ContextMenuInfo lastSelectedMenu = null;
+	//private ContextMenuInfo lastSelectedMenu = null;
+	private OnLongClickListener quickButtonLongClickListener = null;
 
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getNoBackgroundTheme());
 		super.onCreate(savedInstanceState);
 
 		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
@@ -73,6 +99,7 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 		combatview = (CombatView) findViewById(R.id.main_combatview);
 		quickitemview = (QuickitemView) findViewById(R.id.main_quickitemview);
 		activeConditions = new DisplayActiveActorConditionIcons(controllers, world, this, (RelativeLayout) findViewById(R.id.statusview_activeconditions));
+		activeConditions.setTarget(world.model.player);
 		VirtualDpadView dpad = (VirtualDpadView) findViewById(R.id.main_virtual_dpad);
 		toolboxview = (ToolboxView) findViewById(R.id.main_toolboxview);
 		statusview.registerToolboxViews(toolboxview, quickitemview);
@@ -90,6 +117,7 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 			new DebugInterface(controllers, world, this).addDebugButtons();
 
 		quickitemview.setVisibility(View.GONE);
+		createLongClickListener();
 		quickitemview.registerForContextMenu(this);
 
 		dpad.updateVisibility(preferences);
@@ -115,7 +143,6 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 			}
 			break;
 		case INTENTREQUEST_CONVERSATION:
-			MovementController.refreshMonsterAggressiveness(world.model.currentMap, world.model.player);
 			controllers.mapController.applyCurrentMapReplacements(getResources(), true);
 			break;
 		case INTENTREQUEST_SAVEGAME:
@@ -123,6 +150,9 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 			final int slot = data.getIntExtra("slot", 1);
 			if (save(slot)) {
 				Toast.makeText(this, getResources().getString(R.string.menu_save_gamesaved, slot), Toast.LENGTH_SHORT).show();
+				if (!world.model.statistics.hasUnlimitedSaves()) {
+					finish();
+				}
 			} else {
 				Toast.makeText(this, R.string.menu_save_failed, Toast.LENGTH_LONG).show();
 			}
@@ -131,8 +161,7 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 	}
 
 	private boolean save(int slot) {
-		final Player player = world.model.player;
-		return Savegames.saveWorld(world, this, slot, getString(R.string.savegame_currenthero_displayinfo, player.getLevel(), player.getTotalExperience(), player.getGold()));
+		return Savegames.saveWorld(world, this, slot);
 	}
 
 	@Override
@@ -162,13 +191,11 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 		super.onResume();
 		if (!AndorsTrailApplication.getApplicationFromActivity(this).getWorldSetup().isSceneReady) return;
 
-		controllers.gameRoundController.resume();
-
-		if (world.model.uiSelections.isInCombat) {
-			controllers.combatController.setCombatSelection(world.model.uiSelections.selectedMonster, world.model.uiSelections.selectedPosition);
-			controllers.combatController.enterCombat(CombatController.BeginTurnAs.continueLastTurn);
+		if (world.model.statistics.isDead()) this.finish();
+		else {
+			controllers.gameRoundController.resume();
+			updateStatus();
 		}
-		updateStatus();
 	}
 
 	private void unsubscribeFromModel() {
@@ -180,6 +207,8 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 		controllers.movementController.playerMovementListeners.remove(this);
 		controllers.combatController.combatActionListeners.remove(this);
 		controllers.combatController.combatTurnListeners.remove(this);
+		controllers.actorStatsController.combatActionListeners.remove(this);
+		controllers.skillController.combatActionListeners.remove(this);
 		controllers.mapController.worldEventListeners.remove(this);
 	}
 
@@ -187,6 +216,8 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 		controllers.mapController.worldEventListeners.add(this);
 		controllers.combatController.combatTurnListeners.add(this);
 		controllers.combatController.combatActionListeners.add(this);
+		controllers.actorStatsController.combatActionListeners.add(this);
+		controllers.skillController.combatActionListeners.add(this);
 		controllers.movementController.playerMovementListeners.add(this);
 		statusview.subscribe();
 		quickitemview.subscribe();
@@ -194,48 +225,50 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 		combatview.subscribe();
 		activeConditions.subscribe();
 	}
+	
 
-	@Override
-	public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
-		super.onCreateContextMenu(menu, v, menuInfo);
-		if(quickitemview.isQuickButtonId(v.getId())){
-			createQuickButtonMenu(menu);
-		}
-		lastSelectedMenu = null;
+	public void registerForLongClick(QuickButton item) {
+		item.setOnLongClickListener(quickButtonLongClickListener);
 	}
 
-	private void createQuickButtonMenu(ContextMenu menu){
-		menu.add(Menu.NONE, R.id.quick_menu_unassign, Menu.NONE, R.string.inventory_unassign);
-		SubMenu assignMenu = menu.addSubMenu(Menu.NONE, R.id.quick_menu_assign, Menu.NONE, R.string.inventory_assign);
-		for(int i=0; i<world.model.player.inventory.items.size(); ++i){
-			ItemEntry itemEntry = world.model.player.inventory.items.get(i);
-			if(itemEntry.itemType.isUsable())
-				assignMenu.add(R.id.quick_menu_assign_group, i, Menu.NONE, itemEntry.itemType.getName(world.model.player));
-		}
-	}
+	public void createLongClickListener() {
+		if (quickButtonLongClickListener != null) return;
+		quickButtonLongClickListener = new OnLongClickListener() {
+			@Override
+			public boolean onLongClick(View v) {
+				if (v instanceof QuickButton) {
+					
+					final int buttonId = ((QuickButton)v).getIndex();
+					
+//					final AlertDialog dialog = new AlertDialog.Builder(new ContextThemeWrapper(v.getContext(), R.style.AndorsTrailStyle_Dialog)).create();
+					View view = getLayoutInflater().inflate(R.layout.quickbuttons_usable_inventory, null);
+					ListView lv = (ListView) view.findViewById(R.id.quickbuttons_assignlist);
 
-	@Override
-	public boolean onContextItemSelected(MenuItem item) {
-		QuickButtonContextMenuInfo menuInfo;
-		if(item.getGroupId() == R.id.quick_menu_assign_group){
-			menuInfo = (QuickButtonContextMenuInfo) lastSelectedMenu;
-			controllers.itemController.setQuickItem(world.model.player.inventory.items.get(item.getItemId()).itemType, menuInfo.index);
-			return true;
-		}
-		switch(item.getItemId()){
-		case R.id.quick_menu_unassign:
-			menuInfo = (QuickButtonContextMenuInfo) item.getMenuInfo();
-			controllers.itemController.setQuickItem(null, menuInfo.index);
-			break;
-		case R.id.quick_menu_assign:
-			menuInfo = (QuickButtonContextMenuInfo) item.getMenuInfo();
-			lastSelectedMenu = menuInfo;
-			break;
-		default:
-			return super.onContextItemSelected(item);
-		}
-		return true;
+					TileCollection wornTiles = world.tileManager.loadTilesFor(world.model.player.inventory, getResources());
+					final ItemContainerAdapter inventoryListAdapter = new QuickslotsItemContainerAdapter(lv.getContext(), world.tileManager, world.model.player.inventory.usableItems(), world.model.player, wornTiles);
+					lv.setAdapter(inventoryListAdapter);
+
+					final CustomDialog d = CustomDialogFactory.createDialog(v.getContext(),
+							v.getResources().getString(R.string.inventory_assign), 
+							v.getResources().getDrawable(R.drawable.ui_icon_equipment), 
+							v.getResources().getString(R.string.inventory_selectitem), view, false);
+					
+					
+					lv.setOnItemClickListener(new OnItemClickListener() {
+						@Override
+						public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+							controllers.itemController.setQuickItem(inventoryListAdapter.getItem(position).itemType, buttonId);
+							d.dismiss();
+						}
+					});
+					
+					CustomDialogFactory.show(d);
+				}
+				return true;
+			}
+		};
 	}
+	
 
 	private void updateStatus() {
 		statusview.updateStatus();
@@ -248,6 +281,14 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 		world.model.combatLog.append(msg);
 		statusText.setText(world.model.combatLog.getLastMessages());
 		statusText.setVisibility(View.VISIBLE);
+		if (! world.model.uiSelections.isInCombat) {
+			statusText.postDelayed(new Runnable(){
+				@Override
+				public void run() {
+					clearMessages();
+				}
+			}, Constants.STATUS_TEXT_AUTOHIDE_DELAY);
+		}
 	}
 
 	private void clearMessages() {
@@ -264,6 +305,10 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 			t = Toast.makeText(this, msg, duration);
 			lastToast = new WeakReference<Toast>(t);
 		} else {
+			if (Build.VERSION.SDK_INT >= 30 ||
+				Build.VERSION.SDK_INT >= 26 && t.getView().isShown()) {
+				t.cancel();
+			}
 			t.setText(msg);
 			t.setDuration(duration);
 		}
@@ -272,7 +317,7 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 
 
 	@Override
-	public void onPlayerMoved(Coord newPosition, Coord previousPosition) { }
+	public void onPlayerMoved(PredefinedMap map, Coord newPosition, Coord previousPosition) { }
 
 	@Override
 	public void onPlayerEnteredNewMap(PredefinedMap map, Coord p) { }
@@ -340,6 +385,11 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 		Dialogs.showConversation(this, controllers, phraseID, m);
 	}
 
+	@Override
+	public void onScriptAreaStartedConversation(String phraseID) {
+		Dialogs.showMapScriptMessage(this, controllers, phraseID);
+	}
+
 	@Override
 	public void onPlayerSteppedOnMonster(Monster m) {
 		Dialogs.showMonsterEncounter(this, controllers, m);
@@ -411,7 +461,11 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 
 	@Override
 	public void onPlayerDied(int lostExp) {
-		message(getString(R.string.combat_hero_dies, lostExp));
+		if (!world.model.statistics.isDead()) {
+			message(getString(R.string.combat_hero_dies, lostExp));
+		} else {
+			Dialogs.showHeroDied(this, controllers);
+		}
 	}
 
 	@Override
@@ -428,4 +482,68 @@ public final class MainActivity extends Activity implements PlayerMovementListen
 	public void onPlayerDoesNotHaveEnoughAP() {
 		message(getString(R.string.combat_not_enough_ap));
 	}
+	
+	@Override
+	public void onPlayerTauntsMonster(Monster attacker) {
+		if (attacker != null) message(getString(R.string.combat_taunt_monster, attacker.getName()));
+	}
+	
+	@Override
+	public void onPlayerReceviesActorCondition(ActorConditionEffect effect) {
+		StringBuilder sb = new StringBuilder();
+		if (effect.isImmunity()) {
+			sb.append(effect.conditionType.name);
+		} else if (effect.isRemovalEffect()) {
+			sb.append(effect.conditionType.name);
+		} else {
+			sb.append(effect.conditionType.name);
+			if (effect.magnitude > 1) {
+				sb.append(" x");
+				sb.append(effect.magnitude);
+			}
+		}
+		if (ActorCondition.isTemporaryEffect(effect.duration)) {
+			sb.append(' ');
+			sb.append(getString(R.string.iteminfo_effect_duration, effect.duration));
+		}
+		String msg = sb.toString();
+
+		if (effect.isImmunity()) {
+			message(getString(R.string.combat_condition_player_immune, msg));
+		} else if (effect.isRemovalEffect()) {
+			message(getString(R.string.combat_condition_player_clear, msg));
+		} else {
+			message(getString(R.string.combat_condition_player_apply, msg));
+		}
+	}
+	
+	@Override
+	public void onMonsterReceivesActorCondition(ActorConditionEffect effect, Monster target) {
+		StringBuilder sb = new StringBuilder();
+		if (effect.isImmunity()) {
+			sb.append(effect.conditionType.name);
+		} else if (effect.isRemovalEffect()) {
+			sb.append(effect.conditionType.name);
+		} else {
+			sb.append(effect.conditionType.name);
+			if (effect.magnitude > 1) {
+				sb.append(" x");
+				sb.append(effect.magnitude);
+			}
+		}
+		if (ActorCondition.isTemporaryEffect(effect.duration)) {
+			sb.append(' ');
+			sb.append(getString(R.string.iteminfo_effect_duration, effect.duration));
+		}
+		String msg = sb.toString();
+
+		if (effect.isImmunity()) {
+			message(getString(R.string.combat_condition_monster_immune, target.getName(), msg));
+		} else if (effect.isRemovalEffect()) {
+			message(getString(R.string.combat_condition_monster_clear, target.getName(), msg));
+		} else {
+			message(getString(R.string.combat_condition_monster_apply, target.getName(), msg));
+		}
+	}
+
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/MonsterEncounterActivity.java

@@ -1,23 +1,25 @@
 package com.gpl.rpg.AndorsTrail.activity;
 
-import android.app.Activity;
 import android.os.Bundle;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.Window;
 import android.widget.Button;
 import android.widget.TextView;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.Dialogs;
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.context.ControllerContext;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.model.actor.Monster;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
 
-public final class MonsterEncounterActivity extends Activity {
+public final class MonsterEncounterActivity extends AndorsTrailBaseActivity {
 
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getDialogTheme());
 		super.onCreate(savedInstanceState);
 		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
 		if (!app.isInitialized()) { finish(); return; }
@@ -38,7 +40,7 @@ public final class MonsterEncounterActivity extends Activity {
 
 		TextView tv = (TextView) findViewById(R.id.monsterencounter_title);
 		tv.setText(monster.getName());
-		world.tileManager.setImageViewTile(getResources(), tv, monster);
+		world.tileManager.setImageViewTile(getResources(), tv, monster, world.model.currentMaps.tiles);
 
 		tv = (TextView) findViewById(R.id.monsterencounter_description);
 		tv.setText(getString(R.string.dialog_monsterencounter_message, difficulty));

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/MonsterInfoActivity.java

@@ -1,6 +1,5 @@
 package com.gpl.rpg.AndorsTrail.activity;
 
-import android.app.Activity;
 import android.os.Bundle;
 import android.view.View;
 import android.view.View.OnClickListener;
@@ -8,17 +7,19 @@ import android.view.ViewGroup;
 import android.view.Window;
 import android.widget.Button;
 import android.widget.TextView;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.Dialogs;
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.context.ControllerContext;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.model.actor.Monster;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
 import com.gpl.rpg.AndorsTrail.view.ItemEffectsView;
 import com.gpl.rpg.AndorsTrail.view.RangeBar;
 import com.gpl.rpg.AndorsTrail.view.TraitsInfoView;
 
-public final class MonsterInfoActivity extends Activity {
+public final class MonsterInfoActivity extends AndorsTrailBaseActivity {
 
 	private WorldContext world;
 	private ControllerContext controllers;
@@ -29,10 +30,12 @@ public final class MonsterInfoActivity extends Activity {
 	private RangeBar hp;
 	private ViewGroup monsterinfo_container;
 	private TextView monsterinfo_max_ap;
+	private TextView monsterinfo_killcount;
 
 
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getDialogTheme());
 		super.onCreate(savedInstanceState);
 		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
 		if (!app.isInitialized()) { finish(); return; }
@@ -45,6 +48,7 @@ public final class MonsterInfoActivity extends Activity {
 		monsterinfo_title = (TextView) findViewById(R.id.monsterinfo_title);
 		monsterinfo_difficulty = (TextView) findViewById(R.id.monsterinfo_difficulty);
 		monsterinfo_max_ap = (TextView) findViewById(R.id.monsterinfo_max_ap);
+		monsterinfo_killcount = (TextView) findViewById(R.id.monsterinfo_killcount);
 
 		Button b = (Button) findViewById(R.id.monsterinfo_close);
 		b.setOnClickListener(new OnClickListener() {
@@ -76,7 +80,7 @@ public final class MonsterInfoActivity extends Activity {
 
 	private void updateTitle(Monster monster) {
 		monsterinfo_title.setText(monster.getName());
-		world.tileManager.setImageViewTile(getResources(), monsterinfo_title, monster);
+		world.tileManager.setImageViewTile(getResources(), monsterinfo_title, monster, world.model.currentMaps.tiles);
 		monsterinfo_difficulty.setText(getMonsterDifficultyResource(controllers, monster));
 	}
 
@@ -87,9 +91,12 @@ public final class MonsterInfoActivity extends Activity {
 				null,
 				monster.getOnHitEffectsAsList(),
 				null,
+				monster.getOnHitReceivedEffectsAsList(),
+				monster.getOnDeathEffects(),
 				false);
 		hp.update(monster.getMaxHP(), monster.getCurrentHP());
 		monsterinfo_max_ap.setText(Integer.toString(monster.getMaxAP()));
+		monsterinfo_killcount.setText(Integer.toString(world.model.statistics.getNumberOfKillsForMonsterName(monster.getName()) ));
 	}
 
 	public static int getMonsterDifficultyResource(ControllerContext controllerContext, Monster monster) {

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/Preferences.java

@@ -0,0 +1,36 @@
+package com.gpl.rpg.AndorsTrail.activity;
+
+import android.os.Bundle;
+import android.preference.PreferenceActivity;
+import android.view.Window;
+import android.view.WindowManager;
+
+import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
+import com.gpl.rpg.AndorsTrail.R;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
+
+public final class Preferences extends PreferenceActivity {
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getBaseTheme());
+		requestWindowFeature(Window.FEATURE_NO_TITLE);
+		super.onCreate(savedInstanceState);
+		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
+		if (app.getPreferences().fullscreen) {
+			getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+		} else {
+			getWindow().setFlags(0, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+		}
+
+		app.setLocale(this);
+		addPreferencesFromResource(R.xml.preferences);
+	}
+
+	@Override
+	protected void onResume() {
+		super.onResume();
+		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
+		app.setLocale(this);
+	}
+}
+

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/ShopActivity.java

@@ -2,17 +2,23 @@ package com.gpl.rpg.AndorsTrail.activity;
 
 import android.content.res.Resources;
 import android.os.Bundle;
-import android.support.v4.app.FragmentActivity;
 import android.support.v4.app.FragmentTabHost;
+import android.view.LayoutInflater;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.activity.fragment.ShopActivity_Buy;
 import com.gpl.rpg.AndorsTrail.activity.fragment.ShopActivity_Sell;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
 
-public final class ShopActivity extends FragmentActivity {
+public final class ShopActivity extends AndorsTrailBaseFragmentActivity {
 
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getBaseTheme());
 		super.onCreate(savedInstanceState);
 
 		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
@@ -26,11 +32,22 @@ public final class ShopActivity extends FragmentActivity {
 		FragmentTabHost tabHost = (FragmentTabHost) findViewById(android.R.id.tabhost);
 		tabHost.setup(this, getSupportFragmentManager(), R.id.realtabcontent);
 
+		LayoutInflater inflater = getLayoutInflater();
+		
+		ViewGroup v;
+		
+		v = (ViewGroup) inflater.inflate(R.layout.tabindicator, null);
+		((TextView)v.findViewById(R.id.tabindicator_text)).setText(res.getString(R.string.shop_buy));
+		((ImageView)v.findViewById(R.id.tabindicator_icon)).setImageResource(R.drawable.ui_icon_equipment);
 		tabHost.addTab(tabHost.newTabSpec("buy")
-				.setIndicator(res.getString(R.string.shop_buy))
+				.setIndicator(v)
 				,ShopActivity_Buy.class, null);
+		
+		v = (ViewGroup) inflater.inflate(R.layout.tabindicator, null);
+		((TextView)v.findViewById(R.id.tabindicator_text)).setText(res.getString(R.string.shop_sell));
+		((ImageView)v.findViewById(R.id.tabindicator_icon)).setImageResource(R.drawable.ui_icon_coins);
 		tabHost.addTab(tabHost.newTabSpec("sell")
-				.setIndicator(res.getString(R.string.shop_sell))
+				.setIndicator(v)
 				,ShopActivity_Sell.class, null);
 	}
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/SkillInfoActivity.java

@@ -1,6 +1,5 @@
 package com.gpl.rpg.AndorsTrail.activity;
 
-import android.app.Activity;
 import android.content.Intent;
 import android.content.res.Resources;
 import android.os.Bundle;
@@ -10,6 +9,7 @@ import android.view.ViewGroup;
 import android.view.ViewGroup.LayoutParams;
 import android.widget.Button;
 import android.widget.TextView;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
@@ -18,11 +18,13 @@ import com.gpl.rpg.AndorsTrail.model.ability.SkillCollection;
 import com.gpl.rpg.AndorsTrail.model.ability.SkillInfo;
 import com.gpl.rpg.AndorsTrail.model.ability.SkillInfo.SkillLevelRequirement;
 import com.gpl.rpg.AndorsTrail.model.actor.Player;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
 
-public final class SkillInfoActivity extends Activity {
+public final class SkillInfoActivity extends AndorsTrailBaseActivity {
 
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
+		setTheme(ThemeHelper.getDialogTheme());
 		super.onCreate(savedInstanceState);
 		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
 		if (!app.isInitialized()) { finish(); return; }
@@ -145,9 +147,12 @@ public final class SkillInfoActivity extends Activity {
 		case fightstyleDualWield: return R.string.skill_title_fightstyle_dualwield;
 		case fightstyle2hand: return R.string.skill_title_fightstyle_2hand;
 		case fightstyleWeaponShield: return R.string.skill_title_fightstyle_weapon_shield;
+		case fightstyleUnarmedUnarmored: return R.string.skill_title_fightstyle_unarmed_unarmored;
 		case specializationDualWield: return R.string.skill_title_specialization_dualwield;
 		case specialization2hand: return R.string.skill_title_specialization_2hand;
 		case specializationWeaponShield: return R.string.skill_title_specialization_weapon_shield;
+		case weaponProficiencyPole: return R.string.skill_title_weapon_prof_pole;
+		case sporeImmunity: return R.string.skill_title_spore_immunity;
 		default:
 			return -1;
 		}
@@ -176,6 +181,7 @@ public final class SkillInfoActivity extends Activity {
 		case resistancePhysical: return res.getString(R.string.skill_longdescription_resistance_physical_capacity, SkillCollection.PER_SKILLPOINT_INCREASE_RESISTANCE_CHANCE_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_RESISTANCE_CHANCE_PERCENT * SkillCollection.MAX_LEVEL_RESISTANCE);
 		case resistanceBlood: return res.getString(R.string.skill_longdescription_resistance_blood_disorder, SkillCollection.PER_SKILLPOINT_INCREASE_RESISTANCE_CHANCE_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_RESISTANCE_CHANCE_PERCENT * SkillCollection.MAX_LEVEL_RESISTANCE);
 		case shadowBless: return res.getString(R.string.skill_longdescription_shadow_bless, SkillCollection.PER_SKILLPOINT_INCREASE_RESISTANCE_SHADOW_BLESS);
+		case sporeImmunity: return res.getString(R.string.skill_longdescription_spore_immunity);
 		case crit1: return res.getString(R.string.skill_longdescription_crit1, SkillCollection.PER_SKILLPOINT_INCREASE_CRIT1_CHANCE);
 		case crit2: return res.getString(R.string.skill_longdescription_crit2, SkillCollection.PER_SKILLPOINT_INCREASE_CRIT2_CHANCE);
 		case rejuvenation: return res.getString(R.string.skill_longdescription_rejuvenation, SkillCollection.PER_SKILLPOINT_INCREASE_REJUVENATION_CHANCE);
@@ -194,9 +200,16 @@ public final class SkillInfoActivity extends Activity {
 		case fightstyleDualWield: return res.getString(R.string.skill_longdescription_fightstyle_dualwield, SkillCollection.DUALWIELD_EFFICIENCY_LEVEL0, SkillCollection.DUALWIELD_EFFICIENCY_LEVEL1, SkillCollection.DUALWIELD_LEVEL1_OFFHAND_AP_COST_PERCENT, SkillCollection.DUALWIELD_EFFICIENCY_LEVEL2);
 		case fightstyle2hand: return res.getString(R.string.skill_longdescription_fightstyle_2hand, SkillCollection.PER_SKILLPOINT_INCREASE_FIGHTSTYLE_2HAND_DMG_PERCENT);
 		case fightstyleWeaponShield: return res.getString(R.string.skill_longdescription_fightstyle_weapon_shield, SkillCollection.PER_SKILLPOINT_INCREASE_FIGHTSTYLE_WEAPON_AC_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_FIGHTSTYLE_SHIELD_BC_PERCENT);
+		case fightstyleUnarmedUnarmored: return res.getString(R.string.skill_longdescription_fightstyle_unarmed_unarmored,
+				SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_UNARMORED_AC,
+				SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_UNARMORED_BC,
+				SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_UNARMORED_DR,
+				SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_UNARMORED_DMG_MAX,
+				SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_UNARMORED_CM_PERCENT);
 		case specializationDualWield: return res.getString(R.string.skill_longdescription_specialization_dualwield, SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_DUALWIELD_AC_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_DUALWIELD_BC_PERCENT);
 		case specialization2hand: return res.getString(R.string.skill_longdescription_specialization_2hand, SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_2HAND_DMG_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_2HAND_AC_PERCENT);
 		case specializationWeaponShield: return res.getString(R.string.skill_longdescription_specialization_weapon_shield, SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_WEAPON_AC_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_SPECIALIZATION_WEAPON_DMG_PERCENT);
+		case weaponProficiencyPole: return res.getString(R.string.skill_longdescription_weapon_prof_pole, SkillCollection.PER_SKILLPOINT_INCREASE_WEAPON_PROF_AC_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_WEAPON_PROF_BC_PERCENT, SkillCollection.PER_SKILLPOINT_INCREASE_WEAPON_PROF_CS_PERCENT);
 		default:
 			return "";
 		}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/StartScreenActivity.java

@@ -0,0 +1,288 @@
+package com.gpl.rpg.AndorsTrail.activity;
+
+import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
+import com.gpl.rpg.AndorsTrail.AndorsTrailPreferences;
+import com.gpl.rpg.AndorsTrail.R;
+import com.gpl.rpg.AndorsTrail.activity.fragment.StartScreenActivity_MainMenu;
+import com.gpl.rpg.AndorsTrail.activity.fragment.StartScreenActivity_MainMenu.OnNewGameRequestedListener;
+import com.gpl.rpg.AndorsTrail.activity.fragment.StartScreenActivity_NewGame;
+import com.gpl.rpg.AndorsTrail.activity.fragment.StartScreenActivity_NewGame.GameCreationOverListener;
+import com.gpl.rpg.AndorsTrail.resource.tiles.TileManager;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
+import com.gpl.rpg.AndorsTrail.view.CloudsAnimatorView;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory.CustomDialog;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.res.Resources;
+import android.graphics.drawable.AnimationDrawable;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager.OnBackStackChangedListener;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.ViewTreeObserver;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+public final class StartScreenActivity extends AndorsTrailBaseFragmentActivity implements OnNewGameRequestedListener, GameCreationOverListener, OnBackStackChangedListener {
+
+	private TextView tv;
+	private TextView development_version;
+	private CloudsAnimatorView clouds_back, clouds_mid, clouds_front;
+	private Fragment currentFragment;
+	
+	//Means false by default, as a toggle is initiated in onCreate.
+	boolean ui_visible = true;
+	
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		initPreferences();
+		setTheme(ThemeHelper.getBaseTheme());
+		super.onCreate(savedInstanceState);
+
+		final AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
+		final Resources res = getResources();
+		TileManager tileManager = app.getWorld().tileManager;
+		tileManager.setDensity(res);
+		app.setWindowParameters(this);
+
+		setContentView(R.layout.startscreen);
+
+		if (findViewById(R.id.startscreen_fragment_container) != null) {
+			StartScreenActivity_MainMenu mainMenu = new StartScreenActivity_MainMenu();
+			
+			getSupportFragmentManager().beginTransaction()
+				.replace(R.id.startscreen_fragment_container, mainMenu)
+				.commit();
+			currentFragment = mainMenu;
+			
+			getSupportFragmentManager().addOnBackStackChangedListener(this);
+		}
+		
+		
+		
+		tv = (TextView) findViewById(R.id.startscreen_version);
+		tv.setText('v' + AndorsTrailApplication.CURRENT_VERSION_DISPLAY);
+		
+		development_version = (TextView) findViewById(R.id.startscreen_dev_version);
+		if (AndorsTrailApplication.DEVELOPMENT_INCOMPATIBLE_SAVEGAMES) {
+			development_version.setText(R.string.startscreen_incompatible_savegames);
+			development_version.setVisibility(View.VISIBLE);
+		} else if (!AndorsTrailApplication.IS_RELEASE_VERSION) {
+			development_version.setText(R.string.startscreen_non_release_version);
+			development_version.setVisibility(View.VISIBLE);
+		}
+		
+
+		clouds_back = (CloudsAnimatorView) findViewById(R.id.ts_clouds_animator_back);
+		if (clouds_back != null) clouds_back.setCloudsCountAndLayer(40, CloudsAnimatorView.Layer.below);
+		clouds_mid = (CloudsAnimatorView) findViewById(R.id.ts_clouds_animator_mid);
+		if (clouds_mid != null) clouds_mid.setCloudsCountAndLayer(15, CloudsAnimatorView.Layer.center);
+		clouds_front = (CloudsAnimatorView) findViewById(R.id.ts_clouds_animator_front);
+		if (clouds_front != null) clouds_front.setCloudsCountAndLayer(8, CloudsAnimatorView.Layer.above);
+		
+		View background = findViewById(R.id.title_bg);
+		if (background != null) {
+			background.setOnClickListener(new View.OnClickListener() {
+			
+				@Override
+				public void onClick(View v) {
+					toggleUiVisibility();
+				}
+			});
+		}
+		
+		if (development_version.getVisibility() == View.VISIBLE) {
+			development_version.setText(development_version.getText()
+//					+
+//					"\nMax Heap: " + Runtime.getRuntime().maxMemory() / (1024 * 1024) + "MB"+
+//					"\nUsed Heap: " + Runtime.getRuntime().totalMemory() / (1024 * 1024) + "MB"+
+//					"\nTile size: " + (int) (32 * res.getDisplayMetrics().density)
+					);
+		}
+
+		toggleUiVisibility();
+		
+		app.getWorldSetup().startResourceLoader(res);
+	}
+
+	@Override
+	public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+		if (grantResults.length > 0 && grantResults[0] != PackageManager.PERMISSION_GRANTED) {
+
+			final CustomDialog d = CustomDialogFactory.createDialog(this,
+					getResources().getString(R.string.dialog_permission_information_title),
+					getResources().getDrawable(android.R.drawable.ic_dialog_info),
+					getResources().getString(R.string.dialog_permission_information),
+					null,
+					true);
+			final Activity activity = this;
+			CustomDialogFactory.addDismissButton(d, android.R.string.ok);
+			CustomDialogFactory.setDismissListener(d, new DialogInterface.OnDismissListener() {
+				@Override
+				public void onDismiss(DialogInterface dialog) {
+					StartScreenActivity_MainMenu.checkAndRequestPermissions(activity);
+				}
+			});
+			CustomDialogFactory.show(d);
+		}
+	}
+
+	private void toggleUiVisibility() {
+		ui_visible = !ui_visible; 
+		int visibility = ui_visible ? View.VISIBLE : View.GONE;
+		if (tv != null) tv.setVisibility(visibility);
+		if (!AndorsTrailApplication.IS_RELEASE_VERSION) {
+			if (development_version != null) development_version.setVisibility(visibility);
+		}
+		if (currentFragment != null) {
+			if (ui_visible) {
+
+				if (!AndorsTrailApplication.IS_RELEASE_VERSION) {
+					development_version.setText(
+						development_version.getText()
+//						+
+//						"\nMax Heap: " + Runtime.getRuntime().maxMemory() / (1024 * 1024) + "MB"+
+//						"\nUsed Heap: " + Runtime.getRuntime().totalMemory() / (1024 * 1024) + "MB"+
+//						"\nTile size: " + (int) (32 * getResources().getDisplayMetrics().density)
+						);
+				}
+				
+				getSupportFragmentManager().beginTransaction()
+					.show(currentFragment)
+					.commit();
+			} else {
+				getSupportFragmentManager().beginTransaction()
+					.hide(currentFragment)
+					.commit();
+			}
+		}
+	}
+	
+	private void initPreferences() {
+		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this);
+		AndorsTrailPreferences preferences = app.getPreferences();
+		preferences.read(this);
+		ThemeHelper.changeTheme(preferences.selectedTheme);
+	}
+	
+	@Override
+	public void onWindowFocusChanged(boolean hasFocus) {
+		super.onWindowFocusChanged(hasFocus);
+		if (hasFocus) {
+			((AnimationDrawable)((ImageView)findViewById(R.id.title_logo)).getDrawable()).start();
+			ImageView iv = (ImageView) findViewById(R.id.ts_foreground);
+			int ivWidth = iv.getWidth();
+			int drawableWidth = iv.getDrawable().getIntrinsicWidth();
+			float ratio = ((float)ivWidth) / ((float)drawableWidth);
+			
+			if (clouds_back != null) {
+				clouds_back.setScalingRatio(ratio);
+			}
+			if (clouds_mid != null) {
+				clouds_mid.setScalingRatio(ratio);
+			}
+			if (clouds_front != null) {
+				clouds_front.setScalingRatio(ratio);
+			}
+		}
+	}
+	
+	@Override
+	protected void onResume() {
+		super.onResume();
+		final ImageView iv = (ImageView) findViewById(R.id.ts_foreground);
+		iv.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
+			
+			@Override
+			public boolean onPreDraw() {
+				float[] point = new float[]{0f,0.25f * iv.getDrawable().getIntrinsicHeight()};
+				iv.getImageMatrix().mapPoints(point);
+				int imgY = (int) (iv.getTop() + point[1]);
+				int screenHeight = getResources().getDisplayMetrics().heightPixels;
+
+				if (clouds_back != null) {
+					clouds_back.setYMax(imgY);
+				}
+				if (clouds_mid != null) {
+					clouds_mid.setYMax(imgY);
+				}
+				if (clouds_front != null) {
+					clouds_front.setYMax(imgY);
+				}
+				iv.getViewTreeObserver().removeOnPreDrawListener(this);
+				return true;
+			}
+		});
+		
+		
+		if (clouds_back != null)clouds_back.resumeAnimation();
+		if (clouds_mid != null)clouds_mid.resumeAnimation();
+		if (clouds_front != null)clouds_front.resumeAnimation();
+	}
+
+	@Override
+	protected void onPause() {
+		super.onPause();
+		if (clouds_back != null)clouds_back.pauseAnimation();
+		if (clouds_mid != null)clouds_mid.pauseAnimation();
+		if (clouds_front != null)clouds_front.pauseAnimation();
+	}
+	
+	@Override
+	protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+		super.onActivityResult(requestCode, resultCode, data);
+	}
+	
+	@Override
+	public boolean onKeyDown(int keyCode, KeyEvent event) {
+		if (keyCode == KeyEvent.KEYCODE_BACK) {
+			if (getSupportFragmentManager().getBackStackEntryCount() > 0) {
+				backPressed();
+				return true;
+			} else {
+				return super.onKeyDown(keyCode, event);
+			}
+		}
+		return super.onKeyDown(keyCode, event);
+	}
+
+	private void backPressed() {
+		if (getSupportFragmentManager().getBackStackEntryCount() > 0) {
+			getSupportFragmentManager().popBackStack();
+			currentFragment = getSupportFragmentManager().findFragmentById(R.id.startscreen_fragment_container);
+		}
+	}
+	
+	
+	
+	public void onNewGameRequested() {
+		if (findViewById(R.id.startscreen_fragment_container) != null) {
+			StartScreenActivity_NewGame newGameFragment = new StartScreenActivity_NewGame();
+			
+			getSupportFragmentManager().beginTransaction()
+				.replace(R.id.startscreen_fragment_container, newGameFragment)
+				.addToBackStack(null)
+				.commit();
+
+			currentFragment = newGameFragment;
+			
+		}
+	}
+	
+	@Override
+	public void onGameCreationCancelled() {
+		backPressed();
+	}
+
+	@Override
+	public void onBackStackChanged() {
+		currentFragment = getSupportFragmentManager().findFragmentById(R.id.startscreen_fragment_container);
+	}
+	
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/fragment/HeroinfoActivity_Inventory.java

@@ -1,18 +1,26 @@
 package com.gpl.rpg.AndorsTrail.activity.fragment;
 
+import java.util.Arrays;
+
 import android.app.Activity;
 import android.content.Intent;
 import android.os.Bundle;
 import android.support.v4.app.Fragment;
-import android.view.*;
-import android.view.ContextMenu.ContextMenuInfo;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
 import android.view.View.OnClickListener;
+import android.view.ViewGroup;
 import android.widget.AdapterView;
 import android.widget.AdapterView.AdapterContextMenuInfo;
 import android.widget.AdapterView.OnItemClickListener;
+import android.widget.AdapterView.OnItemLongClickListener;
 import android.widget.ImageView;
 import android.widget.ListView;
 import android.widget.TextView;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.Dialogs;
 import com.gpl.rpg.AndorsTrail.R;
@@ -20,14 +28,17 @@ import com.gpl.rpg.AndorsTrail.activity.ItemInfoActivity;
 import com.gpl.rpg.AndorsTrail.context.ControllerContext;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.controller.ItemController;
+import com.gpl.rpg.AndorsTrail.model.actor.HeroCollection;
 import com.gpl.rpg.AndorsTrail.model.actor.Player;
 import com.gpl.rpg.AndorsTrail.model.item.Inventory;
 import com.gpl.rpg.AndorsTrail.model.item.ItemContainer;
 import com.gpl.rpg.AndorsTrail.model.item.ItemType;
 import com.gpl.rpg.AndorsTrail.resource.tiles.TileCollection;
+import com.gpl.rpg.AndorsTrail.view.CustomMenuInflater;
 import com.gpl.rpg.AndorsTrail.view.ItemContainerAdapter;
+import com.gpl.rpg.AndorsTrail.view.SpinnerEmulator;
 
-public final class HeroinfoActivity_Inventory extends Fragment {
+public final class HeroinfoActivity_Inventory extends Fragment implements CustomMenuInflater.MenuItemSelectedListener {
 
 	private static final int INTENTREQUEST_ITEMINFO = 3;
 	private static final int INTENTREQUEST_BULKSELECT_DROP = 11;
@@ -37,7 +48,15 @@ public final class HeroinfoActivity_Inventory extends Fragment {
 	private TileCollection wornTiles;
 
 	private Player player;
+	private ListView inventoryList;
 	private ItemContainerAdapter inventoryListAdapter;
+	private ItemContainerAdapter inventoryWeaponsListAdapter;
+	private ItemContainerAdapter inventoryArmorListAdapter;
+	private ItemContainerAdapter inventoryJewelryListAdapter;
+	private ItemContainerAdapter inventoryPotionListAdapter;
+	private ItemContainerAdapter inventoryFoodListAdapter;
+	private ItemContainerAdapter inventoryQuestListAdapter;
+	private ItemContainerAdapter inventoryOtherListAdapter;
 
 	private TextView heroinfo_stats_gold;
 	private TextView heroinfo_stats_attack;
@@ -60,25 +79,71 @@ public final class HeroinfoActivity_Inventory extends Fragment {
 
 	@Override
 	public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
-		View v = inflater.inflate(R.layout.heroinfo_inventory, container, false);
+		final View v = inflater.inflate(R.layout.heroinfo_inventory, container, false);
+
+		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this.getActivity());
+		if (!app.isInitialized()) return v;
+		
+		inventoryList = (ListView) v.findViewById(R.id.inventorylist_root);
+		ImageView heroicon = (ImageView) v.findViewById(R.id.heroinfo_inventory_heroicon);
+		heroinfo_stats_gold = (TextView) v.findViewById(R.id.heroinfo_stats_gold);
+		heroinfo_stats_attack = (TextView) v.findViewById(R.id.heroinfo_stats_attack);
+		heroinfo_stats_defense = (TextView) v.findViewById(R.id.heroinfo_stats_defense);
 
-		ListView inventoryList = (ListView) v.findViewById(R.id.inventorylist_root);
 		registerForContextMenu(inventoryList);
 		inventoryList.setOnItemClickListener(new OnItemClickListener() {
 			@Override
 			public void onItemClick(AdapterView<?> parent, View v, int position, long id) {
-				ItemType itemType = inventoryListAdapter.getItem(position).itemType;
+				// Move this code to separate function? -- Done
+				ItemType itemType = getSelectedItemType(position);
 				showInventoryItemInfo(itemType.id);
 			}
 		});
+		inventoryList.setOnItemLongClickListener(new OnItemLongClickListener() {
+			
+			@Override
+			public boolean onItemLongClick(AdapterView<?> parent, View view, int position, long id) {
+				showContextMenuForItem(getSelectedItemType(position));
+				return true;
+			}
+		});
+
+		new SpinnerEmulator(v, R.id.inventorylist_category_filters_button, R.array.inventorylist_category_filters, R.string.heroinfo_inventory_categories) {
+			@Override
+			public void setValue(int value) {
+				world.model.uiSelections.selectedInventoryCategory = value;
+			}
+			@Override
+			public void selectionChanged(int value) {
+				reloadShownCategory(value);
+			}
+			@Override
+			public int getValue() {
+				return world.model.uiSelections.selectedInventoryCategory;
+			}
+		};
+		new SpinnerEmulator(v, R.id.inventorylist_sort_filters_button, R.array.inventorylist_sort_filters, R.string.heroinfo_inventory_sort) {
+			@Override
+			public void setValue(int value) {
+				world.model.uiSelections.selectedInventorySort = value;
+			}
+			@Override
+			public void selectionChanged(int value) {
+				reloadShownSort(player.inventory);
+			}
+			@Override
+			public int getValue() {
+				return world.model.uiSelections.selectedInventorySort;
+			}
+		};
+		
 		ItemContainer inv = player.inventory;
 		wornTiles = world.tileManager.loadTilesFor(player.inventory, getResources());
 		inventoryListAdapter = new ItemContainerAdapter(getActivity(), world.tileManager, inv, player, wornTiles);
 		inventoryList.setAdapter(inventoryListAdapter);
 
-		heroinfo_stats_gold = (TextView) v.findViewById(R.id.heroinfo_stats_gold);
-		heroinfo_stats_attack = (TextView) v.findViewById(R.id.heroinfo_stats_attack);
-		heroinfo_stats_defense = (TextView) v.findViewById(R.id.heroinfo_stats_defense);
+		
+		heroicon.setImageResource(HeroCollection.getHeroLargeSprite(player.iconID));
 
 		setWearSlot(v, Inventory.WearSlot.weapon, R.id.heroinfo_worn_weapon, R.drawable.equip_weapon);
 		setWearSlot(v, Inventory.WearSlot.shield, R.id.heroinfo_worn_shield, R.drawable.equip_shield);
@@ -118,6 +183,10 @@ public final class HeroinfoActivity_Inventory extends Fragment {
 		super.onActivityResult(requestCode, resultCode, data);
 		switch (requestCode) {
 		case INTENTREQUEST_ITEMINFO:
+			if (resultCode == ItemInfoActivity.RESULT_MORE_ACTIONS) {
+				showContextMenuForItem( world.itemTypes.getItemType(data.getExtras().getString("itemTypeID")));
+				break;
+			}
 			if (resultCode != Activity.RESULT_OK) break;
 
 			ItemType itemType = world.itemTypes.getItemType(data.getExtras().getString("itemTypeID"));
@@ -201,45 +270,76 @@ public final class HeroinfoActivity_Inventory extends Fragment {
 	}
 
 	private void updateItemList() {
-		inventoryListAdapter.notifyDataSetChanged();
+		int currentScreen = world.model.uiSelections.selectedInventoryCategory;
+		if (currentScreen == 0)
+			inventoryListAdapter.notifyDataSetChanged();
+		else
+			reloadShownCategory(world.model.uiSelections.selectedInventoryCategory);
 	}
 
-	@Override
-	public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
-		super.onCreateContextMenu(menu, v, menuInfo);
-		ItemType type = getSelectedItemType((AdapterContextMenuInfo) menuInfo);
+//	@Override
+//	public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {}
+//		ItemType type = getSelectedItemType((AdapterContextMenuInfo) menuInfo);
+	
+	
+	public void showContextMenuForItem(ItemType type) {
 		MenuInflater inflater = getActivity().getMenuInflater();
-		switch (v.getId()) {
-		case R.id.inventorylist_root:
-			inflater.inflate(R.menu.inventoryitem, menu);
-			if (type.isUsable()){
-				menu.findItem(R.id.inv_menu_use).setVisible(true);
-				menu.findItem(R.id.inv_menu_assign).setVisible(true);
-			}
-			if (type.isEquippable()) {
-				menu.findItem(R.id.inv_menu_equip).setVisible(true);
-				if (type.isOffhandCapableWeapon()) menu.findItem(R.id.inv_menu_equip_offhand).setVisible(true);
-				else if (type.category.inventorySlot == Inventory.WearSlot.leftring) menu.findItem(R.id.inv_menu_equip_offhand).setVisible(true);
-			}
-			break;
+		Menu menu = CustomMenuInflater.newMenuInstance(getActivity());
+		inflater.inflate(R.menu.inventoryitem, menu);
+		if (type.isUsable()){
+			menu.findItem(R.id.inv_menu_use).setVisible(true);
+			menu.findItem(R.id.inv_menu_assign).setVisible(true);
+		}
+		if (type.isEquippable()) {
+			menu.findItem(R.id.inv_menu_equip).setVisible(true);
+			if (type.isOffhandCapableWeapon()) menu.findItem(R.id.inv_menu_equip_offhand).setVisible(true);
+			else if (type.category.inventorySlot == Inventory.WearSlot.leftring) menu.findItem(R.id.inv_menu_equip_offhand).setVisible(true);
 		}
 		lastSelectedItem = null;
+		CustomMenuInflater.showMenuInDialog(getActivity(), menu, world.tileManager.getDrawableForItem(getResources(), type.iconID, world.tileManager.loadTilesFor(Arrays.asList(new Integer[] { type.iconID}), getResources())), type.getName(player), type, this);
 	}
 
-	private ItemType getSelectedItemType(AdapterContextMenuInfo info) {
-		return inventoryListAdapter.getItem(info.position).itemType;
+	private ItemType getSelectedItemType(int position) {
+		int v = world.model.uiSelections.selectedInventoryCategory;
+
+		if (v == 0) { //All items
+			return inventoryListAdapter.getItem(position).itemType;
+		}else if (v == 1) { //Weapon items
+			return inventoryWeaponsListAdapter.getItem(position).itemType;
+		} else if (v == 2) { //Armor items
+			return inventoryArmorListAdapter.getItem(position).itemType;
+		} else if (v == 3) { //Jewelry items
+			return inventoryJewelryListAdapter.getItem(position).itemType;
+		} else if (v == 4) { //Potion items
+			return inventoryPotionListAdapter.getItem(position).itemType;
+		} else if (v == 5) { //Food items
+			return inventoryFoodListAdapter.getItem(position).itemType;
+		} else if (v == 6) { //Quest items
+			return inventoryQuestListAdapter.getItem(position).itemType;
+		} else if (v == 7) { //Other items
+			return inventoryOtherListAdapter.getItem(position).itemType;
+		}
+
+		// Better than crashing...
+		return inventoryListAdapter.getItem(position).itemType;
+
 	}
+
+
+	private ItemType getSelectedItemType(AdapterContextMenuInfo info) {
+		return getSelectedItemType(info.position);
+	}
+	
 	@Override
-	public boolean onContextItemSelected(MenuItem item) {
-		ItemType itemType;
-		AdapterContextMenuInfo info = (AdapterContextMenuInfo) item.getMenuInfo();
+	public void onMenuItemSelected(MenuItem item, Object data) {
+		ItemType itemType = (ItemType) data;
 		switch (item.getItemId()) {
 		case R.id.inv_menu_info:
-			showInventoryItemInfo(getSelectedItemType(info));
+			showInventoryItemInfo(itemType);
 			//context.mapController.itemInfo(this, getSelectedItemType(info));
 			break;
 		case R.id.inv_menu_drop:
-			String itemTypeID = getSelectedItemType(info).id;
+			String itemTypeID = itemType.id;
 			int quantity = player.inventory.getItemQuantity(itemTypeID);
 			if (quantity > 1) {
 				Intent intent = Dialogs.getIntentForBulkDroppingInterface(getActivity(), itemTypeID, quantity);
@@ -249,11 +349,9 @@ public final class HeroinfoActivity_Inventory extends Fragment {
 			}
 			break;
 		case R.id.inv_menu_equip:
-			itemType = getSelectedItemType(info);
 			controllers.itemController.equipItem(itemType, itemType.category.inventorySlot);
 			break;
 		case R.id.inv_menu_equip_offhand:
-			itemType = getSelectedItemType(info);
 			if (itemType.category.inventorySlot == Inventory.WearSlot.weapon) {
 				controllers.itemController.equipItem(itemType, Inventory.WearSlot.shield);
 			} else if (itemType.category.inventorySlot == Inventory.WearSlot.leftring) {
@@ -264,31 +362,28 @@ public final class HeroinfoActivity_Inventory extends Fragment {
 			context.mapController.unequipItem(this, getSelectedItemType(info));
 			break;*/
 		case R.id.inv_menu_use:
-			controllers.itemController.useItem(getSelectedItemType(info));
+			controllers.itemController.useItem(itemType);
 			break;
 		case R.id.inv_menu_assign:
-			lastSelectedItem = getSelectedItemType(info);
+			//lastSelectedItem = itemType;
 			break;
 		case R.id.inv_assign_slot1:
-			controllers.itemController.setQuickItem(lastSelectedItem, 0);
+			controllers.itemController.setQuickItem(itemType, 0);
 			break;
 		case R.id.inv_assign_slot2:
-			controllers.itemController.setQuickItem(lastSelectedItem, 1);
+			controllers.itemController.setQuickItem(itemType, 1);
 			break;
 		case R.id.inv_assign_slot3:
-			controllers.itemController.setQuickItem(lastSelectedItem, 2);
+			controllers.itemController.setQuickItem(itemType, 2);
 			break;
 		case R.id.inv_menu_movetop:
-			player.inventory.sortToTop(getSelectedItemType(info).id);
+			player.inventory.sortToTop(itemType.id);
 			break;
 		case R.id.inv_menu_movebottom:
-			player.inventory.sortToBottom(getSelectedItemType(info).id);
+			player.inventory.sortToBottom(itemType.id);
 			break;
-		default:
-			return super.onContextItemSelected(item);
 		}
 		update();
-		return true;
 	}
 
 	private void showEquippedItemInfo(ItemType itemType, Inventory.WearSlot inventorySlot) {
@@ -340,4 +435,56 @@ public final class HeroinfoActivity_Inventory extends Fragment {
 		Intent intent = Dialogs.getIntentForItemInfo(getActivity(), itemType.id, action, text, enabled, null);
 		startActivityForResult(intent, INTENTREQUEST_ITEMINFO);
 	}
-}
+
+	private void reloadShownCategory(int v) { // Apologies about the code duplication,
+		// just didn't seem to make sense as an array, although I did create a nice array for skill category adapters.
+
+		// Decide which category to show
+		if (v == 0) { //All items
+			inventoryList.setAdapter(inventoryListAdapter);
+			inventoryListAdapter.notifyDataSetChanged();
+		} else if (v == 1) { //Weapon items
+			inventoryWeaponsListAdapter = new ItemContainerAdapter(getActivity(), world.tileManager, player.inventory.buildWeaponItems(), player, wornTiles);
+			inventoryList.setAdapter(inventoryWeaponsListAdapter);
+			inventoryWeaponsListAdapter.notifyDataSetChanged();
+		} else if (v == 2) { //Armor items
+			inventoryArmorListAdapter = new ItemContainerAdapter(getActivity(), world.tileManager, player.inventory.buildArmorItems(), player, wornTiles);
+			inventoryList.setAdapter(inventoryArmorListAdapter);
+			inventoryArmorListAdapter.notifyDataSetChanged();
+		} else if (v == 3) { //Jewelry items
+			inventoryJewelryListAdapter = new ItemContainerAdapter(getActivity(), world.tileManager, player.inventory.buildJewelryItems(), player, wornTiles);
+			inventoryList.setAdapter(inventoryJewelryListAdapter);
+			inventoryJewelryListAdapter.notifyDataSetChanged();
+		} else if (v == 4) { //Potion items
+			inventoryPotionListAdapter = new ItemContainerAdapter(getActivity(), world.tileManager, player.inventory.buildPotionItems(), player, wornTiles);
+			inventoryList.setAdapter(inventoryPotionListAdapter);
+			inventoryPotionListAdapter.notifyDataSetChanged();
+		} else if (v == 5) { //Food items
+			inventoryFoodListAdapter = new ItemContainerAdapter(getActivity(), world.tileManager, player.inventory.buildFoodItems(), player, wornTiles);
+			inventoryList.setAdapter(inventoryFoodListAdapter);
+			inventoryFoodListAdapter.notifyDataSetChanged();
+		} else if (v == 6) { //Quest items
+			inventoryQuestListAdapter = new ItemContainerAdapter(getActivity(), world.tileManager, player.inventory.buildQuestItems(), player, wornTiles);
+			inventoryList.setAdapter(inventoryQuestListAdapter);
+			inventoryQuestListAdapter.notifyDataSetChanged();
+		} else if (v == 7) { //Other items
+			inventoryOtherListAdapter = new ItemContainerAdapter(getActivity(), world.tileManager, player.inventory.buildOtherItems(), player, wornTiles);
+			inventoryList.setAdapter(inventoryOtherListAdapter);
+			inventoryOtherListAdapter.notifyDataSetChanged();
+		}
+		//updateItemList();
+	}
+
+	private void reloadShownSort(Inventory inv) {
+		int selected = world.model.uiSelections.selectedInventorySort;
+
+		inventoryListAdapter.reloadShownSort(selected, world.model.uiSelections.oldSortSelection, player.inventory, player);
+
+		// Currently not functional, perhaps because selection only updates when changed.
+		if (world.model.uiSelections.oldSortSelection == selected)
+			world.model.uiSelections.oldSortSelection = 0;
+		else world.model.uiSelections.oldSortSelection = selected;
+		updateItemList();
+	}
+
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/fragment/HeroinfoActivity_Quests.java

@@ -1,5 +1,10 @@
 package com.gpl.rpg.AndorsTrail.activity.fragment;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
@@ -7,24 +12,25 @@ import android.support.v4.app.Fragment;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
-import android.widget.*;
-import android.widget.AdapterView.OnItemSelectedListener;
+import android.widget.ExpandableListView;
+import android.widget.SimpleExpandableListAdapter;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.model.actor.Player;
 import com.gpl.rpg.AndorsTrail.model.quest.Quest;
 import com.gpl.rpg.AndorsTrail.model.quest.QuestLogEntry;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import com.gpl.rpg.AndorsTrail.view.SpinnerEmulator;
 
 public final class HeroinfoActivity_Quests extends Fragment {
 
 	private WorldContext world;
-	private Spinner questlog_includecompleted;
+
+//	private Button includeCompletedButton;
+//	private Dialog includeCompletedDialog = null;
+//	private ListView questlog_includecompleted;
+	
 	private SimpleExpandableListAdapter questlog_contents_adapter;
 
 	private Player player;
@@ -42,27 +48,33 @@ public final class HeroinfoActivity_Quests extends Fragment {
 		this.player = world.model.player;
 	}
 
+	@Override
 	public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
 		View v = inflater.inflate(R.layout.questlog, container, false);
-
+		
+		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this.getActivity());
+		if (!app.isInitialized()) return v;
+		
 		Context ctx = getActivity();
 
-		questlog_includecompleted = (Spinner) v.findViewById(R.id.questlog_includecompleted);
-		ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(ctx, R.array.questlog_includecompleted, android.R.layout.simple_spinner_item);
-		adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
-		questlog_includecompleted.setAdapter(adapter);
-		questlog_includecompleted.setOnItemSelectedListener(new OnItemSelectedListener() {
+		
+		new SpinnerEmulator(v, R.id.questlog_includecompleted_button, R.array.questlog_includecompleted, R.string.questlog_includecompleted_prompt) {
 			@Override
-			public void onItemSelected(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
-				world.model.uiSelections.selectedQuestFilter = questlog_includecompleted.getSelectedItemPosition();
+			public void setValue(int value) {
+				world.model.uiSelections.selectedQuestFilter = value;
+			}
+			
+			@Override
+			public void selectionChanged(int value) {
 				reloadQuests();
 			}
-
+			
 			@Override
-			public void onNothingSelected(AdapterView<?> arg0) {}
-		});
-		questlog_includecompleted.setSelection(world.model.uiSelections.selectedQuestFilter);
-
+			public int getValue() {
+				return world.model.uiSelections.selectedQuestFilter;
+			}
+		};
+		
 		ExpandableListView questlog_contents = (ExpandableListView) v.findViewById(R.id.questlog_contents);
 		questlog_contents_adapter = new SimpleExpandableListAdapter(
 				ctx
@@ -104,43 +116,47 @@ public final class HeroinfoActivity_Quests extends Fragment {
 		groupList.clear();
 		childList.clear();
 
-		for (Quest q : world.quests.getAllQuests()) {
+		for (String questProgressID : player.getAllQuestProgressIDs()) {
+			Quest q = world.quests.getQuest(questProgressID);
+			if (q == null) continue; // This should not happen
 			if (!q.showInLog) continue; // Do not show
-			if (player.hasAnyQuestProgress(q.questID)) {
-				boolean isCompleted = q.isCompleted(player);
+			boolean isCompleted = q.isCompleted(player);
 
-				int v = questlog_includecompleted.getSelectedItemPosition();
-				if (v == 0) { // Hide completed quests
-					if (isCompleted) continue;
-				} else if (v == 1) { // Include completed quests
-					// Always show.
-				} else if (v == 2) { // Only completed quests
-					if (!isCompleted) continue;
-				}
+			int v = world.model.uiSelections.selectedQuestFilter;
+			if (v == 0) { // Active quests
+				if (isCompleted) continue;
+			} else if (v == 1) { // All quests
+				// Always show.
+			} else if (v == 2) { // Completed quests
+				if (!isCompleted) continue;
+			}
 
-				int statusResId;
-				if (isCompleted) {
-					statusResId = R.string.questlog_queststatus_completed;
-				} else {
-					statusResId = R.string.questlog_queststatus_inprogress;
-				}
+			int statusResId;
+			if (isCompleted) {
+				statusResId = R.string.questlog_queststatus_completed;
+			} else {
+				statusResId = R.string.questlog_queststatus_inprogress;
+			}
 
-				Map<String, Object> item = new HashMap<String, Object>();
-				item.put(mn_questName, q.name);
-				item.put(mn_questStatus, getString(R.string.questlog_queststatus, getString(statusResId)));
-				groupList.add(item);
+			Map<String, Object> item = new HashMap<String, Object>();
+			item.put(mn_questName, q.name);
+			item.put(mn_questStatus, getString(R.string.questlog_queststatus, getString(statusResId)));
+			groupList.add(item);
 
-				List<Map<String, ?>> logItemList = new ArrayList<Map<String, ?>>();
-				for (QuestLogEntry e : q.stages) {
-					if (e.logtext.length() <= 0) continue; // Do not show if displaytext is empty.
-					if (player.hasExactQuestProgress(q.questID, e.progress)) {
-						item = new HashMap<String, Object>();
-						item.put(mn_logText, e.logtext);
-						logItemList.add(item);
+			List<Map<String, ?>> logItemList = new ArrayList<Map<String, ?>>();
+			for(Integer progress : player.getQuestProgress(q.questID)) {
+				for(QuestLogEntry e : q.stages) {
+					if (e.progress == progress.intValue()) {
+						if (e.logtext.length() > 0) {
+							item = new HashMap<String, Object>();
+							item.put(mn_logText, e.logtext);
+							logItemList.add(item);
+						}
+						continue;
 					}
 				}
-				childList.add(logItemList);
 			}
+			childList.add(logItemList);
 		}
 		questlog_contents_adapter.notifyDataSetChanged();
 	}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/fragment/HeroinfoActivity_Skills.java

@@ -1,5 +1,7 @@
 package com.gpl.rpg.AndorsTrail.activity.fragment;
 
+import java.util.ArrayList;
+
 import android.app.Activity;
 import android.content.Intent;
 import android.os.Bundle;
@@ -11,6 +13,7 @@ import android.widget.AdapterView;
 import android.widget.AdapterView.OnItemClickListener;
 import android.widget.ListView;
 import android.widget.TextView;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.Dialogs;
 import com.gpl.rpg.AndorsTrail.R;
@@ -19,7 +22,7 @@ import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.model.ability.SkillCollection;
 import com.gpl.rpg.AndorsTrail.model.actor.Player;
 import com.gpl.rpg.AndorsTrail.view.SkillListAdapter;
-
+import com.gpl.rpg.AndorsTrail.view.SpinnerEmulator;
 public final class HeroinfoActivity_Skills extends Fragment {
 
 	private static final int INTENTREQUEST_SKILLINFO = 12;
@@ -28,8 +31,9 @@ public final class HeroinfoActivity_Skills extends Fragment {
 	private ControllerContext controllers;
 	private Player player;
 
-	private SkillListAdapter skillListAdapter;
 	private TextView listskills_number_of_increases;
+	ListView skillList;
+	private ArrayList<SkillListAdapter> skillListCategoryViewsAdapters = new ArrayList<SkillListAdapter>();
 
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
@@ -41,17 +45,60 @@ public final class HeroinfoActivity_Skills extends Fragment {
 		this.player = world.model.player;
 	}
 
+	@Override
 	public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
 		View v = inflater.inflate(R.layout.heroinfo_skill_list, container, false);
-
+		
+		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this.getActivity());
+		if (!app.isInitialized()) return v;
+		
 		final Activity ctx = getActivity();
-		skillListAdapter = new SkillListAdapter(ctx, world.skills.getAllSkills(), player);
-		ListView skillList = (ListView) v.findViewById(R.id.heroinfo_listskills_list);
-		skillList.setAdapter(skillListAdapter);
+
+		new SpinnerEmulator(v,R.id.skillList_category_filters_button, R.array.skill_category_filters, R.string.heroinfo_skill_categories) {
+			@Override
+			public void setValue(int value) {
+				world.model.uiSelections.selectedSkillCategory = value;
+			}
+			@Override
+			public void selectionChanged(int value) {
+				reloadShownCategory();
+			}
+			@Override
+			public int getValue() {
+				return world.model.uiSelections.selectedSkillCategory;
+			}
+		};
+		new SpinnerEmulator(v,R.id.skillList_sort_filters_button, R.array.skill_sort_filters, R.string.heroinfo_skill_sort) {
+			@Override
+			public void setValue(int value) {
+				world.model.uiSelections.selectedSkillSort = value;
+			}
+			@Override
+			public void selectionChanged(int value) {
+				reloadShownSort();
+			}
+			@Override
+			public int getValue() {
+				return world.model.uiSelections.selectedSkillSort;
+			}
+		};
+		
+
+		for(int i = 0; i< SkillCollection.SkillCategory.values().length; i++){
+			// Creates a list of adapters for each category.
+			// The adapter at position 0 has all items.
+			// length + 1 in order to create an extra position for "all"
+			skillListCategoryViewsAdapters.add(
+					new SkillListAdapter(ctx, world.skills.getAllSkills(), player, i));
+		}
+		
+		skillList = (ListView) v.findViewById(R.id.heroinfo_listskills_list);
+		skillList.setAdapter(getCurrentCategoryAdapter());
 		skillList.setOnItemClickListener(new OnItemClickListener() {
 			@Override
 			public void onItemClick(AdapterView<?> parent, View v, int position, long id) {
-				Intent intent = Dialogs.getIntentForSkillInfo(ctx, skillListAdapter.getItem(position).id);
+				Intent intent = Dialogs.getIntentForSkillInfo(ctx,
+						getCurrentCategoryAdapter().getItem(position).id);
 				startActivityForResult(intent, INTENTREQUEST_SKILLINFO);
 			}
 		});
@@ -59,6 +106,25 @@ public final class HeroinfoActivity_Skills extends Fragment {
 		return v;
 	}
 
+	private void reloadShownSort() {
+		int v = world.model.uiSelections.selectedSkillSort;
+		if(v==0) getCurrentCategoryAdapter().sortDefault();
+		if(v==1) getCurrentCategoryAdapter().sortByName();
+		if(v==2) getCurrentCategoryAdapter().sortByPoints();
+		if(v==3) getCurrentCategoryAdapter().sortByUnlocked();
+
+		updateSkillList();
+	}
+
+	private void reloadShownCategory() {
+		skillList.setAdapter(getCurrentCategoryAdapter());
+		updateSkillList();
+	}
+	private SkillListAdapter getCurrentCategoryAdapter(){
+		return skillListCategoryViewsAdapters.get(
+				world.model.uiSelections.selectedSkillCategory);
+	}
+
 	@Override
 	public void onStart() {
 		super.onStart();
@@ -95,6 +161,6 @@ public final class HeroinfoActivity_Skills extends Fragment {
 		} else {
 			listskills_number_of_increases.setVisibility(View.GONE);
 		}
-		skillListAdapter.notifyDataSetInvalidated();
+		getCurrentCategoryAdapter().notifyDataSetInvalidated();
 	}
-}
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/fragment/HeroinfoActivity_Stats.java

@@ -1,5 +1,7 @@
 package com.gpl.rpg.AndorsTrail.activity.fragment;
 
+import java.util.ArrayList;
+
 import android.content.Intent;
 import android.content.res.Resources;
 import android.os.Bundle;
@@ -12,32 +14,35 @@ import android.widget.Button;
 import android.widget.TableLayout;
 import android.widget.TableRow;
 import android.widget.TextView;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.Dialogs;
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
+import com.gpl.rpg.AndorsTrail.model.GameStatistics;
+import com.gpl.rpg.AndorsTrail.model.actor.HeroCollection;
 import com.gpl.rpg.AndorsTrail.model.actor.Player;
 import com.gpl.rpg.AndorsTrail.model.item.Inventory;
+import com.gpl.rpg.AndorsTrail.model.item.ItemTraits_OnHitReceived;
 import com.gpl.rpg.AndorsTrail.model.item.ItemTraits_OnUse;
 import com.gpl.rpg.AndorsTrail.model.item.ItemType;
 import com.gpl.rpg.AndorsTrail.view.ItemEffectsView;
 import com.gpl.rpg.AndorsTrail.view.RangeBar;
 import com.gpl.rpg.AndorsTrail.view.TraitsInfoView;
 
-import java.util.ArrayList;
-
 public final class HeroinfoActivity_Stats extends Fragment {
 
 	private static final int INTENTREQUEST_LEVELUP = 6;
 
 	private WorldContext world;
 	private Player player;
+	private GameStatistics statistics;
 
 	private View view;
 	private Button levelUpButton;
-	private TextView heroinfo_ap;
 	private TextView heroinfo_reequip_cost;
 	private TextView heroinfo_useitem_cost;
+	private TextView heroinfo_mode;
 	private TextView heroinfo_level;
 	private TextView heroinfo_totalexperience;
 	private TextView basetraitsinfo_max_hp;
@@ -46,10 +51,12 @@ public final class HeroinfoActivity_Stats extends Fragment {
 	private TextView heroinfo_base_useitem_cost;
 	private RangeBar rangebar_hp;
 	private RangeBar rangebar_exp;
+	private RangeBar rangebar_ap;
 	private ItemEffectsView actorinfo_onhiteffects;
 	private TableLayout heroinfo_basestats_table;
 	private ViewGroup heroinfo_container;
 
+
 	@Override
 	public void onCreate(Bundle savedInstanceState) {
 		super.onCreate(savedInstanceState);
@@ -57,6 +64,7 @@ public final class HeroinfoActivity_Stats extends Fragment {
 		if (!app.isInitialized()) return;
 		this.world = app.getWorld();
 		this.player = world.model.player;
+		this.statistics = world.model.statistics;
 	}
 
 	@Override
@@ -64,27 +72,36 @@ public final class HeroinfoActivity_Stats extends Fragment {
 		View v = inflater.inflate(R.layout.heroinfo_stats, container, false);
 		view = v;
 
+		AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(this.getActivity());
+		if (!app.isInitialized()) return v;
+		
 		TextView tv = (TextView) v.findViewById(R.id.heroinfo_title);
-		tv.setText(player.getName());
-		world.tileManager.setImageViewTile(getResources(), tv, player);
-
+		if (tv != null) {
+			tv.setText(player.getName());
+			tv.setCompoundDrawablesWithIntrinsicBounds(HeroCollection.getHeroLargeSprite(player.iconID), 0, 0, 0);
+		}
 		heroinfo_container = (ViewGroup) v.findViewById(R.id.heroinfo_container);
-		heroinfo_ap = (TextView) v.findViewById(R.id.heroinfo_ap);
 		heroinfo_reequip_cost = (TextView) v.findViewById(R.id.heroinfo_reequip_cost);
 		heroinfo_useitem_cost = (TextView) v.findViewById(R.id.heroinfo_useitem_cost);
 		basetraitsinfo_max_hp = (TextView) v.findViewById(R.id.basetraitsinfo_max_hp);
 		basetraitsinfo_max_ap = (TextView) v.findViewById(R.id.basetraitsinfo_max_ap);
 		heroinfo_base_reequip_cost = (TextView) v.findViewById(R.id.heroinfo_base_reequip_cost);
 		heroinfo_base_useitem_cost = (TextView) v.findViewById(R.id.heroinfo_base_useitem_cost);
+		heroinfo_mode = (TextView) v.findViewById(R.id.heroinfo_mode);
 		heroinfo_level = (TextView) v.findViewById(R.id.heroinfo_level);
 		heroinfo_totalexperience = (TextView) v.findViewById(R.id.heroinfo_totalexperience);
 		actorinfo_onhiteffects = (ItemEffectsView) v.findViewById(R.id.actorinfo_onhiteffects);
 		heroinfo_basestats_table = (TableLayout) v.findViewById(R.id.heroinfo_basestats_table);
 
 		rangebar_hp = (RangeBar) v.findViewById(R.id.heroinfo_healthbar);
-		rangebar_hp.init(R.drawable.ui_progress_health, R.string.status_hp);
+		rangebar_hp.init(R.drawable.ui_progress_health, R.string.heroinfo_healthpoints);
+		rangebar_hp.setLargeLabel(true);
 		rangebar_exp = (RangeBar) v.findViewById(R.id.heroinfo_expbar);
-		rangebar_exp.init(R.drawable.ui_progress_exp, R.string.status_exp);
+		rangebar_exp.init(R.drawable.ui_progress_exp, R.string.heroinfo_experiencepoints);
+		rangebar_exp.setLargeLabel(true);
+		rangebar_ap = (RangeBar) v.findViewById(R.id.heroinfo_apbar);
+		rangebar_ap.init(R.drawable.ui_progress_ap, R.string.heroinfo_actionpoints);
+		rangebar_ap.setLargeLabel(true);
 
 		levelUpButton = (Button) v.findViewById(R.id.heroinfo_levelup);
 		levelUpButton.setOnClickListener(new OnClickListener() {
@@ -126,10 +143,21 @@ public final class HeroinfoActivity_Stats extends Fragment {
 
 	private void updateTraits() {
 		final Resources res = getResources();
+		String mode = "";
+		if (statistics.hasUnlimitedLives() && statistics.hasUnlimitedSaves()) {
+			mode = res.getString(R.string.heroinfo_unlimited_lives_and_saves);
+		} else if (statistics.hasUnlimitedLives()) {
+			mode = res.getString(R.string.heroinfo_unlimited_lives);
+		} else if (statistics.getStartLives() == 1) {
+			mode = res.getString(R.string.heroinfo_one_life);
+		} else {
+			mode = res.getString(R.string.heroinfo_limited_lives, statistics.getLivesLeft(), statistics.getStartLives());
+		}
 
+		heroinfo_mode.setText(mode);
 		heroinfo_level.setText(Integer.toString(player.getLevel()));
 		heroinfo_totalexperience.setText(Integer.toString(player.getTotalExperience()));
-		heroinfo_ap.setText(player.getMaxAP() + "/" + player.getCurrentAP());
+//		heroinfo_ap.update(player.getMaxAP() + "/" + player.getCurrentAP());
 		heroinfo_reequip_cost.setText(Integer.toString(player.getReequipCost()));
 		heroinfo_useitem_cost.setText(Integer.toString(player.getUseItemCost()));
 		basetraitsinfo_max_hp.setText(Integer.toString(player.baseTraits.maxHP));
@@ -138,6 +166,7 @@ public final class HeroinfoActivity_Stats extends Fragment {
 		heroinfo_base_useitem_cost.setText(Integer.toString(player.baseTraits.useItemCost));
 		rangebar_hp.update(player.getMaxHP(), player.getCurrentHP());
 		rangebar_exp.update(player.getMaxLevelExperience(), player.getCurrentLevelExperience());
+		rangebar_ap.update(player.getMaxAP(), player.getCurrentAP());
 
 		TraitsInfoView.update(heroinfo_container, player);
 		TraitsInfoView.updateTraitsTable(
@@ -155,15 +184,18 @@ public final class HeroinfoActivity_Stats extends Fragment {
 
 		ArrayList<ItemTraits_OnUse> effects_hit = new ArrayList<ItemTraits_OnUse>();
 		ArrayList<ItemTraits_OnUse> effects_kill = new ArrayList<ItemTraits_OnUse>();
+		ArrayList<ItemTraits_OnHitReceived> effects_hitReceived = new ArrayList<ItemTraits_OnHitReceived>();
 		for (Inventory.WearSlot slot : Inventory.WearSlot.values()) {
 			ItemType type = player.inventory.getItemTypeInWearSlot(slot);
 			if (type == null) continue;
 			if (type.effects_hit != null) effects_hit.add(type.effects_hit);
 			if (type.effects_kill != null) effects_kill.add(type.effects_kill);
+			if (type.effects_hitReceived != null) effects_hitReceived.add(type.effects_hitReceived);
 		}
 		if (effects_hit.isEmpty()) effects_hit = null;
 		if (effects_kill.isEmpty()) effects_kill = null;
-		actorinfo_onhiteffects.update(null, null, effects_hit, effects_kill, false);
+		if (effects_hitReceived.isEmpty()) effects_hitReceived = null;
+		actorinfo_onhiteffects.update(null, null, effects_hit, effects_kill, effects_hitReceived, null, false);
 
 
 		updateStatsTableRow(world.model.statistics.getNumberOfCompletedQuests(world), R.id.heroinfo_gamestats_quests, R.id.heroinfo_gamestats_quests_row);

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/fragment/ShopActivityFragment.java

@@ -1,14 +1,18 @@
 package com.gpl.rpg.AndorsTrail.activity.fragment;
 
+import java.util.HashSet;
+
 import android.content.res.Resources;
 import android.os.Bundle;
 import android.support.v4.app.Fragment;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
+import android.widget.Button;
 import android.widget.ListView;
 import android.widget.TextView;
 import android.widget.Toast;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.Dialogs;
 import com.gpl.rpg.AndorsTrail.R;
@@ -18,10 +22,9 @@ import com.gpl.rpg.AndorsTrail.model.actor.Player;
 import com.gpl.rpg.AndorsTrail.model.item.ItemContainer;
 import com.gpl.rpg.AndorsTrail.resource.tiles.TileCollection;
 import com.gpl.rpg.AndorsTrail.view.ShopItemContainerAdapter;
+import com.gpl.rpg.AndorsTrail.view.SpinnerEmulator;
 import com.gpl.rpg.AndorsTrail.view.ShopItemContainerAdapter.OnContainerItemClickedListener;
 
-import java.util.HashSet;
-
 public abstract class ShopActivityFragment extends Fragment implements OnContainerItemClickedListener {
 
 	protected static final int INTENTREQUEST_ITEMINFO = 3;
@@ -33,6 +36,7 @@ public abstract class ShopActivityFragment extends Fragment implements OnContain
 	protected ItemContainer shopInventory;
 	private TextView shop_gc;
 	private ShopItemContainerAdapter listAdapter;
+	private Button shoplist_sort;
 
 	protected abstract boolean isSellingInterface();
 
@@ -66,9 +70,33 @@ public abstract class ShopActivityFragment extends Fragment implements OnContain
 		final boolean isSelling = isSellingInterface();
 		listAdapter = new ShopItemContainerAdapter(getActivity(), tiles, world.tileManager, player, isSelling ? player.inventory : shopInventory, this, isSelling);
 		shoplist.setAdapter(listAdapter);
+
+		//Initiating drop-down list for category filters
+		shoplist_sort = (Button) v.findViewById(R.id.shoplist_sort_filters);
+		new SpinnerEmulator(v, R.id.shoplist_sort_filters, R.array.shoplist_sort_filters, R.string.shop_item_sort) {
+			@Override
+			public void setValue(int value) {
+				world.model.uiSelections.selectedShopSort = value;
+			}
+			@Override
+			public void selectionChanged(int value) {
+				reloadShownSort(isSelling ? player.inventory : shopInventory);
+			}
+			@Override
+			public int getValue() {
+				return world.model.uiSelections.selectedShopSort;
+			}
+		};
+		
+
 		return v;
 	}
 
+	private void reloadShownSort(ItemContainer itemContainer) {
+		listAdapter.reloadShownSort(world.model.uiSelections.selectedShopSort, itemContainer, player);
+		listAdapter.notifyDataSetChanged();
+	}
+
 	@Override
 	public void onStart() {
 		super.onStart();

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/fragment/ShopActivity_Buy.java

@@ -2,6 +2,7 @@ package com.gpl.rpg.AndorsTrail.activity.fragment;
 
 import android.app.Activity;
 import android.content.Intent;
+
 import com.gpl.rpg.AndorsTrail.Dialogs;
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.activity.ItemInfoActivity;

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/fragment/ShopActivity_Sell.java

@@ -2,6 +2,7 @@ package com.gpl.rpg.AndorsTrail.activity.fragment;
 
 import android.app.Activity;
 import android.content.Intent;
+
 import com.gpl.rpg.AndorsTrail.Dialogs;
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.activity.ItemInfoActivity;

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/fragment/StartScreenActivity_MainMenu.java

@@ -0,0 +1,416 @@
+package com.gpl.rpg.AndorsTrail.activity.fragment;
+
+import android.Manifest;
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.ImageView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
+import com.gpl.rpg.AndorsTrail.AndorsTrailPreferences;
+import com.gpl.rpg.AndorsTrail.Dialogs;
+import com.gpl.rpg.AndorsTrail.R;
+import com.gpl.rpg.AndorsTrail.WorldSetup;
+import com.gpl.rpg.AndorsTrail.activity.AboutActivity;
+import com.gpl.rpg.AndorsTrail.activity.LoadingActivity;
+import com.gpl.rpg.AndorsTrail.activity.Preferences;
+import com.gpl.rpg.AndorsTrail.controller.Constants;
+import com.gpl.rpg.AndorsTrail.resource.tiles.TileManager;
+import com.gpl.rpg.AndorsTrail.savegames.Savegames;
+import com.gpl.rpg.AndorsTrail.savegames.Savegames.FileHeader;
+import com.gpl.rpg.AndorsTrail.util.AndroidStorage;
+import com.gpl.rpg.AndorsTrail.util.L;
+import com.gpl.rpg.AndorsTrail.util.ThemeHelper;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory;
+import com.gpl.rpg.AndorsTrail.view.CustomDialogFactory.CustomDialog;
+
+public class StartScreenActivity_MainMenu extends Fragment {
+
+    private static final int INTENTREQUEST_PREFERENCES = 7;
+    public static final int INTENTREQUEST_LOADGAME = 9;
+
+    private boolean hasExistingGame = false;
+    private Button startscreen_continue;
+    private Button startscreen_newgame;
+    private Button startscreen_load;
+    private ViewGroup save_preview_holder;
+    private ImageView save_preview_hero_icon;
+    private TextView save_preview_hero_desc;
+
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        updatePreferences(false);
+        super.onCreateView(inflater, container, savedInstanceState);
+
+
+		if (container != null) {
+			container.removeAllViews();
+		}
+		
+		View root = inflater.inflate(R.layout.startscreen_mainmenu, container, false);
+
+		save_preview_holder = (ViewGroup) root.findViewById(R.id.save_preview_holder);
+		save_preview_hero_icon = (ImageView) root.findViewById(R.id.save_preview_hero_icon);
+		save_preview_hero_desc = (TextView) root.findViewById(R.id.save_preview_hero_desc);
+
+
+		startscreen_continue = (Button) root.findViewById(R.id.startscreen_continue);
+		startscreen_continue.setOnClickListener(new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				continueGame(false, Savegames.SLOT_QUICKSAVE, null);
+			}
+		});
+
+		startscreen_newgame = (Button) root.findViewById(R.id.startscreen_newgame);
+		startscreen_newgame.setOnClickListener(new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				if (hasExistingGame) {
+					comfirmNewGame();
+				} else {
+					createNewGame();
+				}
+			}
+		});
+
+		Button b = (Button) root.findViewById(R.id.startscreen_about);
+		b.setOnClickListener(new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				startActivity(new Intent(getActivity(), AboutActivity.class));
+			}
+		});
+
+		b = (Button) root.findViewById(R.id.startscreen_preferences);
+		b.setOnClickListener(new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				Intent intent = new Intent(getActivity(), Preferences.class);
+				StartScreenActivity_MainMenu.this.startActivityForResult(intent, INTENTREQUEST_PREFERENCES);
+			}
+		});
+
+		startscreen_load = (Button) root.findViewById(R.id.startscreen_load);
+		startscreen_load.setOnClickListener(new OnClickListener() {
+			@Override
+			public void onClick(View arg0) {
+				AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(getActivity());
+				if (hasExistingGame && app != null && app.getWorld() != null && app.getWorld().model != null
+						&& app.getWorld().model.statistics != null && !app.getWorld().model.statistics.hasUnlimitedSaves()) {
+					final CustomDialog d = CustomDialogFactory.createDialog(getActivity(),
+							getString(R.string.startscreen_load_game),
+							getResources().getDrawable(android.R.drawable.ic_delete),
+							getString(R.string.startscreen_load_game_confirm),
+							null,
+							true);
+					CustomDialogFactory.addButton(d, android.R.string.ok, new View.OnClickListener() {
+						@Override
+						public void onClick(View v) {
+							Dialogs.showLoad(StartScreenActivity_MainMenu.this);
+						}
+					});
+					CustomDialogFactory.addDismissButton(d, android.R.string.cancel);
+					CustomDialogFactory.show(d);
+
+				} else {
+					Dialogs.showLoad(StartScreenActivity_MainMenu.this);
+				}
+			}
+		});
+
+
+		if (AndorsTrailApplication.DEVELOPMENT_FORCE_STARTNEWGAME) {
+			if (AndorsTrailApplication.DEVELOPMENT_DEBUGRESOURCES) {
+				continueGame(true, 0, "Debug player");
+			} else {
+				continueGame(true, 0, "Player");
+			}
+		} else if (AndorsTrailApplication.DEVELOPMENT_FORCE_CONTINUEGAME) {
+			continueGame(false, Savegames.SLOT_QUICKSAVE, null);
+		}
+
+		// if it is a new version we first fire a welcome screen in onResume
+		// and afterwards check the permissions
+		if (!isNewVersion()) {
+			checkAndRequestPermissions(getActivity());
+			migrateDataOnDemand(getActivity());
+		}
+
+		return root;
+	}
+
+	@Override
+	public void onResume() {
+		super.onResume();
+
+		String playerName;
+		String displayInfo = null;
+		int iconID = TileManager.CHAR_HERO;
+		boolean isDead = false;
+
+		FileHeader header = Savegames.quickload(getActivity(), Savegames.SLOT_QUICKSAVE);
+		if (header != null && header.playerName != null) {
+			playerName = header.playerName;
+			displayInfo = header.displayInfo;
+			iconID = header.iconID;
+			isDead = header.isDead;
+		} else {
+			// Before fileversion 14 (v0.6.7), quicksave was stored in Shared preferences
+			SharedPreferences p = getActivity().getSharedPreferences("quicksave", Activity.MODE_PRIVATE);
+			playerName = p.getString("playername", null);
+			if (playerName != null) {
+				displayInfo = "level " + p.getInt("level", -1);
+			}
+		}
+		hasExistingGame = (playerName != null);
+		setButtonState(playerName, displayInfo, iconID, isDead);
+
+		if (isNewVersion()) {
+			Dialogs.showNewVersion(getActivity(), new DialogInterface.OnDismissListener() {
+				@Override
+				public void onDismiss(DialogInterface arg0) {
+					setCurrentVersionForVersionCheck();
+					checkAndRequestPermissions(getActivity());
+					migrateDataOnDemand(getActivity());
+				}
+			});
+		}
+
+	}
+
+	@TargetApi(29)
+	public void migrateDataOnDemand(final Activity activity) {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+			if (activity.getApplicationContext().checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {
+				if (AndroidStorage.shouldMigrateToInternalStorage(activity.getApplicationContext())) {
+					final CustomDialog d = CustomDialogFactory.createDialog(activity,
+							getString(R.string.startscreen_migration_title),
+							activity.getResources().getDrawable(android.R.drawable.ic_dialog_alert),
+							getString(R.string.startscreen_migration_text),
+							null,
+							true);
+					CustomDialogFactory.addDismissButton(d, android.R.string.ok);
+					CustomDialogFactory.show(d);
+					if (!AndroidStorage.migrateToInternalStorage(activity.getApplicationContext())) {
+						final CustomDialog errorDlg = CustomDialogFactory.createDialog(activity,
+								getString(R.string.startscreen_migration_title),
+								activity.getResources().getDrawable(android.R.drawable.ic_dialog_alert),
+								getString(R.string.startscreen_migration_failure),
+								null,
+								true);
+						CustomDialogFactory.addDismissButton(errorDlg, android.R.string.ok);
+						d.cancel();
+						CustomDialogFactory.show(errorDlg);
+					}
+				} else {
+					L.log("INFO: No external files or destination folder ist not empty. No data migration.");
+				}
+			} else {
+				L.log("INFO: No read permission on external folder. No data migration.");
+			}
+		}
+	}
+
+	private static final int READ_EXTERNAL_STORAGE_REQUEST=1;
+	private static final int WRITE_EXTERNAL_STORAGE_REQUEST=2;
+
+	@TargetApi(23)
+	public static void checkAndRequestPermissions(final Activity activity) {
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && Build.VERSION.SDK_INT <= Build.VERSION_CODES.Q) {
+			if (activity.getApplicationContext().checkSelfPermission(Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
+				activity.requestPermissions(new String[] {Manifest.permission.READ_EXTERNAL_STORAGE}, READ_EXTERNAL_STORAGE_REQUEST);
+			}
+			if (activity.getApplicationContext().checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
+				activity.requestPermissions(new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE}, WRITE_EXTERNAL_STORAGE_REQUEST);
+			}
+		}
+	}
+
+	@Override
+	public void onAttach(Activity activity) {
+		super.onAttach(activity);
+		listener = (OnNewGameRequestedListener) activity;
+	}
+
+	@Override
+	public void onDetach() {
+		super.onDetach();
+		listener = null;
+	}
+
+	private void setButtonState(final String playerName, final String displayInfo, int iconID, boolean isDead) {
+		startscreen_continue.setEnabled(hasExistingGame && !isDead);
+		startscreen_newgame.setEnabled(true);
+		if (hasExistingGame) {
+			TileManager tm = AndorsTrailApplication.getApplicationFromActivity(getActivity()).getWorld().tileManager;
+			tm.setImageViewTileForPlayer(getResources(), save_preview_hero_icon, iconID);
+			save_preview_hero_desc.setText((isDead ? getString(R.string.rip_startscreen) : "") + playerName + ", " + displayInfo);
+			save_preview_holder.setVisibility(View.VISIBLE);
+		} else {
+			save_preview_holder.setVisibility(View.GONE);
+		}
+	}
+
+	private void continueGame(boolean createNewCharacter, int loadFromSlot, String name) {
+		final WorldSetup setup = AndorsTrailApplication.getApplicationFromActivity(getActivity()).getWorldSetup();
+		setup.createNewCharacter = createNewCharacter;
+		setup.loadFromSlot = loadFromSlot;
+		setup.newHeroName = name;
+		startActivity(new Intent(getActivity(), LoadingActivity.class));
+	}
+
+	private void comfirmNewGame() {
+//		new AlertDialog.Builder(new ContextThemeWrapper(getActivity(), R.style.AndorsTrailStyle_Dialog))
+//		.setTitle(R.string.startscreen_newgame)
+//		.setMessage(R.string.startscreen_newgame_confirm)
+//		.setIcon(android.R.drawable.ic_delete)
+//		.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
+//			@Override
+//			public void onClick(DialogInterface dialog, int which) {
+//				//continueGame(true);
+////				hasExistingGame = false;
+////				setButtonState(null, null, 0);
+//				createNewGame();
+//			}
+//		})
+//		.setNegativeButton(android.R.string.cancel, null)
+//		.create().show();
+//		
+//		
+		final CustomDialog d = CustomDialogFactory.createDialog(getActivity(),
+				getString(R.string.startscreen_newgame),
+				getResources().getDrawable(android.R.drawable.ic_delete),
+				getResources().getString(R.string.startscreen_newgame_confirm),
+				null,
+				true);
+		CustomDialogFactory.addButton(d, android.R.string.ok, new View.OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				createNewGame();
+			}
+		});
+		CustomDialogFactory.addDismissButton(d, android.R.string.cancel);
+
+		CustomDialogFactory.show(d);
+
+	}
+
+	private static final String versionCheck = "lastversion";
+	private boolean isNewVersion() {
+		SharedPreferences s = getActivity().getSharedPreferences(Constants.PREFERENCE_MODEL_LASTRUNVERSION, Activity.MODE_PRIVATE);
+		int lastversion = s.getInt(versionCheck, 0);
+		if (lastversion >= AndorsTrailApplication.CURRENT_VERSION) return false;
+		return true;
+	}
+
+	private void setCurrentVersionForVersionCheck() {
+		SharedPreferences s = getActivity().getSharedPreferences(Constants.PREFERENCE_MODEL_LASTRUNVERSION, Activity.MODE_PRIVATE);
+		Editor e = s.edit();
+		e.putInt(versionCheck, AndorsTrailApplication.CURRENT_VERSION);
+		e.commit();
+	}
+
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+        switch (requestCode) {
+            case INTENTREQUEST_LOADGAME:
+				boolean unsuccessful = resultCode != Activity.RESULT_OK;
+				if(data == null) break;
+
+                final boolean wasImportOrExport = data.getBooleanExtra("import_export", false);
+                if (wasImportOrExport) {
+					String message = getImportExportMessage(!unsuccessful, data);
+					Toast.makeText(getActivity(), message, Toast.LENGTH_LONG).show();
+					break;
+				}
+				if (unsuccessful) break;
+                final int slot = data.getIntExtra("slot", 1);
+                continueGame(false, slot, null);
+                break;
+            case INTENTREQUEST_PREFERENCES:
+                updatePreferences(true);
+                break;
+        }
+    }
+
+	private String getImportExportMessage(boolean successful, Intent data) {
+		String message = "";
+		boolean isImportWorldmap = data.getBooleanExtra("import_worldmap", false);
+		boolean isImportSaves = data.getBooleanExtra("import_savegames", false);
+		boolean isExport = data.getBooleanExtra("export", false);
+
+		if(isImportWorldmap) {
+			message = getString(successful ? R.string.loadsave_import_worldmap_successfull : R.string.loadsave_import_worldmap_unsuccessfull);
+		} else if(isImportSaves) {
+			message = getString(successful ? R.string.loadsave_import_save_successfull : R.string.loadsave_import_save_unsuccessfull);
+		} else if(isExport) {
+			message = getString(successful ? R.string.loadsave_export_successfull : R.string.loadsave_export_unsuccessfull);
+		}
+
+		return message;
+	}
+
+	private void updatePreferences(boolean alreadyStartedLoadingResources) {
+        AndorsTrailApplication app = AndorsTrailApplication.getApplicationFromActivity(getActivity());
+        AndorsTrailPreferences preferences = app.getPreferences();
+        preferences.read(getActivity());
+        if (app.setLocale(getActivity())) {
+            if (alreadyStartedLoadingResources) {
+                // Changing the locale after having loaded the game requires resources to
+                // be re-loaded. Therefore, we just exit here.
+                Toast.makeText(getActivity(), R.string.change_locale_requires_restart, Toast.LENGTH_LONG).show();
+                doFinish();
+                return;
+            }
+        }
+        if (ThemeHelper.changeTheme(preferences.selectedTheme)) {
+            // Changing the theme requires a restart to re-create all activities.
+            Toast.makeText(getActivity(), R.string.change_theme_requires_restart, Toast.LENGTH_LONG).show();
+            doFinish();
+            return;
+        }
+        app.getWorld().tileManager.updatePreferences(preferences);
+    }
+
+    @SuppressLint("NewApi")
+    private void doFinish() {
+        //For Lollipop and above
+        ((AndorsTrailApplication) getActivity().getApplication()).discardWorld();
+        getActivity().finish();
+    }
+
+
+	public interface OnNewGameRequestedListener {
+		public void onNewGameRequested();
+	}
+
+	private OnNewGameRequestedListener listener = null;
+
+	private void createNewGame() {
+		if (listener != null) {
+			listener.onNewGameRequested();
+		}
+	}
+
+
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/activity/fragment/StartScreenActivity_NewGame.java

@@ -0,0 +1,181 @@
+package com.gpl.rpg.AndorsTrail.activity.fragment;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.RadioGroup;
+import android.widget.RadioGroup.OnCheckedChangeListener;
+import android.widget.TextView;
+import android.widget.Toast;
+import android.widget.ToggleButton;
+
+import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
+import com.gpl.rpg.AndorsTrail.R;
+import com.gpl.rpg.AndorsTrail.WorldSetup;
+import com.gpl.rpg.AndorsTrail.activity.LoadingActivity;
+import com.gpl.rpg.AndorsTrail.resource.tiles.TileManager;
+import com.gpl.rpg.AndorsTrail.view.SpinnerEmulator;
+
+public class StartScreenActivity_NewGame extends Fragment {
+
+	private TextView startscreen_enterheroname;
+	
+	private int selectedIconID = TileManager.CHAR_HERO;
+	private int startLives = -1;
+	private boolean unlimitedSaves = true;
+	
+	@Override
+	public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+		super.onCreateView(inflater, container, savedInstanceState);
+
+		if (container != null) {
+			container.removeAllViews();
+		}
+		
+		View root = inflater.inflate(R.layout.startscreen_newgame, container, false);
+		
+		
+		startscreen_enterheroname = (TextView) root.findViewById(R.id.startscreen_enterheroname);
+
+		new SpinnerEmulator(root, R.id.startscreen_mode_selector_button, R.array.startscreen_mode_selector, R.string.startscreen_game_mode) {
+			@Override
+			public void setValue(int value) {
+				if (value == 0) {
+					startLives = -1;
+					unlimitedSaves = true;
+				} else {
+					unlimitedSaves = false;
+					if (value == 1) {
+						startLives = -1;
+					} else if (value == 2) {
+						startLives = 50;
+					} else if (value == 3) {
+						startLives = 10;
+					} else if (value == 4) {
+						startLives = 3;
+					} else {
+						startLives = 1;
+					}
+				}
+			}
+
+			@Override
+			public void selectionChanged(int value) {
+
+			}
+
+			@Override
+			public int getValue() {
+				return 0;
+			}
+		};
+
+		final RadioGroup group = (RadioGroup) root.findViewById(R.id.newgame_spritegroup);
+		group.setOnCheckedChangeListener(new OnCheckedChangeListener() {
+			
+			@Override
+			public void onCheckedChanged(RadioGroup group, int checkedId) {
+				for (int i = 0; i < group.getChildCount(); i++) {
+					ToggleButton tb = ((ToggleButton)group.getChildAt(i));
+					tb.setChecked(tb.getId() == checkedId);
+				}
+				switch (checkedId) {
+				case R.id.newgame_sprite0:
+					selectedIconID = TileManager.CHAR_HERO_0;
+					break;
+				case R.id.newgame_sprite1:
+					selectedIconID = TileManager.CHAR_HERO_1;
+					break;
+				case R.id.newgame_sprite2:
+					selectedIconID = TileManager.CHAR_HERO_2;
+					break;
+				}
+			}
+		});
+		
+		OnClickListener l = new OnClickListener() {
+			
+			@Override
+			public void onClick(View v) {
+				group.check(v.getId());
+			}
+		};
+		
+		for (int i = 0; i < group.getChildCount(); i++) {
+			ToggleButton tb = ((ToggleButton)group.getChildAt(i));
+			tb.setOnClickListener(l);
+		}
+		
+		Button b = (Button) root.findViewById(R.id.startscreen_newgame_start);
+		b.setOnClickListener(new OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				createNewGame();
+			}
+		});
+		
+		b = (Button) root.findViewById(R.id.startscreen_newgame_cancel);
+		b.setOnClickListener(new OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				gameCreationOver();
+			}
+		});
+		
+		return root;
+	}
+	
+	@Override
+	public void onAttach(Activity activity) {
+		super.onAttach(activity);
+		listener = (GameCreationOverListener) activity;
+	}
+	
+	@Override
+	public void onDetach() {
+		super.onDetach();
+		listener = null;
+	}
+	
+	
+	private void continueGame(boolean createNewCharacter, int loadFromSlot, String name) {
+		final WorldSetup setup = AndorsTrailApplication.getApplicationFromActivity(getActivity()).getWorldSetup();
+		setup.createNewCharacter = createNewCharacter;
+		setup.loadFromSlot = loadFromSlot;
+		setup.newHeroName = name;
+		setup.newHeroIcon = selectedIconID;
+		setup.newHeroStartLives = startLives;
+		setup.newHeroUnlimitedSaves = unlimitedSaves;
+		gameCreationOver();
+		startActivity(new Intent(getActivity(), LoadingActivity.class));
+	}
+
+	private void createNewGame() {
+		String name = startscreen_enterheroname.getText().toString().trim();
+		if (name == null || name.length() <= 0) {
+			Toast.makeText(getActivity(), R.string.startscreen_enterheroname, Toast.LENGTH_SHORT).show();
+			return;
+		}
+		continueGame(true, 0, name);
+	}
+	
+	public interface GameCreationOverListener {
+		public void onGameCreationCancelled();
+	}
+	
+	private GameCreationOverListener listener = null;
+	
+	private void gameCreationOver() {
+		if (listener != null) {
+			listener.onGameCreationCancelled();
+		}
+	}
+	
+	
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/context/ControllerContext.java

@@ -1,11 +1,24 @@
 package com.gpl.rpg.AndorsTrail.context;
 
+import java.lang.ref.WeakReference;
+
+import android.content.Context;
 import android.content.res.Resources;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.AndorsTrailPreferences;
-import com.gpl.rpg.AndorsTrail.controller.*;
-
-import java.lang.ref.WeakReference;
+import com.gpl.rpg.AndorsTrail.controller.ActorStatsController;
+import com.gpl.rpg.AndorsTrail.controller.CombatController;
+import com.gpl.rpg.AndorsTrail.controller.ConversationController;
+import com.gpl.rpg.AndorsTrail.controller.GameRoundController;
+import com.gpl.rpg.AndorsTrail.controller.InputController;
+import com.gpl.rpg.AndorsTrail.controller.ItemController;
+import com.gpl.rpg.AndorsTrail.controller.MapController;
+import com.gpl.rpg.AndorsTrail.controller.MonsterMovementController;
+import com.gpl.rpg.AndorsTrail.controller.MonsterSpawningController;
+import com.gpl.rpg.AndorsTrail.controller.MovementController;
+import com.gpl.rpg.AndorsTrail.controller.SkillController;
+import com.gpl.rpg.AndorsTrail.controller.VisualEffectController;
 
 public final class ControllerContext {
 	//Controllers
@@ -46,4 +59,5 @@ public final class ControllerContext {
 	public Resources getResources() {
 		return app.get().getResources();
 	}
+	public Context getContext() {return app.get().getApplicationContext(); }
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/context/WorldContext.java

@@ -59,7 +59,7 @@ public final class WorldContext {
 		this.actorConditionsTypes = copy.actorConditionsTypes;
 		this.skills = copy.skills;
 	}
-	public void reset() {
-		maps.reset();
+	public void resetForNewGame() {
+		maps.resetForNewGame();
 	}
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/ActorStatsController.java

@@ -1,9 +1,13 @@
 package com.gpl.rpg.AndorsTrail.controller;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import com.gpl.rpg.AndorsTrail.context.ControllerContext;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.controller.listeners.ActorConditionListeners;
 import com.gpl.rpg.AndorsTrail.controller.listeners.ActorStatsListeners;
+import com.gpl.rpg.AndorsTrail.controller.listeners.CombatActionListeners;
 import com.gpl.rpg.AndorsTrail.controller.listeners.PlayerStatsListeners;
 import com.gpl.rpg.AndorsTrail.model.ability.ActorCondition;
 import com.gpl.rpg.AndorsTrail.model.ability.ActorConditionEffect;
@@ -16,20 +20,20 @@ import com.gpl.rpg.AndorsTrail.model.actor.Monster;
 import com.gpl.rpg.AndorsTrail.model.actor.Player;
 import com.gpl.rpg.AndorsTrail.model.item.Inventory;
 import com.gpl.rpg.AndorsTrail.model.item.ItemTraits_OnEquip;
+import com.gpl.rpg.AndorsTrail.model.item.ItemTraits_OnHitReceived;
 import com.gpl.rpg.AndorsTrail.model.item.ItemTraits_OnUse;
 import com.gpl.rpg.AndorsTrail.model.item.ItemType;
 import com.gpl.rpg.AndorsTrail.model.map.MonsterSpawnArea;
 import com.gpl.rpg.AndorsTrail.model.map.PredefinedMap;
 import com.gpl.rpg.AndorsTrail.resource.VisualEffectCollection;
 
-import java.util.ArrayList;
-
 public final class ActorStatsController {
 	private final ControllerContext controllers;
 	private final WorldContext world;
 	public final ActorConditionListeners actorConditionListeners = new ActorConditionListeners();
 	public final ActorStatsListeners actorStatsListeners = new ActorStatsListeners();
 	public final PlayerStatsListeners playerStatsListeners = new PlayerStatsListeners();
+	public final CombatActionListeners combatActionListeners = new CombatActionListeners();
 
 	public ActorStatsController(ControllerContext controllers, WorldContext world) {
 		this.controllers = controllers;
@@ -49,6 +53,9 @@ public final class ActorStatsController {
 		if (equipEffects == null) return;
 		if (equipEffects.addedConditions == null) return;
 		for (ActorConditionEffect e : equipEffects.addedConditions) {
+			if (e.isImmunity()) {
+				removeActorConditionImmunity(player, e.conditionType, e.magnitude, ActorCondition.DURATION_FOREVER);
+			}
 			if (e.isRemovalEffect()) continue;
 			if (e.magnitude <= 0) continue;
 			if (e.conditionType.isStacking) {
@@ -93,16 +100,75 @@ public final class ActorStatsController {
 		}
 		removeStackableActorCondition(player, type, magnitude, duration);
 	}
+	
+
+	private void removeActorConditionImmunity(Player player, ActorConditionType type, int magnitude, int duration) {
+		for (Inventory.WearSlot slot : Inventory.WearSlot.values()) {
+			ItemType t = player.inventory.getItemTypeInWearSlot(slot);
+			if (t == null) continue;
+
+			ItemTraits_OnEquip equipEffects = t.effects_equip;
+			if (equipEffects == null) continue;
+			if (equipEffects.addedConditions == null) continue;
+			for (ActorConditionEffect e : equipEffects.addedConditions) {
+				if (!e.conditionType.conditionTypeID.equals(type.conditionTypeID)) continue;
+				if (!e.isImmunity()) continue;
+				if (e.duration != duration) continue;
+				// The player is wearing some other item that gives this immunity. It will not be removed now.
+				return;
+			}
+		}
+		for(int i = player.immunities.size() - 1; i >= 0; --i) {
+			ActorCondition c = player.immunities.get(i);
+			if (!type.conditionTypeID.equals(c.conditionType.conditionTypeID)) continue;
+			if (c.duration != duration) continue;
+
+			player.immunities.remove(i);
+			actorConditionListeners.onActorConditionImmunityRemoved(player, c);
+			break;
+		}
+		//Looking for still-equipped items that would reapply this actor condition.
+		List<ActorConditionEffect> toReapply = new ArrayList<ActorConditionEffect>();
+		for (Inventory.WearSlot slot : Inventory.WearSlot.values()) {
+			ItemType t = player.inventory.getItemTypeInWearSlot(slot);
+			if (t == null) continue;
+
+			ItemTraits_OnEquip equipEffects = t.effects_equip;
+			if (equipEffects == null) continue;
+			if (equipEffects.addedConditions == null) continue;
+			for (ActorConditionEffect e : equipEffects.addedConditions) {
+				if (!e.conditionType.conditionTypeID.equals(type.conditionTypeID)) continue;
+				//There's another immunity (a temporary one for example) active. No nned to keep looking.
+				if (e.isImmunity()) return;
+				// The player is wearing some other item that gives this formerly immune actor condition
+				toReapply.add(e);
+			}
+		}
+		for (ActorConditionEffect e : toReapply) {
+			applyActorCondition(player, e, ActorCondition.DURATION_FOREVER);
+		}
+	}	
 
 	public void applyActorCondition(Actor actor, ActorConditionEffect e) { applyActorCondition(actor, e, e.duration); }
 	private void applyActorCondition(Actor actor, ActorConditionEffect e, int duration) {
-		if (e.isRemovalEffect()) {
+		if (e.isImmunity()) {
+			removeAllConditionsOfType(actor, e.conditionType.conditionTypeID);
+			addActorConditionImmunity(actor, e, duration);
+		} else if (e.isRemovalEffect()) {
 			removeAllConditionsOfType(actor, e.conditionType.conditionTypeID);
 		} else if (e.magnitude > 0) {
-			if (e.conditionType.isStacking) {
-				addStackableActorCondition(actor, e, duration);
-			} else {
-				addNonStackableActorCondition(actor, e, duration);
+			boolean immune = false;
+			for (ActorCondition immunity : actor.immunities) {
+				if (e.conditionType.conditionTypeID.equals(immunity.conditionType.conditionTypeID)) {
+					immune = true;
+				}
+			}
+			if (!immune) {
+				if (e.conditionType.isStacking) {
+					addStackableActorCondition(actor, e, duration);
+				} else {
+					addNonStackableActorCondition(actor, e, duration);
+				}
 			}
 		}
 		recalculateActorCombatTraits(actor);
@@ -145,6 +211,23 @@ public final class ActorStatsController {
 		actor.conditions.add(c);
 		actorConditionListeners.onActorConditionAdded(actor, c);
 	}
+	
+	private void addActorConditionImmunity(Actor actor, ActorConditionEffect e, int duration) {
+		final ActorConditionType type = e.conditionType;
+
+		for(int i = actor.immunities.size() - 1; i >= 0; --i) {
+			ActorCondition c = actor.immunities.get(i);
+			if (!type.conditionTypeID.equals(c.conditionType.conditionTypeID)) continue;
+			if (c.duration >= duration) return;
+			// If the actor already has this immunity, but of a shorter duration, we replace the old immunity by the new, longer one.
+			actor.immunities.remove(i);
+			actorConditionListeners.onActorConditionRemoved(actor, c);
+		}
+
+		ActorCondition c = e.createCondition(duration);
+		actor.immunities.add(c);
+		actorConditionListeners.onActorConditionImmunityAdded(actor, c);
+	}
 
 	public void removeAllTemporaryConditions(final Actor actor) {
 		for(int i = actor.conditions.size() - 1; i >= 0; --i) {
@@ -178,6 +261,10 @@ public final class ActorStatsController {
 
 		addActorMoveCost(actor, effects.increaseMoveCost * multiplier);
 		addActorAttackCost(actor, effects.increaseAttackCost * multiplier);
+		if (actor.isPlayer) {
+			addPlayerReequipCost((Player)actor, effects.increaseReequipCost * multiplier);
+			addPlayerUseCost((Player)actor, effects.increaseUseItemCost * multiplier);
+		}
 		//criticalMultiplier should not be increased. It is always defined by the weapon in use.
 		actor.attackChance += effects.increaseAttackChance * multiplier;
 		actor.criticalSkill += effects.increaseCriticalSkill * multiplier;
@@ -185,34 +272,46 @@ public final class ActorStatsController {
 		actor.damagePotential.addToMax(effects.increaseMaxDamage * multiplier);
 		actor.blockChance += effects.increaseBlockChance * multiplier;
 		actor.damageResistance += effects.increaseDamageResistance * multiplier;
-
-		if (actor.attackChance < 0) actor.attackChance = 0;
-		if (actor.damagePotential.max < 0) actor.damagePotential.set(0, 0);
 	}
 
 	public void recalculatePlayerStats(Player player) {
+		player.weaponDamage.set(0,0);
 		player.resetStatsToBaseTraits();
 		player.recalculateLevelExperience();
 		controllers.itemController.applyInventoryEffects(player);
 		controllers.skillController.applySkillEffects(player);
 		applyEffectsFromCurrentConditions(player);
 		ItemController.recalculateHitEffectsFromWornItems(player);
+		ItemController.applyDamageModifier(player);
 		capActorHealthAtMax(player);
 		capActorAPAtMax(player);
+		lowCapActorAttackChance(player);
+		lowCapActorDamagePotential(player);
 	}
 	public void recalculateMonsterCombatTraits(Monster monster) {
 		monster.resetStatsToBaseTraits();
 		applyEffectsFromCurrentConditions(monster);
 		capActorHealthAtMax(monster);
 		capActorAPAtMax(monster);
+		lowCapActorAttackChance(monster);
+		lowCapActorDamagePotential(monster);
 	}
+
+	private void lowCapActorAttackChance(Actor actor) {
+		if (actor.attackChance < 0) actor.attackChance = 0;
+	}
+
+	private void lowCapActorDamagePotential(Actor actor) {
+		if (actor.damagePotential.max < 0) actor.damagePotential.set(0, 0);
+	}
+
 	private void recalculateActorCombatTraits(Actor actor) {
 		if (actor.isPlayer) recalculatePlayerStats((Player) actor);
 		else recalculateMonsterCombatTraits((Monster) actor);
 	}
 
 	public void applyConditionsToPlayer(Player player, boolean isFullRound) {
-		if (player.conditions.isEmpty()) return;
+		if (player.conditions.isEmpty() && player.immunities.isEmpty()) return;
 		if (!isFullRound) removeConditionsFromSkillEffects(player);
 
 		applyStatsEffects(player, isFullRound);
@@ -242,17 +341,26 @@ public final class ActorStatsController {
 	}
 
 	private static int getRandomConditionForRejuvenate(Player player) {
-		ArrayList<Integer> potentialConditions = new ArrayList<Integer>();
-		for(int i = 0; i < player.conditions.size(); ++i) {
-			ActorCondition c = player.conditions.get(i);
-			if (!c.isTemporaryEffect()) continue;
-			if (c.conditionType.isPositive) continue;
-			if (c.conditionType.conditionCategory == ActorConditionType.ConditionCategory.spiritual) continue;
-			potentialConditions.add(i);
-		}
-		if (potentialConditions.isEmpty()) return -1;
+		int i = -1;
+		int count = 0;
+		int potentialConditions[] = new int[player.conditions.size()];
+		for (ActorCondition c : player.conditions) {
+			i++;
 
-		return potentialConditions.get(Constants.rnd.nextInt(potentialConditions.size()));
+			if (!c.isTemporaryEffect())
+				continue;
+			if (c.conditionType.isPositive)
+				continue;
+			if (c.conditionType.conditionCategory == ActorConditionType.ConditionCategory.spiritual)
+				continue;
+
+			potentialConditions[count++] = i;
+		}
+
+		if (count == 0)
+			return -1;
+
+		return potentialConditions[Constants.rnd.nextInt(count)];
 	}
 
 	public void applyConditionsToMonsters(PredefinedMap map, boolean isFullRound) {
@@ -273,7 +381,7 @@ public final class ActorStatsController {
 			return;
 		}
 
-		decreaseDurationAndRemoveConditions(monster);
+		if (!isFullRound) decreaseDurationAndRemoveConditions(monster);
 	}
 
 	private void applyStatsEffects(Actor actor, boolean isFullRound) {
@@ -306,6 +414,44 @@ public final class ActorStatsController {
 				actorConditionListeners.onActorConditionDurationChanged(actor, c);
 			}
 		}
+		for(int i = actor.immunities.size() - 1; i >= 0; --i) {
+			ActorCondition c = actor.immunities.get(i);
+			if (!c.isTemporaryEffect()) continue;
+			if (c.duration <= 1) {
+				actor.immunities.remove(i);
+				actorConditionListeners.onActorConditionImmunityRemoved(actor, c);
+				removedAnyConditions = true;
+			} else {
+				c.duration -= 1;
+				actorConditionListeners.onActorConditionImmunityDurationChanged(actor, c);
+			}
+			if (actor instanceof Player) {
+				Player player = (Player) actor;
+				//Looking for still-equipped items that would reapply this actor condition.
+				List<ActorConditionEffect> toReapply = new ArrayList<ActorConditionEffect>();
+				for (Inventory.WearSlot slot : Inventory.WearSlot.values()) {
+					ItemType t = player.inventory.getItemTypeInWearSlot(slot);
+					if (t == null) continue;
+
+					ItemTraits_OnEquip equipEffects = t.effects_equip;
+					if (equipEffects == null) continue;
+					if (equipEffects.addedConditions == null) continue;
+					for (ActorConditionEffect e : equipEffects.addedConditions) {
+						if (!e.conditionType.conditionTypeID.equals(c.conditionType.conditionTypeID)) continue;
+						//There's another immunity (a temporary one for example) active. No need to keep looking.
+						if (e.isImmunity()) {
+							toReapply.clear();
+							break;
+						}
+						// The player is wearing some other item that gives this formerly immune actor condition
+						toReapply.add(e);
+					}
+				}
+				for (ActorConditionEffect e : toReapply) {
+					applyActorCondition(player, e, ActorCondition.DURATION_FOREVER);
+				}
+			}
+		}
 		if (removedAnyConditions) {
 			recalculateActorCombatTraits(actor);
 		}
@@ -331,12 +477,22 @@ public final class ActorStatsController {
 			controllers.effectController.startEnqueuedEffect(source.position);
 		}
 	}
+	
+	public void applyHitReceivedEffect(Actor source, Actor target, ItemTraits_OnHitReceived effect) {
+		applyUseEffect(source, target, effect);
+		if (effect.changedStats_target != null) {
+			applyStatsModifierEffect(target, effect.changedStats, 1);
+			controllers.effectController.startEnqueuedEffect(target.position);
+		}
+	}
 
 	private void rollForConditionEffect(Actor actor, ActorConditionEffect conditionEffect) {
 		int chanceRollBias = 0;
 		if (actor.isPlayer) chanceRollBias = SkillController.getActorConditionEffectChanceRollBias(conditionEffect, (Player) actor);
 
 		if (!Constants.rollResult(conditionEffect.chance, chanceRollBias)) return;
+		if (actor.isPlayer) combatActionListeners.onPlayerReceviesActorCondition(conditionEffect);
+		else combatActionListeners.onMonsterReceivesActorCondition(conditionEffect, (Monster)actor);
 		applyActorCondition(actor, conditionEffect);
 	}
 
@@ -383,6 +539,13 @@ public final class ActorStatsController {
 			applyUseEffect(player, null, type.effects_kill);
 		}
 	}
+	
+	public void applyOnDeathEffectsToPlayer(Player player, Actor monster) {
+		ItemTraits_OnUse onDeathEffect = monster.getOnDeathEffects();
+		if (onDeathEffect == null) return;
+		
+		applyUseEffect(player, null, onDeathEffect);
+	}
 
 	public void applySkillEffectsForNewRound(Player player, PredefinedMap currentMap) {
 		int level = player.getSkillLevel(SkillCollection.SkillID.regeneration);
@@ -394,6 +557,11 @@ public final class ActorStatsController {
 		}
 	}
 
+	public void addPlayerWeaponDamage(Player player, int increaseMinDamage, int increaseMaxDamage) {
+		player.weaponDamage.add(increaseMinDamage, true);
+		player.weaponDamage.addToMax(increaseMaxDamage);
+	}
+
 	public static enum LevelUpSelection {
 		health
 		,attackChance
@@ -456,6 +624,18 @@ public final class ActorStatsController {
 		if (actor.attackCost <= 0) actor.attackCost = 1;
 		actorStatsListeners.onActorAttackCostChanged(actor, actor.attackCost);
 	}
+	public void addPlayerReequipCost(Player player, int amount) {
+		if (amount == 0) return;
+		player.reequipCost += amount;
+		if (player.reequipCost < 0) player.reequipCost = 0;
+		actorStatsListeners.onPlayerReequipCostChanged(player, player.reequipCost);
+	}
+	public void addPlayerUseCost(Player player, int amount) {
+		if (amount == 0) return;
+		player.useItemCost += amount;
+		if (player.useItemCost < 0) player.useItemCost = 0;
+		actorStatsListeners.onPlayerUseCostChanged(player, player.useItemCost);
+	}
 
 	public void setActorMaxHealth(Actor actor) {
 		if (actor.health.isMax()) return;

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/CombatController.java

@@ -1,9 +1,12 @@
 package com.gpl.rpg.AndorsTrail.controller;
 
+import java.util.ArrayList;
+
 import android.os.Handler;
 import android.os.Message;
-import android.util.FloatMath;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailPreferences;
+import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.context.ControllerContext;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.controller.VisualEffectController.VisualEffectCompletedCallback;
@@ -15,13 +18,15 @@ import com.gpl.rpg.AndorsTrail.model.actor.Actor;
 import com.gpl.rpg.AndorsTrail.model.actor.Monster;
 import com.gpl.rpg.AndorsTrail.model.actor.MonsterType;
 import com.gpl.rpg.AndorsTrail.model.actor.Player;
+import com.gpl.rpg.AndorsTrail.model.item.ItemContainer;
+import com.gpl.rpg.AndorsTrail.model.item.ItemTraits_OnHitReceived;
 import com.gpl.rpg.AndorsTrail.model.item.ItemTraits_OnUse;
 import com.gpl.rpg.AndorsTrail.model.item.Loot;
 import com.gpl.rpg.AndorsTrail.model.map.MonsterSpawnArea;
 import com.gpl.rpg.AndorsTrail.resource.VisualEffectCollection;
 import com.gpl.rpg.AndorsTrail.util.Coord;
 
-import java.util.ArrayList;
+import static java.lang.Math.max;
 
 public final class CombatController implements VisualEffectCompletedCallback {
 	private final ControllerContext controllers;
@@ -54,10 +59,18 @@ public final class CombatController implements VisualEffectCompletedCallback {
 	public void exitCombat(boolean pickupLootBags) {
 		setCombatSelection(null, null);
 		world.model.uiSelections.isInCombat = false;
+		if (pickupLootBags) {
+			recordLootInCombatLog();
+		}
 		combatTurnListeners.onCombatEnded();
+		controllers.actorStatsController.setActorMaxAP(world.model.player);
 		world.model.uiSelections.selectedPosition = null;
 		world.model.uiSelections.selectedMonster = null;
-		controllers.gameRoundController.resetRoundTimers();
+		if (world.model.player.isDead()) {
+			controllers.gameRoundController.resetRoundTimers();
+		} else {
+			endOfCombatRound();
+		}
 		if (pickupLootBags && totalExpThisFight > 0) {
 			controllers.itemController.lootMonsterBags(killedMonsterBags, totalExpThisFight);
 		} else {
@@ -66,6 +79,31 @@ public final class CombatController implements VisualEffectCompletedCallback {
 		resetCombatState();
 	}
 
+	private void recordLootInCombatLog() {
+		Loot combinedLoot = Loot.combine(killedMonsterBags);
+		if (combinedLoot.gold > 0) {
+			world.model.combatLog.append(controllers.getResources().getString(R.string.dialog_loot_foundgold, combinedLoot.gold));
+		}
+		int itemCount = combinedLoot.items.countItems();
+		if (itemCount > 0) {
+			StringBuilder itemMessage = new StringBuilder();
+			if (itemCount == 1) {
+				itemMessage.append(controllers.getResources().getString(R.string.combat_log_item_single));
+			} else {
+				itemMessage.append(controllers.getResources().getString(R.string.combat_log_item_plural, itemCount));
+			}
+			boolean firstItem = true;
+			for (ItemContainer.ItemEntry entry : combinedLoot.items.items) {
+				if (!firstItem) {
+					itemMessage.append(";");
+				}
+				itemMessage.append(" " + entry.itemType.getName(world.model.player) + " (" + entry.quantity + ")");
+				firstItem = false;
+			}
+			world.model.combatLog.append(itemMessage.toString());
+		}
+	}
+
 	private void resetCombatState() {
 		killedMonsterBags.clear();
 		totalExpThisFight = 0;
@@ -78,7 +116,7 @@ public final class CombatController implements VisualEffectCompletedCallback {
 	}
 	public void setCombatSelection(Monster selectedMonster, Coord selectedPosition) {
 		if (selectedMonster != null) {
-			if (!selectedMonster.isAgressive()) return;
+			if (!selectedMonster.isAgressive(world.model.player)) return;
 		}
 		Coord previousSelection = world.model.uiSelections.selectedPosition;
 		if (previousSelection != null) {
@@ -102,10 +140,10 @@ public final class CombatController implements VisualEffectCompletedCallback {
 	}
 
 	public void setCombatSelection(Coord p) {
-		Monster m = world.model.currentMap.getMonsterAt(p);
+		Monster m = world.model.currentMaps.map.getMonsterAt(p);
 		if (m != null) {
 			setCombatSelection(m, p);
-		} else if (world.model.currentTileMap.isWalkable(p)) {
+		} else if (world.model.currentMaps.tileMap.isWalkable(p)) {
 			setCombatSelection(null, p);
 		}
 	}
@@ -121,7 +159,7 @@ public final class CombatController implements VisualEffectCompletedCallback {
 
 	public boolean canExitCombat() { return getAdjacentAggressiveMonster() == null; }
 	private Monster getAdjacentAggressiveMonster() {
-		return MovementController.getAdjacentAggressiveMonster(world.model.currentMap, world.model.player);
+		return MovementController.getAdjacentAggressiveMonster(world.model.currentMaps.map, world.model.player);
 	}
 
 	public void executeMoveAttack(int dx, int dy) {
@@ -148,7 +186,7 @@ public final class CombatController implements VisualEffectCompletedCallback {
 	private void executeFlee(int dx, int dy) {
 		// avoid monster fields when fleeing
 		if (!controllers.movementController.findWalkablePosition(dx, dy, AndorsTrailPreferences.MOVEMENTAGGRESSIVENESS_DEFENSIVE)) return;
-		Monster m = world.model.currentMap.getMonsterAt(world.model.player.nextPosition);
+		Monster m = world.model.currentMaps.map.getMonsterAt(world.model.player.nextPosition);
 		if (m != null) return;
 		executeCombatMove(world.model.player.nextPosition);
 	}
@@ -170,11 +208,14 @@ public final class CombatController implements VisualEffectCompletedCallback {
 				playerKilledMonster(target);
 			}
 
+			controllers.skillController.applySkillEffectsFromPlayerAttack(attack, target);
 			startAttackEffect(attack, attackPosition, this, CALLBACK_PLAYERATTACK);
 		} else {
 			combatActionListeners.onPlayerAttackMissed(target, attack);
-			playerAttackCompleted();
+			controllers.skillController.applySkillEffectsFromPlayerAttack(attack, target);
+			startMissedEffect(attack, attackPosition, this, CALLBACK_PLAYERATTACK);
 		}
+		
 	}
 
 	private void playerAttackCompleted() {
@@ -188,24 +229,26 @@ public final class CombatController implements VisualEffectCompletedCallback {
 	public void playerKilledMonster(Monster killedMonster) {
 		final Player player = world.model.player;
 
-		Loot loot = world.model.currentMap.getBagOrCreateAt(killedMonster.position);
+		Loot loot = world.model.currentMaps.map.getBagOrCreateAt(killedMonster.position);
 		killedMonster.createLoot(loot, player);
 
-		controllers.monsterSpawnController.remove(world.model.currentMap, killedMonster);
-		controllers.effectController.addSplatter(world.model.currentMap, killedMonster);
+		controllers.monsterSpawnController.remove(world.model.currentMaps.map, killedMonster);
+		controllers.effectController.addSplatter(world.model.currentMaps.map, killedMonster);
 
 		controllers.actorStatsController.addActorAP(player, player.getSkillLevel(SkillCollection.SkillID.cleave) * SkillCollection.PER_SKILLPOINT_INCREASE_CLEAVE_AP);
 		controllers.actorStatsController.addActorHealth(player, player.getSkillLevel(SkillCollection.SkillID.eater) * SkillCollection.PER_SKILLPOINT_INCREASE_EATER_HEALTH);
 
-		world.model.statistics.addMonsterKill(killedMonster.getMonsterTypeID());
+		world.model.statistics.addMonsterKill(killedMonster.monsterType);
 		controllers.actorStatsController.addExperience(loot.exp);
+		world.model.combatLog.append(controllers.getResources().getString(R.string.dialog_monsterloot_gainedexp, loot.exp));
 
 		totalExpThisFight += loot.exp;
 		loot.exp = 0;
 		controllers.actorStatsController.applyKillEffectsToPlayer(player);
+		controllers.actorStatsController.applyOnDeathEffectsToPlayer(player, killedMonster);
 
 		if (!loot.hasItemsOrGold()) {
-			world.model.currentMap.removeGroundLoot(loot);
+			world.model.currentMaps.map.removeGroundLoot(loot);
 		} else if (world.model.uiSelections.isInCombat) {
 			killedMonsterBags.add(loot);
 		}
@@ -227,7 +270,7 @@ public final class CombatController implements VisualEffectCompletedCallback {
 		return true;
 	}
 
-	private boolean playerHasApLeft() {
+	public boolean playerHasApLeft() {
 		final Player player = world.model.player;
 		if (player.hasAPs(player.getUseItemCost())) return true;
 		if (player.hasAPs(player.getAttackCost())) return true;
@@ -263,7 +306,7 @@ public final class CombatController implements VisualEffectCompletedCallback {
 		}
 
 		world.model.player.nextPosition.set(dest);
-		controllers.movementController.moveToNextIfPossible(false);
+		controllers.movementController.moveToNextIfPossible();
 
 		playerActionCompleted();
 	}
@@ -294,7 +337,7 @@ public final class CombatController implements VisualEffectCompletedCallback {
 	private void beginMonsterTurn(boolean isFirstRound) {
 		controllers.actorStatsController.setActorMinAP(world.model.player);
 		world.model.uiSelections.isPlayersCombatTurn = false;
-		for (MonsterSpawnArea a : world.model.currentMap.spawnAreas) {
+		for (MonsterSpawnArea a : world.model.currentMaps.map.spawnAreas) {
 			for (Monster m : a.monsters) {
 				controllers.actorStatsController.setActorMaxAP(m);
 			}
@@ -312,14 +355,14 @@ public final class CombatController implements VisualEffectCompletedCallback {
 			if (shouldAttackWithMonsterInCombat(currentActiveMonster, playerPosition)) return MonsterAction.attack;
 		}
 
-		for (MonsterSpawnArea a : world.model.currentMap.spawnAreas) {
+		for (MonsterSpawnArea a : world.model.currentMaps.map.spawnAreas) {
 			for (Monster m : a.monsters) {
-				if (!m.isAgressive()) continue;
+				if (!m.isAgressive(world.model.player)) continue;
 
 				if (shouldAttackWithMonsterInCombat(m, playerPosition)) {
 					currentActiveMonster = m;
 					return MonsterAction.attack;
-				} else if (shouldMoveMonsterInCombat(m, a, playerPosition)) {
+				} else if (shouldMoveMonsterInCombat(m, a, world.model.player, playerPosition)) {
 					currentActiveMonster = m;
 					return MonsterAction.move;
 				}
@@ -333,13 +376,13 @@ public final class CombatController implements VisualEffectCompletedCallback {
 		if (!m.rectPosition.isAdjacentTo(playerPosition)) return false;
 		return true;
 	}
-	private static boolean shouldMoveMonsterInCombat(Monster m, MonsterSpawnArea a, Coord playerPosition) {
+	private static boolean shouldMoveMonsterInCombat(Monster m, MonsterSpawnArea a, Player p, Coord playerPosition) {
 		final MonsterType.AggressionType movementAggressionType = m.getMovementAggressionType();
 		if (movementAggressionType == MonsterType.AggressionType.none) return false;
 
 		if (!m.hasAPs(m.getMoveCost())) return false;
 		if (m.position.isAdjacentTo(playerPosition)) return false;
-		if (!m.isAgressive()) return false;
+		if (!m.isAgressive(p)) return false;
 
 		if (movementAggressionType == MonsterType.AggressionType.protectSpawn) {
 			if (a.area.contains(playerPosition)) return true;
@@ -374,10 +417,16 @@ public final class CombatController implements VisualEffectCompletedCallback {
 			handleNextMonsterAction();
 			return;
 		}
-
-		controllers.monsterMovementController.moveMonsterToNextPosition(currentActiveMonster, world.model.currentMap);
-		combatActionListeners.onMonsterMovedDuringCombat(currentActiveMonster);
-		waitForNextMonsterAction();
+		
+		final Monster movingMonster = currentActiveMonster;
+		controllers.monsterMovementController.moveMonsterToNextPositionDuringCombat(currentActiveMonster, world.model.currentMaps.map, new VisualEffectController.VisualEffectCompletedCallback(){
+			@Override
+			public void onVisualEffectCompleted(int callbackValue) {
+				combatActionListeners.onMonsterMovedDuringCombat(movingMonster);
+				handleNextMonsterAction();
+			}
+		});
+		
 	}
 
 	private void attackWithCurrentMonster() {
@@ -389,12 +438,12 @@ public final class CombatController implements VisualEffectCompletedCallback {
 
 		if (attack.isHit) {
 			combatActionListeners.onMonsterAttackSuccess(currentActiveMonster, attack);
-
+			controllers.skillController.applySkillEffectsFromMonsterAttack(attack, currentActiveMonster);
 			startAttackEffect(attack, world.model.player.position, this, CALLBACK_MONSTERATTACK);
 		} else {
 			combatActionListeners.onMonsterAttackMissed(currentActiveMonster, attack);
-
-			waitForNextMonsterAction();
+			controllers.skillController.applySkillEffectsFromMonsterAttack(attack, currentActiveMonster);
+			startMissedEffect(attack, world.model.player.position, this, CALLBACK_MONSTERATTACK);
 		}
 	}
 
@@ -427,10 +476,25 @@ public final class CombatController implements VisualEffectCompletedCallback {
 		controllers.effectController.startEffect(
 				position
 				, VisualEffectCollection.VisualEffectID.redSplash
-				, attack.damage
+				, (attack.damage == 0) ? null : String.valueOf(attack.damage)
 				, callback
 				, callbackValue);
 	}
+	
+	private void startMissedEffect(AttackResult attack, final Coord position, VisualEffectCompletedCallback callback, int callbackValue) {
+		if (controllers.preferences.attackspeed_milliseconds <= 0) {
+			callback.onVisualEffectCompleted(callbackValue);
+			return;
+		}
+		controllers.effectController.startEffect(
+				position
+				, VisualEffectCollection.VisualEffectID.miss
+				, controllers.getResources().getString(R.string.combat_miss_animation_message)
+				, callback
+				, callbackValue);
+	}
+	
+	
 	private void endMonsterTurn() {
 		currentActiveMonster = null;
 		newPlayerTurn(false);
@@ -452,13 +516,29 @@ public final class CombatController implements VisualEffectCompletedCallback {
 		if (target.isImmuneToCriticalHits()) return false;
 		return true;
 	}
-	private static float getAverageDamagePerHit(Actor attacker, Actor target) {
-		float result = (float) (getAttackHitChance(attacker, target)) * attacker.getDamagePotential().average() / 100;
-		if (hasCriticalAttack(attacker, target)) {
-			result += (float) attacker.getEffectiveCriticalChance() * result * attacker.getCriticalMultiplier() / 100;
+
+	// see this post for explenations about the calculation: https://andorstrail.com/viewtopic.php?f=3&t=6661
+	// if you change code here make sure to run the tests in CombatControllerTest.java
+	public static float getAverageDamagePerHit(final Actor attacker, final Actor target) {
+		final int numPossibleOutcomes =  attacker.getDamagePotential().max - attacker.getDamagePotential().current + 1;
+		float avgNonCriticalDamage = 0;
+		for (int n = 0; n < numPossibleOutcomes; n++) {
+			avgNonCriticalDamage += max(0, (float) n + attacker.getDamagePotential().current - target.getDamageResistance()) / numPossibleOutcomes;
 		}
-		result -= target.getDamageResistance();
-		return result;
+
+		float avgCriticalDamage = 0;
+		float effectiveCriticalChance = 0;
+		if (hasCriticalAttack(attacker, target)) {
+			effectiveCriticalChance = attacker.getEffectiveCriticalChance();
+		}
+		if (effectiveCriticalChance > 0) {
+			for (int n = 0; n < numPossibleOutcomes; n++) {
+				avgCriticalDamage += max(0, Math.floor((n + attacker.getDamagePotential().current) * attacker.getCriticalMultiplier()) - target.getDamageResistance()) / numPossibleOutcomes;
+			}
+		}
+
+		float avgDamagePerSuccessfulStrike = (1 - effectiveCriticalChance / 100) * avgNonCriticalDamage + effectiveCriticalChance * avgCriticalDamage / 100;
+		return (float)getAttackHitChance(attacker, target) * avgDamagePerSuccessfulStrike / 100;
 	}
 	private static float getAverageDamagePerTurn(Actor attacker, Actor target) {
 		return getAverageDamagePerHit(attacker, target) * attacker.getAttacksPerTurn();
@@ -472,7 +552,7 @@ public final class CombatController implements VisualEffectCompletedCallback {
 
 		float averageDamagePerTurn = getAverageDamagePerTurn(attacker, target);
 		if (averageDamagePerTurn <= 0) return 100;
-		return (int) FloatMath.ceil(target.getMaxHP() / averageDamagePerTurn);
+		return (int) Math.ceil(target.getMaxHP() / averageDamagePerTurn);
 	}
 	public int getMonsterDifficulty(Monster monster) {
 		// returns [0..100) . 100 == easy.
@@ -487,13 +567,11 @@ public final class CombatController implements VisualEffectCompletedCallback {
 
 	private AttackResult playerAttacks(Monster currentMonster) {
 		AttackResult result = attack(world.model.player, currentMonster);
-		controllers.skillController.applySkillEffectsFromPlayerAttack(result, currentMonster);
 		return result;
 	}
 
 	private AttackResult monsterAttacks(Monster currentMonster) {
 		AttackResult result = attack(currentMonster, world.model.player);
-		controllers.skillController.applySkillEffectsFromMonsterAttack(result, currentMonster);
 		return result;
 	}
 
@@ -530,11 +608,24 @@ public final class CombatController implements VisualEffectCompletedCallback {
 
 	private void applyAttackHitStatusEffects(Actor attacker, Actor target) {
 		ItemTraits_OnUse[] onHitEffects = attacker.getOnHitEffects();
-		if (onHitEffects == null) return;
-
-		for (ItemTraits_OnUse e : onHitEffects) {
-			controllers.actorStatsController.applyUseEffect(attacker, target, e);
+		ItemTraits_OnHitReceived[] onHitReceivedEffects = target.getOnHitReceivedEffects();
+		if (onHitEffects != null) {
+			for (ItemTraits_OnUse e : onHitEffects) {
+				controllers.actorStatsController.applyUseEffect(attacker, target, e);
+			}
 		}
+		if (onHitReceivedEffects != null) {
+			for (ItemTraits_OnHitReceived e : onHitReceivedEffects) {
+				controllers.actorStatsController.applyHitReceivedEffect(target, attacker, e);
+			}
+		}
+	}
+
+	public void endOfCombatRound() {
+		world.model.worldData.tickWorldTime();
+		controllers.gameRoundController.resetRoundTimers();
+		controllers.actorStatsController.applyConditionsToPlayer(world.model.player, false);
+		controllers.actorStatsController.applyConditionsToMonsters(world.model.currentMaps.map, true);
 	}
 
 	public void monsterSteppedOnPlayer(Monster m) {

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/Constants.java

@@ -1,11 +1,11 @@
 package com.gpl.rpg.AndorsTrail.controller;
 
+import java.util.Random;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.util.ConstRange;
 import com.gpl.rpg.AndorsTrail.util.Range;
 
-import java.util.Random;
-
 public final class Constants {
 	public static final int PERCENT_EXP_LOST_WHEN_DIED = 30;
 	public static final int LEVELUP_EFFECT_HEALTH = 5;
@@ -19,11 +19,15 @@ public final class Constants {
 	public static final int EXP_FACTOR_DAMAGERESISTANCE = 9;
 	public static final float EXP_FACTOR_SCALING = 0.7f;
 	public static final int FLEE_FAIL_CHANCE_PERCENT = 20;
-	public static final long MINIMUM_INPUT_INTERVAL = AndorsTrailApplication.DEVELOPMENT_DEBUGBUTTONS ? 50 : 200;
-	public static final int MAX_MAP_WIDTH = 33;
-	public static final int MAX_MAP_HEIGHT = 33;
+	public static final long MINIMUM_INPUT_INTERVAL_FAST = 50;
+	public static final long MINIMUM_INPUT_INTERVAL_STD = 200;
+	//TODO restore final modifier before release
+	public static long MINIMUM_INPUT_INTERVAL = AndorsTrailApplication.DEVELOPMENT_FASTSPEED ? MINIMUM_INPUT_INTERVAL_FAST : MINIMUM_INPUT_INTERVAL_STD;
+	public static final int MAX_MAP_WIDTH = 46;
+	public static final int MAX_MAP_HEIGHT = 46;
 
 	public static final int MONSTER_MOVEMENT_TURN_DURATION_MS = 1200;
+	public static final int MONSTER_IMMOBILE_MOVE_COST = 999;
 
 	public static final int TICK_DELAY = 500;
 	private static final int ROUND_DURATION = 6000;
@@ -31,8 +35,9 @@ public final class Constants {
 	public static final int TICKS_PER_ROUND = ROUND_DURATION / TICK_DELAY;
 	public static final int TICKS_PER_FULLROUND = FULLROUND_DURATION / TICK_DELAY;
 	public static final int SPLATTER_DURATION_MS = 20000;
+	public static final int STATUS_TEXT_AUTOHIDE_DELAY = ROUND_DURATION;
 
-	public static final ConstRange monsterWaitTurns = new ConstRange(30,4);
+	public static final ConstRange monsterWaitTurns = new ConstRange(5,1);
 	public static final long MAP_UNVISITED_RESPAWN_DURATION_MS = 3 * 60 * 1000; // 3 min in milliseconds
 
 	public static final String PREFERENCE_MODEL_LASTRUNVERSION = "lastversion";
@@ -43,10 +48,16 @@ public final class Constants {
 	public static final String FILENAME_WORLDMAP_HTMLFILE_SUFFIX = ".html";
 	public static final String FILENAME_SAVEGAME_FILENAME_PREFIX = "savegame";
 	public static final String PLACEHOLDER_PLAYERNAME = "$playername";
+	public static final String CHEAT_DETECTION_FOLDER = "dEAGyGE3YojqXjI3x4x7";
+	public static final String PASSIVE_ACHIEVEMENT_CHECK_PHRASE = "passive_achievement_check";
+
+	public static final String SAVEGAME_FILE_MIME_TYPE = "application/octet-stream";
+	public static final String WORLDMAP_FILE_MIME_TYPE = "image/png";
+	public static final String NO_FILE_EXTENSION_MIME_TYPE = "application/no_file_extension_mime_type";
 
 	public static final Random rnd = new Random();
 	public static int rollValue(final ConstRange r) { return rollValue(r.max, r.current); }
-	public static int rollValue(final ConstRange r, int bias) { return rollValue(r.max, r.current + bias); }
+	public static int rollValue(final ConstRange r, int bias) { return rollValue((r.max + 1) * 100 -1, r.current * 100 + bias)/100; }
 	public static int rollValue(final Range r) { return rollValue(r.max, r.current); }
 	private static int rollValue(final int max, final int min) {
 		if (max <= min) return max;
@@ -54,7 +65,7 @@ public final class Constants {
 	}
 	public static boolean roll100(final int chance) { return rollResult(100, chance); }
 	public static boolean rollResult(final ConstRange r) { return rollResult(r.max, r.current); }
-	public static boolean rollResult(final ConstRange r, int bias) { return rollResult(r.max, r.current + bias); }
+	public static boolean rollResult(final ConstRange r, int bias) { return rollResult(r.max * 100, r.current * 100 + bias); }
 	public static boolean rollResult(final Range r) { return rollResult(r.max, r.current); }
 	private static boolean rollResult(final int probabilityMax, final int probabilityValue) { return rnd.nextInt(probabilityMax) < probabilityValue; }
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/ConversationController.java

@@ -0,0 +1,479 @@
+package com.gpl.rpg.AndorsTrail.controller;
+
+import java.util.ArrayList;
+
+import android.content.res.Resources;
+
+import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
+import com.gpl.rpg.AndorsTrail.context.ControllerContext;
+import com.gpl.rpg.AndorsTrail.context.WorldContext;
+import com.gpl.rpg.AndorsTrail.model.GameStatistics;
+import com.gpl.rpg.AndorsTrail.model.ability.ActorCondition;
+import com.gpl.rpg.AndorsTrail.model.ability.ActorConditionEffect;
+import com.gpl.rpg.AndorsTrail.model.ability.ActorConditionType;
+import com.gpl.rpg.AndorsTrail.model.ability.SkillCollection;
+import com.gpl.rpg.AndorsTrail.model.ability.SkillInfo;
+import com.gpl.rpg.AndorsTrail.model.actor.Actor;
+import com.gpl.rpg.AndorsTrail.model.actor.Monster;
+import com.gpl.rpg.AndorsTrail.model.actor.Player;
+import com.gpl.rpg.AndorsTrail.model.conversation.ConversationCollection;
+import com.gpl.rpg.AndorsTrail.model.conversation.Phrase;
+import com.gpl.rpg.AndorsTrail.model.conversation.Reply;
+import com.gpl.rpg.AndorsTrail.model.item.ItemTypeCollection;
+import com.gpl.rpg.AndorsTrail.model.item.Loot;
+import com.gpl.rpg.AndorsTrail.model.map.LayeredTileMap;
+import com.gpl.rpg.AndorsTrail.model.map.MonsterSpawnArea;
+import com.gpl.rpg.AndorsTrail.model.map.PredefinedMap;
+import com.gpl.rpg.AndorsTrail.model.quest.QuestLogEntry;
+import com.gpl.rpg.AndorsTrail.model.quest.QuestProgress;
+import com.gpl.rpg.AndorsTrail.model.script.Requirement;
+import com.gpl.rpg.AndorsTrail.model.script.ScriptEffect;
+import com.gpl.rpg.AndorsTrail.util.ConstRange;
+import com.gpl.rpg.AndorsTrail.util.L;
+
+public final class ConversationController {
+
+	private final ControllerContext controllers;
+	private final WorldContext world;
+
+	public ConversationController(ControllerContext controllers, WorldContext world) {
+		this.controllers = controllers;
+		this.world = world;
+	}
+
+	private static final ConstRange always = new ConstRange(1, 1);
+
+	public static final class ScriptEffectResult {
+		public final Loot loot = new Loot();
+		public final ArrayList<ActorConditionEffect> actorConditions = new ArrayList<ActorConditionEffect>();
+		public final ArrayList<SkillInfo> skillIncrease = new ArrayList<SkillInfo>();
+		public final ArrayList<QuestProgress> questProgress = new ArrayList<QuestProgress>();
+
+		public boolean isEmpty() {
+			if (loot.hasItemsOrExp()) return false;
+			if (!actorConditions.isEmpty()) return false;
+			if (!skillIncrease.isEmpty()) return false;
+			if (!questProgress.isEmpty()) return false;
+			return true;
+		}
+	}
+
+	private ScriptEffectResult applyScriptEffectsForPhrase(Resources res, final Player player, final Phrase phrase) {
+		if (phrase.scriptEffects == null || phrase.scriptEffects.length == 0) return null;
+
+		final ScriptEffectResult result = new ScriptEffectResult();
+		for (ScriptEffect effect : phrase.scriptEffects) {
+			applyScriptEffect(res, player, effect, result);
+		}
+
+		if (result.isEmpty()) return null;
+
+		player.inventory.add(result.loot);
+		controllers.actorStatsController.addExperience(result.loot.exp);
+
+		return result;
+	}
+
+	private void applyScriptEffect(Resources res, Player player, ScriptEffect effect, ScriptEffectResult result) {
+		switch (effect.type) {
+			case actorCondition:
+				addActorConditionReward(player, effect.effectID, effect.value, result);
+				break;
+			case actorConditionImmunity:
+				addActorConditionImmunityReward(player, effect.effectID, effect.value, result);
+				break;
+			case skillIncrease:
+				addSkillReward(player, SkillCollection.SkillID.valueOf(effect.effectID), result);
+				break;
+			case dropList:
+				addDropListReward(player, effect.effectID, result);
+				break;
+			case questProgress:
+				addQuestProgressReward(player, effect.effectID, effect.value, result);
+				break;
+			case alignmentChange:
+				addAlignmentReward(player, effect.effectID, effect.value);
+				break;
+			case alignmentSet:
+				setAlignmentReward(player, effect.effectID, effect.value);
+				break;
+			case giveItem:
+				addItemReward(effect.effectID, effect.value, result);
+				break;
+			case createTimer:
+				world.model.worldData.createTimer(effect.effectID);
+				break;
+			case spawnAll:
+				spawnAll(effect.mapName, effect.effectID);
+				break;
+			case removeSpawnArea:
+				deactivateSpawnArea(effect.mapName, effect.effectID, true);
+				break;
+			case deactivateSpawnArea:
+				deactivateSpawnArea(effect.mapName, effect.effectID, false);
+				break;
+			case activateMapObjectGroup:
+				activateMapObjectGroup(effect.mapName, effect.effectID);
+				break;
+			case deactivateMapObjectGroup:
+				deactivateMapObjectGroup(effect.mapName, effect.effectID);
+				break;
+			case removeQuestProgress:
+				addRemoveQuestProgressReward(player, effect.effectID, effect.value);
+				break;
+			case changeMapFilter:
+				changeMapFilter(res, effect.mapName, effect.effectID);
+				break;
+		}
+	}
+
+	private void changeMapFilter(Resources res, String mapName, String effectID) {
+		PredefinedMap map = findMapForScriptEffect(mapName);
+		map.currentColorFilter = effectID;
+		if (world.model.currentMaps.map == map) {
+			controllers.mapController.applyCurrentMapReplacements(res, true);
+		}
+	}
+	
+	private void deactivateMapObjectGroup(String mapName, String mapObjectGroupID) {
+		PredefinedMap map = findMapForScriptEffect(mapName);
+		controllers.mapController.deactivateMapObjectGroup(map, mapObjectGroupID);
+	}
+
+	private PredefinedMap findMapForScriptEffect(String mapName) {
+		if (mapName == null) return world.model.currentMaps.map;
+		return world.maps.findPredefinedMap(mapName);
+	}
+
+	private void activateMapObjectGroup(String mapName, String mapObjectGroupID) {
+		PredefinedMap map = findMapForScriptEffect(mapName);
+		controllers.mapController.activateMapObjectGroup(map, mapObjectGroupID);
+	}
+
+	private void spawnAll(String mapName, String areaId) {
+		PredefinedMap map = findMapForScriptEffect(mapName);
+		LayeredTileMap tileMap = null;
+		if (map == world.model.currentMaps.map) {
+			tileMap = world.model.currentMaps.tileMap;
+		}
+		for (MonsterSpawnArea area : map.spawnAreas) {
+			if (!area.areaID.equals(areaId)) continue;
+			controllers.monsterSpawnController.activateSpawnArea(map, tileMap, area, true);
+			controllers.effectController.asyncUpdateArea(area.area);
+		}
+	}
+
+	private void deactivateSpawnArea(String mapName, String areaID, boolean removeAllMonsters) {
+		PredefinedMap map = findMapForScriptEffect(mapName);
+		for (MonsterSpawnArea area : map.spawnAreas) {
+			if (!area.areaID.equals(areaID)) continue;
+			controllers.monsterSpawnController.deactivateSpawnArea(area, removeAllMonsters);
+			if (removeAllMonsters) controllers.effectController.asyncUpdateArea(area.area);
+		}
+	}
+
+	private void addAlignmentReward(Player player, String faction, int delta) {
+		player.addAlignment(faction, delta);
+		MovementController.refreshMonsterAggressiveness(world.model.currentMaps.map, world.model.player);
+	}
+
+	private void setAlignmentReward(Player player, String faction, int delta) {
+		player.setAlignment(faction, delta);
+		MovementController.refreshMonsterAggressiveness(world.model.currentMaps.map, world.model.player);
+	}
+
+	private void addQuestProgressReward(Player player, String questID, int questProgress, ScriptEffectResult result) {
+		QuestProgress progress = new QuestProgress(questID, questProgress);
+		boolean added = player.addQuestProgress(progress);
+
+		if (!added) return; // Only apply exp reward if the quest stage was reached just now (and not re-reached)
+
+		QuestLogEntry stage = world.quests.getQuestLogEntry(progress);
+		if (stage == null) return;
+
+		result.loot.exp += stage.rewardExperience;
+		result.questProgress.add(progress);
+	}
+
+	private void addRemoveQuestProgressReward(Player player, String questID, int questProgress) {
+        QuestProgress progress = new QuestProgress(questID, questProgress);
+		player.removeQuestProgress(progress);
+	}
+
+	private void addDropListReward(Player player, String droplistID, ScriptEffectResult result) {
+		world.dropLists.getDropList(droplistID).createRandomLoot(result.loot, player);
+	}
+
+	private void addItemReward(String itemTypeID, int quantity, ScriptEffectResult result) {
+		result.loot.add(world.itemTypes.getItemType(itemTypeID), quantity);
+	}
+
+	private void addSkillReward(Player player, SkillCollection.SkillID skillID, ScriptEffectResult result) {
+		SkillInfo skill = world.skills.getSkill(skillID);
+		boolean addedSkill = controllers.skillController.levelUpSkillByQuest(player, skill);
+		if (addedSkill) {
+			result.skillIncrease.add(skill);
+		}
+	}
+
+	private void addActorConditionReward(Player player, String conditionTypeID, int value, ScriptEffectResult result) {
+		int magnitude = 1;
+		int duration = value;
+		if (value == ActorCondition.DURATION_FOREVER) duration = ActorCondition.DURATION_FOREVER;
+		else if (value == ActorCondition.MAGNITUDE_REMOVE_ALL) {
+			duration = ActorCondition.DURATION_NONE;
+			magnitude = ActorCondition.MAGNITUDE_REMOVE_ALL;
+		}
+
+		ActorConditionType conditionType = world.actorConditionsTypes.getActorConditionType(conditionTypeID);
+		ActorConditionEffect e = new ActorConditionEffect(conditionType, magnitude, duration, always);
+		controllers.actorStatsController.applyActorCondition(player, e);
+		result.actorConditions.add(e);
+	}
+
+	private void addActorConditionImmunityReward(Player player, String conditionTypeID, int value, ScriptEffectResult result) {
+		int duration = value;
+		int magnitude = ActorCondition.MAGNITUDE_REMOVE_ALL;
+
+		ActorConditionType conditionType = world.actorConditionsTypes.getActorConditionType(conditionTypeID);
+		ActorConditionEffect e = new ActorConditionEffect(conditionType, magnitude, duration, always);
+		controllers.actorStatsController.applyActorCondition(player, e);
+		result.actorConditions.add(e);
+	}
+
+	private static void applyReplyEffect(final WorldContext world, final Reply reply, ControllerContext controllers) {
+		if (!reply.hasRequirements()) return;
+
+		for (Requirement requirement : reply.requires) {
+			requirementFulfilled(world, requirement, controllers);
+		}
+	}
+
+	private static boolean canSelectReply(final WorldContext world, final Reply reply) {
+		if (!reply.hasRequirements()) return true;
+
+		for (Requirement requirement : reply.requires) {
+			if (!canFulfillRequirement(world, requirement)) return false;
+		}
+		return true;
+	}
+
+	public static boolean canFulfillRequirement(WorldContext world, Requirement requirement) {
+		Player player = world.model.player;
+		GameStatistics stats = world.model.statistics;
+		boolean result;
+		switch (requirement.requireType) {
+			case questProgress:
+				result = player.hasExactQuestProgress(requirement.requireID, requirement.value);
+				break;
+			case questLatestProgress:
+				result = player.isLatestQuestProgress(requirement.requireID, requirement.value);
+				break;
+			case wear:
+			case wearRemove:
+				result =  player.inventory.isWearing(requirement.requireID, requirement.value);
+				break;
+			case inventoryKeep:
+			case inventoryRemove:
+				if (ItemTypeCollection.isGoldItemType(requirement.requireID)) {
+					result =  player.inventory.gold >= requirement.value;
+				} else {
+					result =  player.inventory.hasItem(requirement.requireID, requirement.value);
+				}
+				break;
+			case skillLevel:
+				result =  player.getSkillLevel(SkillCollection.SkillID.valueOf(requirement.requireID)) >= requirement.value;
+				break;
+			case killedMonster:
+				result =  stats.getNumberOfKillsForMonsterType(requirement.requireID) >= requirement.value;
+				break;
+			case timerElapsed:
+				result =  world.model.worldData.hasTimerElapsed(requirement.requireID, requirement.value);
+				break;
+			case usedItem:
+				result =  stats.getNumberOfTimesItemHasBeenUsed(requirement.requireID) >= requirement.value;
+				break;
+			case spentGold:
+				result =  stats.getSpentGold() >= requirement.value;
+				break;
+			case random:
+				result = Constants.rollResult(requirement.chance);
+				break;
+			case consumedBonemeals:
+				result =  stats.getNumberOfUsedBonemealPotions() >= requirement.value;
+				break;
+			case hasActorCondition:
+				result =  player.hasCondition(requirement.requireID);
+				break;
+			case factionScore:
+				result = player.getAlignment(requirement.requireID) >= requirement.value;
+				break;
+			case factionScoreEquals:
+				result = player.getAlignment(requirement.requireID) == requirement.value;
+				break;
+			default:
+				result =  true;
+		}
+		return requirement.negate ? !result : result;
+	}
+
+	public static void requirementFulfilled(WorldContext world, Requirement requirement, ControllerContext controllers) {
+		Player p = world.model.player;
+		switch (requirement.requireType) {
+			case inventoryRemove:
+				if (ItemTypeCollection.isGoldItemType(requirement.requireID)) {
+					p.inventory.gold -= requirement.value;
+					world.model.statistics.addGoldSpent(requirement.value);
+				} else {
+					p.inventory.removeItem(requirement.requireID, requirement.value);
+				}
+				break;
+            case wearRemove:
+                controllers.itemController.removeEquippedItem(requirement.requireID, requirement.value);
+                break;
+		}
+	}
+
+	private static String getDisplayMessage(Phrase phrase, Player player) { return replacePlayerName(phrase.message, player); }
+	private static String getDisplayMessage(Reply reply, Player player) { return replacePlayerName(reply.text, player); }
+	private static String replacePlayerName(String s, Player player) {
+		return s.replace(Constants.PLACEHOLDER_PLAYERNAME, player.getName());
+	}
+
+	public static final class ConversationStatemachine {
+		private final ConversationCollection conversationCollection = new ConversationCollection();
+		private final WorldContext world;
+		private final ControllerContext controllers;
+		private final Player player;
+		private String currentPhraseID;
+		private Phrase currentPhrase;
+		private Monster npc;
+		public final ConversationStateListener listener;
+
+		public ConversationStatemachine(WorldContext world, ControllerContext controllers, ConversationStateListener listener) {
+			this.world = world;
+			this.player = world.model.player;
+			this.controllers = controllers;
+			this.listener = listener;
+		}
+
+		public void setCurrentNPC(Monster currentNPC) { this.npc = currentNPC; }
+		public Monster getCurrentNPC() { return npc; }
+		public String getCurrentPhraseID() { return currentPhraseID; }
+
+		public void playerSelectedReply(final Resources res, Reply r) {
+			applyReplyEffect(world, r, controllers);
+			proceedToPhrase(res, r.nextPhrase, true, true);
+		}
+
+		public void playerSelectedNextStep(final Resources res) {
+			playerSelectedReply(res, currentPhrase.replies[0]);
+		}
+
+		public interface ConversationStateListener {
+			void onTextPhraseReached(String message, Actor actor, String phraseID);
+			void onConversationEnded();
+			void onConversationEndedWithShop(Monster npc);
+			void onConversationEndedWithCombat(Monster npc);
+			void onConversationEndedWithRemoval(Monster npc);
+			void onScriptEffectsApplied(ScriptEffectResult scriptEffectResult);
+			void onConversationCanProceedWithNext();
+			void onConversationHasReply(Reply r, String message);
+		}
+
+		private void setCurrentPhrase(final Resources res, String phraseID) {
+			this.currentPhraseID = phraseID;
+			this.currentPhrase = world.conversationLoader.loadPhrase(phraseID, conversationCollection, res);
+			if (AndorsTrailApplication.DEVELOPMENT_DEBUGMESSAGES) {
+				if (currentPhrase == null) currentPhrase = new Phrase("(phrase \"" + phraseID + "\" not implemented yet)", null, null, null);
+			}
+			if (this.currentPhrase.switchToNPC != null) {
+				setCurrentNPC(world.model.currentMaps.map.findSpawnedMonster(this.currentPhrase.switchToNPC));
+			}
+		}
+
+		public void proceedToPhrase(final Resources res, String phraseID, boolean applyScriptEffects, boolean displayPhraseMessage) {
+			while (phraseID != null) {
+				phraseID = proceedToPhraseInternal(res, phraseID, applyScriptEffects, displayPhraseMessage);
+			}
+		}
+
+		private String proceedToPhraseInternal(final Resources res, String phraseID, boolean applyScriptEffects, boolean displayPhraseMessage) {
+			if (phraseID.equalsIgnoreCase(ConversationCollection.PHRASE_CLOSE)) {
+				listener.onConversationEnded();
+				return null;
+			} else if (phraseID.equalsIgnoreCase(ConversationCollection.PHRASE_SHOP)) {
+				listener.onConversationEndedWithShop(npc);
+				return null;
+			} else if (phraseID.equalsIgnoreCase(ConversationCollection.PHRASE_ATTACK)) {
+				endConversationWithCombat();
+				return null;
+			} else if (phraseID.equalsIgnoreCase(ConversationCollection.PHRASE_REMOVE)) {
+				endConversationWithRemovingNPC();
+				return null;
+			}
+
+			setCurrentPhrase(res, phraseID);
+
+			if (applyScriptEffects) {
+				ScriptEffectResult scriptEffectResult = controllers.conversationController.applyScriptEffectsForPhrase(res, player, currentPhrase);
+				if (scriptEffectResult != null) {
+					listener.onScriptEffectsApplied(scriptEffectResult);
+				}
+			}
+
+			if (currentPhrase.message == null) {
+				for (Reply r : currentPhrase.replies) {
+					if (!canSelectReply(world, r)) continue;
+					applyReplyEffect(world, r, controllers);
+					return r.nextPhrase;
+				}
+			} else if (displayPhraseMessage) {
+				String message = getDisplayMessage(currentPhrase, player);
+				listener.onTextPhraseReached(message, npc, phraseID);
+			}
+
+			if (hasOnlyOneNextReply()) {
+				listener.onConversationCanProceedWithNext();
+				return null;
+			}
+
+			for (Reply r : currentPhrase.replies) {
+				if (!canSelectReply(world, r)) continue;
+				listener.onConversationHasReply(r, getDisplayMessage(r, player));
+			}
+			return null;
+		}
+
+		private void endConversationWithRemovingNPC() {
+			if (npc == null) {
+				if (AndorsTrailApplication.DEVELOPMENT_VALIDATEDATA) L.log("Tried to remove NPC from conversation without having a valid npc target!");
+				listener.onConversationEnded();
+				return;
+			}
+			controllers.monsterSpawnController.remove(world.model.currentMaps.map, npc);
+			listener.onConversationEndedWithRemoval(npc);
+		}
+
+		private void endConversationWithCombat() {
+			if (npc == null) {
+				if (AndorsTrailApplication.DEVELOPMENT_VALIDATEDATA) L.log("Tried to enter combat from conversation without having a valid npc target!");
+				listener.onConversationEnded();
+				return;
+			}
+			npc.forceAggressive();
+			controllers.combatController.setCombatSelection(npc);
+			controllers.combatController.enterCombat(CombatController.BeginTurnAs.player);
+			listener.onConversationEndedWithCombat(npc);
+		}
+
+		public boolean hasOnlyOneNextReply() {
+			if (currentPhrase.replies == null) return false;
+			if (currentPhrase.replies.length != 1) return false;
+			final Reply singleReply = currentPhrase.replies[0];
+			if (!singleReply.text.equals(ConversationCollection.REPLY_NEXT)) return false;
+			if (!canSelectReply(world, singleReply)) return false;
+			return true;
+		}
+	}
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/GameRoundController.java

@@ -3,6 +3,7 @@ package com.gpl.rpg.AndorsTrail.controller;
 import com.gpl.rpg.AndorsTrail.context.ControllerContext;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.controller.listeners.GameRoundListeners;
+import com.gpl.rpg.AndorsTrail.model.map.MapObject;
 import com.gpl.rpg.AndorsTrail.util.TimedMessageTask;
 
 public final class GameRoundController implements TimedMessageTask.Callback {
@@ -51,6 +52,11 @@ public final class GameRoundController implements TimedMessageTask.Callback {
 	public void resume() {
 		world.model.uiSelections.isMainActivityVisible = true;
 		roundTimer.start();
+
+		if (world.model.uiSelections.isInCombat) {
+			controllers.combatController.setCombatSelection(world.model.uiSelections.selectedMonster, world.model.uiSelections.selectedPosition);
+			controllers.combatController.enterCombat(CombatController.BeginTurnAs.continueLastTurn);
+		}
 	}
 
 	private void restartWaitForNextFullRound() {
@@ -68,7 +74,7 @@ public final class GameRoundController implements TimedMessageTask.Callback {
 
 	public void onNewFullRound() {
 		controllers.mapController.resetMapsNotRecentlyVisited();
-		controllers.actorStatsController.applyConditionsToMonsters(world.model.currentMap, true);
+		controllers.actorStatsController.applyConditionsToMonsters(world.model.currentMaps.map, true);
 		controllers.actorStatsController.applyConditionsToPlayer(world.model.player, true);
 		gameRoundListeners.onNewFullRound();
 	}
@@ -79,18 +85,21 @@ public final class GameRoundController implements TimedMessageTask.Callback {
 		gameRoundListeners.onNewRound();
 	}
 	public void onNewPlayerRound() {
+		world.model.worldData.tickWorldTime();
 		controllers.actorStatsController.applyConditionsToPlayer(world.model.player, false);
-		controllers.actorStatsController.applySkillEffectsForNewRound(world.model.player, world.model.currentMap);
+		controllers.actorStatsController.applySkillEffectsForNewRound(world.model.player, world.model.currentMaps.map);
+		controllers.mapController.handleMapEvents(world.model.currentMaps.map, world.model.player.position, MapObject.MapObjectEvaluationType.afterEveryRound);
 	}
 	public void onNewMonsterRound() {
-		controllers.actorStatsController.applyConditionsToMonsters(world.model.currentMap, false);
+		controllers.actorStatsController.applyConditionsToMonsters(world.model.currentMaps.map, false);
 	}
 
 	private void onNewTick() {
 		controllers.monsterMovementController.moveMonsters();
-		controllers.monsterSpawnController.maybeSpawn(world.model.currentMap, world.model.currentTileMap);
+		controllers.monsterSpawnController.maybeSpawn(world.model.currentMaps.map, world.model.currentMaps.tileMap);
 		controllers.monsterMovementController.attackWithAgressiveMonsters();
-		controllers.effectController.updateSplatters(world.model.currentMap);
+		controllers.effectController.updateSplatters(world.model.currentMaps.map);
+		controllers.mapController.handleMapEvents(world.model.currentMaps.map, world.model.player.position, MapObject.MapObjectEvaluationType.continuously);
 		gameRoundListeners.onNewTick();
 	}
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/InputController.java

@@ -0,0 +1,342 @@
+package com.gpl.rpg.AndorsTrail.controller;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.util.SparseIntArray;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnLongClickListener;
+
+import com.gpl.rpg.AndorsTrail.activity.HeroinfoActivity;
+import com.gpl.rpg.AndorsTrail.context.ControllerContext;
+import com.gpl.rpg.AndorsTrail.context.WorldContext;
+import com.gpl.rpg.AndorsTrail.util.Coord;
+import com.gpl.rpg.AndorsTrail.util.L;
+
+public final class InputController implements OnClickListener, OnLongClickListener{
+	private final ControllerContext controllers;
+	private final WorldContext world;
+
+	private final Coord lastTouchPosition_tileCoords = new Coord();
+	private int lastTouchPosition_dx = 0;
+	private int lastTouchPosition_dy = 0;
+	private long lastTouchEventTime = 0;
+	private boolean isDpadActive = false;
+
+	private int keyState_dx = 0;
+	private int keyState_dy = 0;
+	private boolean keyState_attack = false;
+	private boolean keyState_flee = false;
+	private boolean keyState_endturn = false;
+	
+	final private int KEY_UNHANDLED = 0; // Default, for unhandled keycodes
+	final private int KEY_MOVE_UP = 1;
+	final private int KEY_MOVE_DOWN = 2;
+	final private int KEY_MOVE_LEFT = 3;
+	final private int KEY_MOVE_RIGHT = 4;
+	final private int KEY_MOVE_UP_LEFT = 5;
+	final private int KEY_MOVE_UP_RIGHT = 6;
+	final private int KEY_MOVE_DOWN_LEFT = 7;
+	final private int KEY_MOVE_DOWN_RIGHT = 8;
+	final private int KEY_ATTACK = 9;
+	final private int KEY_FLEE = 10;
+	final private int KEY_END_TURN = 11;
+	final private int KEY_HERO_INFO = 12;
+	final private int KEY_TOOLBOX = 13;
+	
+	private SparseIntArray keyMap = new SparseIntArray();  // Android keycode to internal key event mapping.  TODO: Configure via preferences
+
+	public InputController(ControllerContext controllers, WorldContext world) {
+		this.controllers = controllers;
+		this.world = world;
+		initializeKeyMap();
+		
+	}
+	
+/*	New keyboard handler.  Both Key Down and Key Up events handled here to allow conditional behaviours.
+	On 4-way dpad controllers, cursor keys, and WASD, diagonals are generated by chording two keys.
+	Single-key diagonals are supported on numeric keypad and 8-way dpads (not seen/tested in the wild).
+
+    Because two-key combos initially generate a ordinal movement (one key comes in first), which can
+    be dangerous in tight spaces, modifiers are provided to "lock" the input until both keys are down.
+    TODO: Use delay timer to enable chorded diagonals on first move without locking kludge?
+ */
+
+    // Map key codes to spectic internal actions  
+	// TODO: Move mapping out of code to JSON/XML file, or maybe player prefs
+	private void initializeKeyMap() {
+		int key;
+
+		// Keys mapping to UP
+		key = KEY_MOVE_UP;
+		keyMap.put(KeyEvent.KEYCODE_DPAD_UP, key);
+		keyMap.put(KeyEvent.KEYCODE_NUMPAD_8, key);
+		keyMap.put(KeyEvent.KEYCODE_8, key);
+		keyMap.put(KeyEvent.KEYCODE_W, key);
+
+		// Keys mapping to DOWN
+		key = KEY_MOVE_DOWN;
+		keyMap.put(KeyEvent.KEYCODE_DPAD_DOWN, key);
+		keyMap.put(KeyEvent.KEYCODE_NUMPAD_2, key);
+		keyMap.put(KeyEvent.KEYCODE_2, key);
+		keyMap.put(KeyEvent.KEYCODE_S, key);
+
+		// Keys mapping to LEFT
+		key = KEY_MOVE_LEFT;
+		keyMap.put(KeyEvent.KEYCODE_DPAD_LEFT, key);
+		keyMap.put(KeyEvent.KEYCODE_NUMPAD_4, key);
+		keyMap.put(KeyEvent.KEYCODE_4, key);
+		keyMap.put(KeyEvent.KEYCODE_A, key);
+
+		// Keys mapping to RIGHT
+		key = KEY_MOVE_RIGHT;
+		keyMap.put(KeyEvent.KEYCODE_DPAD_RIGHT, key);
+		keyMap.put(KeyEvent.KEYCODE_NUMPAD_6, key);
+		keyMap.put(KeyEvent.KEYCODE_6, key);
+		keyMap.put(KeyEvent.KEYCODE_D, key);
+
+		// Keys mapping to UP_LEFT
+		key = KEY_MOVE_UP_LEFT;
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+			keyMap.put(KeyEvent.KEYCODE_DPAD_UP_LEFT, key);
+		}
+		keyMap.put(KeyEvent.KEYCODE_NUMPAD_7, key);
+		keyMap.put(KeyEvent.KEYCODE_7, key);
+		keyMap.put(KeyEvent.KEYCODE_MOVE_HOME, key);
+
+		// Keys mapping to UP_RIGHT		
+		key = KEY_MOVE_UP_RIGHT;
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+			keyMap.put(KeyEvent.KEYCODE_DPAD_UP_RIGHT, key);
+		}
+		keyMap.put(KeyEvent.KEYCODE_NUMPAD_9, key);
+		keyMap.put(KeyEvent.KEYCODE_9, key);
+		keyMap.put(KeyEvent.KEYCODE_PAGE_UP, key);
+
+		// Keys mapping to DOWN_LEFT
+		key = KEY_MOVE_DOWN_LEFT;
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+			keyMap.put(KeyEvent.KEYCODE_DPAD_DOWN_LEFT, key);
+		}
+		keyMap.put(KeyEvent.KEYCODE_NUMPAD_1, key);
+		keyMap.put(KeyEvent.KEYCODE_1, key);
+		keyMap.put(KeyEvent.KEYCODE_MOVE_END, key);
+
+		// Keys mapping to DOWN_RIGHT		
+		key = KEY_MOVE_DOWN_RIGHT;
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+			keyMap.put(KeyEvent.KEYCODE_DPAD_DOWN_RIGHT, key);
+		}
+		keyMap.put(KeyEvent.KEYCODE_NUMPAD_3, key);
+		keyMap.put(KeyEvent.KEYCODE_3, key);
+		keyMap.put(KeyEvent.KEYCODE_PAGE_DOWN, key);
+
+		// Keys mapping to ATTACK
+		key = KEY_ATTACK;
+		keyMap.put(KeyEvent.KEYCODE_DPAD_CENTER, key);
+		keyMap.put(KeyEvent.KEYCODE_BUTTON_A, key);
+		keyMap.put(KeyEvent.KEYCODE_SPACE, key);
+		keyMap.put(KeyEvent.KEYCODE_NUMPAD_5, key);
+
+		// Keys mapping to FLEE		
+		key = KEY_FLEE;
+		keyMap.put(KeyEvent.KEYCODE_BUTTON_X, key);
+		keyMap.put(KeyEvent.KEYCODE_F, key);
+		keyMap.put(KeyEvent.KEYCODE_NUMPAD_ENTER, key);
+		keyMap.put(KeyEvent.KEYCODE_ENTER, key);
+
+		// Keys mapping to END_TURN
+		key = KEY_END_TURN;
+		keyMap.put(KeyEvent.KEYCODE_BUTTON_Y, key);
+		keyMap.put(KeyEvent.KEYCODE_E, key);
+		keyMap.put(KeyEvent.KEYCODE_FORWARD_DEL, key);
+		keyMap.put(KeyEvent.KEYCODE_NUMPAD_DOT, key);
+
+		// Keys mapping to HERO_INFO 		
+		key = KEY_HERO_INFO;
+		//keyMap.put(KeyEvent.KEYCODE_BUTTON_SELECT, key);
+		keyMap.put(KeyEvent.KEYCODE_BUTTON_L1, key);
+		keyMap.put(KeyEvent.KEYCODE_NUM_LOCK, key);
+		keyMap.put(KeyEvent.KEYCODE_C, key);
+
+		// Keys mapping to TOOLBOX 		
+		key = KEY_TOOLBOX;
+		keyMap.put(KeyEvent.KEYCODE_BUTTON_R1, key);
+		keyMap.put(KeyEvent.KEYCODE_NUMPAD_DIVIDE, key);
+		keyMap.put(KeyEvent.KEYCODE_B, key);
+	}
+
+	// Generate game actions based on mapped keys
+	public boolean onKeyboardAction(Context context, KeyEvent event, boolean acceptInput) {
+		//L.log("onKeyboardAction(): Processing action " + event.getAction() + " for keyCode " + event.getKeyCode());
+
+		if (event.getAction() != KeyEvent.ACTION_DOWN && event.getAction() != KeyEvent.ACTION_UP) return false; // don't handle other actions
+		boolean keydown = (event.getAction() == KeyEvent.ACTION_DOWN);
+		boolean inihbit =  (keyState_attack || keyState_flee); // used to inhibit movement if an action key is held down
+
+		switch (keyMap.get(event.getKeyCode())) {
+
+			// Ordinal directional keys - only modify one direction register; registers are combined when
+			// keys used simultaneously to create synthetic diagonals
+			case KEY_MOVE_UP:
+				keyState_dy = keydown ? -1 : 0;
+				if (acceptInput && !inihbit) onRelativeMovement(keyState_dx, keyState_dy);
+				break;
+			case KEY_MOVE_DOWN:
+				keyState_dy = keydown ? 1 : 0;
+				if (acceptInput && !inihbit) onRelativeMovement(keyState_dx, keyState_dy);
+				break;
+			case KEY_MOVE_LEFT:
+				keyState_dx = keydown ? -1 : 0;
+				if (acceptInput && !inihbit) onRelativeMovement(keyState_dx, keyState_dy);
+				break;
+			case KEY_MOVE_RIGHT:
+				keyState_dx = keydown ? 1 : 0;
+				if (acceptInput && !inihbit) onRelativeMovement(keyState_dx, keyState_dy);
+				break;
+
+			// Diagonal directional keys.  Modify both direction registers, can't be combined
+			// TODO: store individual key position to allow combinations.  May not be worth the trouble.
+			case KEY_MOVE_UP_LEFT:
+				keyState_dx = keydown ? -1 : 0;
+				keyState_dy = keydown ? -1 : 0;
+				if (acceptInput && !inihbit) onRelativeMovement(keyState_dx, keyState_dy);
+				break;
+			case KEY_MOVE_UP_RIGHT:
+				keyState_dx = keydown ? 1 : 0;
+				keyState_dy = keydown ? -1 : 0;
+				if (acceptInput && !inihbit) onRelativeMovement(keyState_dx, keyState_dy);
+				break;
+			case KEY_MOVE_DOWN_LEFT:
+				keyState_dx = keydown ? -1 : 0;
+				keyState_dy = keydown ? 1 : 0;
+				if (acceptInput && !inihbit) onRelativeMovement(keyState_dx, keyState_dy);
+				break;
+			case KEY_MOVE_DOWN_RIGHT:
+				keyState_dx = keydown ? 1 : 0;
+				keyState_dy = keydown ? 1 : 0;
+				if (acceptInput && !inihbit) onRelativeMovement(keyState_dx, keyState_dy);
+				break;
+
+			// Special key handling below - some combat/movement stuff done here because it's too 
+			// specific for logic in onRelativeMovement
+			
+			// "Attack" shortcut - freeze movement to allow chorded direction when key is released.
+			// if in combat, executes an attack on key release
+			case KEY_ATTACK:
+				if (keydown && !keyState_attack) { // key pressed - pause any movement
+					if(!world.model.uiSelections.isInCombat) controllers.movementController.stopMovement();
+				} else if (!keydown && keyState_attack) { // key released - execute attack / move in direction
+					if (acceptInput) onRelativeMovement(keyState_dx, keyState_dy);
+				}
+				keyState_attack = keydown;
+				break;
+
+			// "Flee" shortcut.  Intitiates flee when pressed.  If a direction is held, moves in chosen direction when released
+			case KEY_FLEE:
+				if (world.model.uiSelections.isInCombat) {
+					if (keydown && !keyState_flee) { // button pressed - set flee; movement locked while pressed
+						if(acceptInput) controllers.combatController.startFlee();
+					} else if (!keydown && keyState_flee) { // button released - move flee direction, if held
+						// We need to do a special call because the movement key may already be down, and if the device
+						// doesn't generate repeat keystrokes, this handler won't get another event
+						if ((keyState_dx != 0 || keyState_dy != 0) && allowInputInterval()) {
+							if(acceptInput) controllers.combatController.executeMoveAttack(keyState_dx, keyState_dy);
+						}
+					}
+				}
+				keyState_flee = keydown;
+				break;
+
+			// "End Turn" shortcut.  Flag prevents repeated end turn if key is held down.
+			case KEY_END_TURN:
+				if (acceptInput && keydown && !keyState_endturn) {
+					if (world.model.uiSelections.isInCombat) controllers.combatController.endPlayerTurn();
+				}
+				keyState_endturn = keydown;
+				break;
+			
+			// "Hero Info" screen shortcut.  New activity takes focus, so we don't need to worry about repeats.
+			case KEY_HERO_INFO:
+				if (acceptInput && keydown) context.startActivity(new Intent(context, HeroinfoActivity.class));
+				break;
+			
+			case KEY_TOOLBOX:
+//			???	ToolboxView toolboxview =  context.getApplicationContext(). findViewById(R.id.main_toolboxview);
+				
+				break;
+			
+			case KEY_UNHANDLED: // Unhandled keycode
+				return false;
+			
+			default: // unhandled keymap code entry (should not happen)
+				L.log("onKeyboardAction(): Unhandled keyMap code constant " + keyMap.get(event.getKeyCode()) + " for keyCode " + event.getKeyCode());
+				return false;
+		}
+
+		return true;
+	}
+
+	public void onRelativeMovement(int dx, int dy) {
+		//L.log("onRelativeMovement(): dx=" + dx + " dy=" + dy + " combat: " + world.model.uiSelections.isInCombat);
+		if (world.model.uiSelections.isInCombat) {
+			if (allowInputInterval()) controllers.combatController.executeMoveAttack(dx, dy);
+		} else if (dx == 0 && dy == 0) {
+			controllers.movementController.stopMovement();
+		} else {
+			controllers.movementController.startMovement(dx, dy, null);
+		}
+	}
+
+	public void onKeyboardCancel() {
+		controllers.movementController.stopMovement();
+	}
+
+	@Override
+	public void onClick(View arg0) {
+		if (!world.model.uiSelections.isInCombat) return;
+		onRelativeMovement(lastTouchPosition_dx, lastTouchPosition_dy);
+	}
+
+	@Override
+	public boolean onLongClick(View arg0) {
+		if (world.model.uiSelections.isInCombat) {
+			//TODO: Should be able to mark positions far away (mapwalk / ranged combat)
+			if (lastTouchPosition_dx == 0 && lastTouchPosition_dy == 0) return false;
+			if (Math.abs(lastTouchPosition_dx) > 1) return false;
+			if (Math.abs(lastTouchPosition_dy) > 1) return false;
+
+			controllers.combatController.setCombatSelection(lastTouchPosition_tileCoords);
+			return true;
+		}
+		return false;
+	}
+
+	private boolean allowInputInterval() {
+		final long now = System.currentTimeMillis();
+		if ((now - lastTouchEventTime) < Constants.MINIMUM_INPUT_INTERVAL) return false;
+		lastTouchEventTime = now;
+		return true;
+	}
+
+	public void setDpadActive(boolean isDpadActive) {
+		this.isDpadActive = isDpadActive;
+	}
+
+	public void onTouchCancel() {
+		controllers.movementController.stopMovement();
+	}
+
+	public boolean onTouchedTile(int tile_x, int tile_y) {
+		lastTouchPosition_tileCoords.set(tile_x, tile_y);
+		lastTouchPosition_dx = tile_x - world.model.player.position.x;
+		lastTouchPosition_dy = tile_y - world.model.player.position.y;
+
+		if (world.model.uiSelections.isInCombat || isDpadActive) return false;
+
+		controllers.movementController.startMovement(lastTouchPosition_dx, lastTouchPosition_dy, lastTouchPosition_tileCoords);
+		return true;
+	}
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/ItemController.java

@@ -1,6 +1,10 @@
 package com.gpl.rpg.AndorsTrail.controller;
 
+import java.util.ArrayList;
+import java.util.Collection;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailPreferences;
+import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.context.ControllerContext;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.controller.listeners.QuickSlotListeners;
@@ -8,11 +12,15 @@ import com.gpl.rpg.AndorsTrail.model.ModelContainer;
 import com.gpl.rpg.AndorsTrail.model.ability.SkillCollection;
 import com.gpl.rpg.AndorsTrail.model.ability.traits.AbilityModifierTraits;
 import com.gpl.rpg.AndorsTrail.model.actor.Player;
-import com.gpl.rpg.AndorsTrail.model.item.*;
+import com.gpl.rpg.AndorsTrail.model.item.Inventory;
+import com.gpl.rpg.AndorsTrail.model.item.ItemContainer;
 import com.gpl.rpg.AndorsTrail.model.item.ItemContainer.ItemEntry;
+import com.gpl.rpg.AndorsTrail.model.item.ItemTraits_OnHitReceived;
+import com.gpl.rpg.AndorsTrail.model.item.ItemTraits_OnUse;
+import com.gpl.rpg.AndorsTrail.model.item.ItemType;
+import com.gpl.rpg.AndorsTrail.model.item.Loot;
 
-import java.util.ArrayList;
-import java.util.Collection;
+import static java.lang.Math.min;
 
 public final class ItemController {
 
@@ -28,7 +36,7 @@ public final class ItemController {
 	public void dropItem(ItemType type, int quantity) {
 		if (world.model.player.inventory.getItemQuantity(type.id) < quantity) return;
 		world.model.player.inventory.removeItem(type.id, quantity);
-		world.model.currentMap.itemDropped(type, quantity, world.model.player.position);
+		world.model.currentMaps.map.itemDropped(type, quantity, world.model.player.position);
 	}
 
 	public void equipItem(ItemType type, Inventory.WearSlot slot) {
@@ -51,6 +59,9 @@ public final class ItemController {
 		player.inventory.setItemTypeInWearSlot(slot, type);
 		controllers.actorStatsController.addConditionsFromEquippedItem(player, type);
 		controllers.actorStatsController.recalculatePlayerStats(player);
+		if (world.model.uiSelections.isInCombat && !controllers.combatController.playerHasApLeft()) {
+			controllers.combatController.endPlayerTurn();
+		}
 	}
 
 	public void unequipSlot(ItemType type, Inventory.WearSlot slot) {
@@ -65,6 +76,9 @@ public final class ItemController {
 
 		unequipSlot(player, slot);
 		controllers.actorStatsController.recalculatePlayerStats(player);
+		if (world.model.uiSelections.isInCombat && !controllers.combatController.playerHasApLeft()) {
+			controllers.combatController.endPlayerTurn();
+		}
 	}
 
 	private void unequipSlot(Player player, Inventory.WearSlot slot) {
@@ -85,11 +99,12 @@ public final class ItemController {
 
 		if (!player.inventory.removeItem(type.id, 1)) return;
 
+		world.model.combatLog.append(controllers.getResources().getString(R.string.inventory_item_used, type.getName(player)));
 		controllers.actorStatsController.applyUseEffect(player, null, type.effects_use);
 		world.model.statistics.addItemUsage(type);
-
-		//TODO: provide feedback that the item has been used.
-		//context.mainActivity.message(androidContext.getResources().getString(R.string.inventory_item_used, type.name));
+		if (world.model.uiSelections.isInCombat && !controllers.combatController.playerHasApLeft()) {
+			controllers.combatController.endPlayerTurn();
+		}
 	}
 
 	public void playerSteppedOnLootBag(Loot loot) {
@@ -170,29 +185,46 @@ public final class ItemController {
 			// The stats for off-hand weapons will be added later in SkillController.applySkillEffectsFromFightingStyles
 			if (SkillController.isDualWielding(mainHandItem, type)) return;
 		}
-		if (type.effects_equip != null && type.effects_equip.stats != null)
-		controllers.actorStatsController.applyAbilityEffects(player, type.effects_equip.stats, 1);
+		if (type.effects_equip != null && type.effects_equip.stats != null) {
+            controllers.actorStatsController.applyAbilityEffects(player, type.effects_equip.stats, 1);
+            if (type.isWeapon()) {
+                controllers.actorStatsController.addPlayerWeaponDamage(player, type.effects_equip.stats.increaseMinDamage, type.effects_equip.stats.increaseMaxDamage);
+            }
+        }
 	}
 
 	public static void recalculateHitEffectsFromWornItems(Player player) {
-		ArrayList<ItemTraits_OnUse> effects = null;
+		ArrayList<ItemTraits_OnUse> effects_onHit = null;
+		ArrayList<ItemTraits_OnHitReceived> effects_onHitReceived = null;
 		for (Inventory.WearSlot slot : Inventory.WearSlot.values()) {
 			ItemType type = player.inventory.getItemTypeInWearSlot(slot);
 			if (type == null) continue;
-			ItemTraits_OnUse e = type.effects_hit;
-			if (e == null) continue;
+			ItemTraits_OnUse eh = type.effects_hit;
+			ItemTraits_OnHitReceived ehr = type.effects_hitReceived;
+			if (eh == null && ehr == null) continue;
 
-			if (effects == null) effects = new ArrayList<ItemTraits_OnUse>();
-			effects.add(e);
+			if (effects_onHit == null) effects_onHit = new ArrayList<ItemTraits_OnUse>();
+			if (eh != null) effects_onHit.add(eh);
+			
+			if (effects_onHitReceived == null) effects_onHitReceived = new ArrayList<ItemTraits_OnHitReceived>();
+			if (ehr != null) effects_onHitReceived.add(ehr);
 		}
 
-		if (effects != null) {
-			ItemTraits_OnUse[] effects_ = new ItemTraits_OnUse[effects.size()];
-			effects_ = effects.toArray(effects_);
+		if (effects_onHit != null) {
+			ItemTraits_OnUse[] effects_ = new ItemTraits_OnUse[effects_onHit.size()];
+			effects_ = effects_onHit.toArray(effects_);
 			player.onHitEffects = effects_;
 		} else {
 			player.onHitEffects = null;
 		}
+
+		if (effects_onHitReceived != null) {
+			ItemTraits_OnHitReceived[] effects_ = new ItemTraits_OnHitReceived[effects_onHitReceived.size()];
+			effects_ = effects_onHitReceived.toArray(effects_);
+			player.onHitReceivedEffects = effects_;
+		} else {
+			player.onHitReceivedEffects = null;
+		}
 	}
 
 	public void consumeNonItemLoot(Loot loot) {
@@ -210,6 +242,7 @@ public final class ItemController {
 	public void pickupAll(Loot loot) {
 		world.model.player.inventory.add(loot.items);
 		consumeNonItemLoot(loot);
+		checkQuickslotItemLooted(loot.items);
 		loot.clear();
 	}
 	public void pickupAll(Iterable<Loot> lootBags) {
@@ -220,8 +253,8 @@ public final class ItemController {
 	public boolean removeLootBagIfEmpty(final Loot loot) {
 		if (loot.hasItemsOrGold()) return false;
 
-		world.model.currentMap.removeGroundLoot(loot);
-		controllers.mapController.mapLayoutListeners.onLootBagRemoved(world.model.currentMap, loot.position);
+		world.model.currentMaps.map.removeGroundLoot(loot);
+		controllers.mapController.mapLayoutListeners.onLootBagRemoved(world.model.currentMaps.map, loot.position);
 		return true; // The bag was removed.
 	}
 
@@ -307,7 +340,6 @@ public final class ItemController {
 		boolean addSpace = false;
 		if (attackChance != 0) {
 			sb.append(attackChance);
-			sb.append('%');
 			addSpace = true;
 		}
 		if (minDamage != 0 || maxDamage != 0) {
@@ -325,19 +357,16 @@ public final class ItemController {
 				sb.append('+');
 			}
 			sb.append(criticalSkill);
-			addSpace = true;
 		}
 		if (criticalMultiplier != 0 && criticalMultiplier != 1) {
 			sb.append('x');
 			sb.append(criticalMultiplier);
-			addSpace = true;
 		}
 	}
 
 	public static void describeBlockEffect(int blockChance, int damageResistance, StringBuilder sb) {
 		if (blockChance != 0) {
 			sb.append(blockChance);
-			sb.append('%');
 		}
 		if (damageResistance != 0) {
 			sb.append('/');
@@ -354,4 +383,64 @@ public final class ItemController {
 		world.model.player.inventory.quickitem[quickSlotId] = itemType;
 		quickSlotListeners.onQuickSlotChanged(quickSlotId);
 	}
+	
+	private void checkQuickslotItemLooted(ItemContainer items) {
+		for (ItemEntry item : items.items) {
+			if (item.itemType.isUsable()) {
+				for (int i = 0; i < world.model.player.inventory.quickitem.length; i++) {
+					if (item.itemType == world.model.player.inventory.quickitem[i]) {
+						quickSlotListeners.onQuickSlotChanged(i);
+						
+					}
+				}
+			}
+		}
+	}
+
+	public int removeEquippedItem(String itemTypeID, int count) {
+		int removed = 0;
+		final Player player = world.model.player;
+		for (Inventory.WearSlot slot : Inventory.WearSlot.values()) {
+			ItemType type = player.inventory.getItemTypeInWearSlot(slot);
+			if (type != null && type.id.equals(itemTypeID)) {
+				player.inventory.setItemTypeInWearSlot(slot, null);
+				controllers.actorStatsController.removeConditionsFromUnequippedItem(player, type);
+				controllers.actorStatsController.recalculatePlayerStats(player);
+				removed++;
+				if (removed >= count) {
+					break;
+				}
+			}
+		}
+		return removed;
+	}
+	public static void applyDamageModifier(Player player) {
+		ItemType itemType = player.inventory.getItemTypeInWearSlot(Inventory.WearSlot.weapon);
+		int modifier1 = -1;
+		int modifier2 = -1;
+		if (itemType != null) modifier1 = itemType.effects_equip.stats.setNonWeaponDamageModifier;
+		itemType = player.inventory.getItemTypeInWearSlot(Inventory.WearSlot.shield);
+		if (itemType != null && itemType.isWeapon()) modifier2 = itemType.effects_equip.stats.setNonWeaponDamageModifier;
+
+		int modifier = 100;
+		if (modifier1 >= 0 && modifier2 >= 0) {
+			int skillLevelFightStyle = player.getSkillLevel(SkillCollection.SkillID.fightstyleDualWield);
+			if (skillLevelFightStyle == 2) {
+				modifier = Math.max(modifier1, modifier2);
+			} else if (skillLevelFightStyle == 1) {
+				modifier = (modifier1 + modifier2) / 2;
+			} else {
+				modifier = Math.min(modifier1, modifier2);
+			}
+		}
+		else if (modifier1 <= 0 && modifier2 >= 0) modifier = modifier2;
+		else if (modifier2 <= 0 && modifier1 >= 0) modifier = modifier1;
+
+		if (modifier != 100) {
+			final int minBaseDamage = player.damagePotential.current - player.weaponDamage.current;
+			final int maxBaseDamage = player.damagePotential.max - player.weaponDamage.max;
+			player.damagePotential.add(Math.round(minBaseDamage * ((modifier - 100)/100f)), true);
+			player.damagePotential.addToMax(Math.round(maxBaseDamage * ((modifier - 100)/100f)));
+		}
+	}
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/MapController.java

@@ -0,0 +1,248 @@
+package com.gpl.rpg.AndorsTrail.controller;
+
+import java.util.List;
+
+import android.content.res.Resources;
+
+import com.gpl.rpg.AndorsTrail.context.ControllerContext;
+import com.gpl.rpg.AndorsTrail.context.WorldContext;
+import com.gpl.rpg.AndorsTrail.controller.listeners.MapLayoutListeners;
+import com.gpl.rpg.AndorsTrail.controller.listeners.WorldEventListeners;
+import com.gpl.rpg.AndorsTrail.model.ability.SkillCollection;
+import com.gpl.rpg.AndorsTrail.model.actor.Actor;
+import com.gpl.rpg.AndorsTrail.model.actor.Monster;
+import com.gpl.rpg.AndorsTrail.model.actor.Player;
+import com.gpl.rpg.AndorsTrail.model.conversation.Reply;
+import com.gpl.rpg.AndorsTrail.model.map.LayeredTileMap;
+import com.gpl.rpg.AndorsTrail.model.map.MapObject;
+import com.gpl.rpg.AndorsTrail.model.map.PredefinedMap;
+import com.gpl.rpg.AndorsTrail.model.map.ReplaceableMapSection;
+import com.gpl.rpg.AndorsTrail.util.Coord;
+
+public final class MapController {
+
+	private final ControllerContext controllers;
+	private final WorldContext world;
+	public final WorldEventListeners worldEventListeners = new WorldEventListeners();
+	public final MapLayoutListeners mapLayoutListeners = new MapLayoutListeners();
+	private ConversationController.ConversationStatemachine mapScriptExecutor;
+
+	public MapController(ControllerContext controllers, WorldContext world) {
+		this.controllers = controllers;
+		this.world = world;
+	}
+
+	public void handleMapEventsAfterMovement(PredefinedMap currentMap, Coord newPosition, Coord lastPosition) {
+		// Several map objects can now overlap. Inactive ones won't be returned by getActiveEventObjectsAt()
+		List<MapObject> objects = currentMap.getActiveEventObjectsAt(newPosition);
+		if (objects == null) return;
+		for (MapObject mapObject : objects) {
+
+			switch (mapObject.evaluateWhen) {
+			case afterEveryRound:
+				continue;
+			case whenEntering:
+				// Do not trigger event if the player already was on the same MapObject before.
+				if (mapObject.position.contains(lastPosition)) continue;
+				break;
+			case onEveryStep:
+				break;
+			}
+			handleMapEvent(mapObject, newPosition);
+		}
+	}
+
+	public void handleMapEvents(PredefinedMap currentMap, Coord position, MapObject.MapObjectEvaluationType evaluationType) {
+		List<MapObject> objects = currentMap.getActiveEventObjectsAt(position);
+		if (objects == null) return;
+		for (MapObject mapObject : objects) {
+			if (mapObject == null) return;
+			if (mapObject.evaluateWhen != evaluationType) return;
+			handleMapEvent(mapObject, position);
+		}
+	}
+
+	private void handleMapEvent(MapObject o, Coord position) {
+		if (!shouldHandleMapEvent(o)) return;
+		switch (o.type) {
+		case sign:
+			if (o.id == null || o.id.length() <= 0) return;
+			worldEventListeners.onPlayerSteppedOnMapSignArea(o);
+			break;
+		case newmap:
+			if (o.map == null || o.place == null) return;
+			int offset_x = position.x - o.position.topLeft.x;
+			int offset_y = position.y - o.position.topLeft.y;
+			controllers.movementController.placePlayerAsyncAt(MapObject.MapObjectType.newmap, o.map, o.place, offset_x, offset_y);
+			break;
+		case rest:
+			steppedOnRestArea(o);
+			break;
+		case script:
+			runScriptArea(o);
+			break;
+		}
+	}
+
+	private boolean shouldHandleMapEvent(MapObject mapObject) {
+		if (!mapObject.isActive) return false;
+		if (world.model.uiSelections.isInCombat) {
+			// Only "script" events may run while in combat.
+			if (mapObject.type != MapObject.MapObjectType.script) return false;
+		}
+		return true;
+	}
+
+	private void runScriptArea(MapObject o) {
+		Resources res = controllers.getResources();
+		mapScriptExecutor.proceedToPhrase(res, o.id, true, true);
+		controllers.mapController.applyCurrentMapReplacements(res, true);
+	}
+
+	private void steppedOnRestArea(MapObject area) {
+		if (controllers.preferences.confirmRest) {
+			worldEventListeners.onPlayerSteppedOnRestArea(area);
+		} else {
+			rest(area);
+		}
+	}
+
+	public void steppedOnMonster(Monster m, Coord p) {
+		if (m.isAgressive(world.model.player)) {
+			controllers.combatController.setCombatSelection(m, p);
+			if (controllers.preferences.confirmAttack) {
+				worldEventListeners.onPlayerSteppedOnMonster(m);
+			} else {
+				controllers.combatController.enterCombat(CombatController.BeginTurnAs.player);
+			}
+		} else {
+			worldEventListeners.onPlayerStartedConversation(m, m.getPhraseID());
+		}
+	}
+
+	public void handlePlayerDeath() {
+		controllers.combatController.exitCombat(false);
+		final Player player = world.model.player;
+		int lostExp = player.getCurrentLevelExperience() * Constants.PERCENT_EXP_LOST_WHEN_DIED / 100;
+		lostExp -= lostExp * player.getSkillLevel(SkillCollection.SkillID.lowerExploss) * SkillCollection.PER_SKILLPOINT_INCREASE_EXPLOSS_PERCENT / 100;
+
+		if (lostExp < 0) lostExp = 0;
+		controllers.actorStatsController.addExperience(-lostExp);
+		world.model.statistics.addPlayerDeath(lostExp);
+
+		if (!world.model.statistics.isDead()) {
+			controllers.movementController.respawnPlayerAsync();
+			lotsOfTimePassed();
+		}
+		worldEventListeners.onPlayerDied(lostExp);
+	}
+
+	public void lotsOfTimePassed() {
+		final Player player = world.model.player;
+		controllers.actorStatsController.removeAllTemporaryConditions(player);
+		controllers.actorStatsController.recalculatePlayerStats(player);
+		controllers.actorStatsController.setActorMaxAP(player);
+		controllers.actorStatsController.setActorMaxHealth(player);
+		for (PredefinedMap m : world.maps.getAllMaps()) {
+			m.resetTemporaryData();
+		}
+		controllers.monsterSpawnController.spawnAll(world.model.currentMaps.map, world.model.currentMaps.tileMap);
+		world.model.worldData.tickWorldTime(20);
+		controllers.gameRoundController.resetRoundTimers();
+		mapScriptExecutor.proceedToPhrase(controllers.getResources(), Constants.PASSIVE_ACHIEVEMENT_CHECK_PHRASE, true, true);
+	}
+
+	public void rest(MapObject area) {
+		lotsOfTimePassed();
+		world.model.player.setSpawnPlace(world.model.currentMaps.map.name, area.id);
+		worldEventListeners.onPlayerRested();
+	}
+
+	public boolean canEnterKeyArea(MapObject area) {
+		if (ConversationController.canFulfillRequirement(world, area.enteringRequirement)) {
+			ConversationController.requirementFulfilled(world, area.enteringRequirement, controllers);
+			return true;
+		}
+		worldEventListeners.onPlayerSteppedOnKeyArea(area);
+		return false;
+	}
+
+	public void resetMapsNotRecentlyVisited() {
+		for (PredefinedMap m : world.maps.getAllMaps()) {
+			if (m == world.model.currentMaps.map) continue;
+			if (m.isRecentlyVisited()) continue;
+			if (m.hasResetTemporaryData()) continue;
+			m.resetTemporaryData();
+		}
+	}
+
+	public void applyCurrentMapReplacements(final Resources res, boolean updateWorldmap) {
+		if (!applyReplacements(world.model.currentMaps.map, world.model.currentMaps.tileMap)) return;
+		world.maps.worldMapRequiresUpdate = true;
+
+		if (!updateWorldmap) return;
+		WorldMapController.updateWorldMap(controllers.getContext(), world, res);
+		mapLayoutListeners.onMapTilesChanged(world.model.currentMaps.map, world.model.currentMaps.tileMap);
+	}
+
+	private boolean applyReplacements(PredefinedMap map, LayeredTileMap tileMap) {
+		boolean hasUpdated = false;
+		if (tileMap.replacements != null) {
+			for(ReplaceableMapSection replacement : tileMap.replacements) {
+				if (replacement.isApplied) continue;
+				if (!satisfiesCondition(replacement)) continue;
+				else ConversationController.requirementFulfilled(world, replacement.requirement, controllers);
+				tileMap.applyReplacement(replacement);
+				for (ReplaceableMapSection impactedReplacement : tileMap.replacements) {
+					if (replacement != impactedReplacement && impactedReplacement.isApplied && impactedReplacement.replacementArea.intersects(replacement.replacementArea)) {
+						//The applied replacement has overwritten changes made by a previously applied replacement.
+						//This previous replacement must now be considered as unapplied to let it be reapplied later eventually.
+						impactedReplacement.isApplied = false;
+					}
+				}
+				hasUpdated = true;
+			}
+		}
+		if (map.currentColorFilter != null) {
+			LayeredTileMap.ColorFilterId filter = LayeredTileMap.ColorFilterId.valueOf(map.currentColorFilter);
+			if (filter != tileMap.colorFilter) {
+				tileMap.changeColorFilter(filter);
+				hasUpdated = true;
+			}
+		}
+		if (!map.lastSeenLayoutHash.equalsIgnoreCase(tileMap.getCurrentLayoutHash())) {
+			map.lastSeenLayoutHash = tileMap.getCurrentLayoutHash();
+			hasUpdated = true;
+		}
+		return hasUpdated;
+	}
+
+	public boolean satisfiesCondition(ReplaceableMapSection replacement) {
+		return ConversationController.canFulfillRequirement(world, replacement.requirement);
+	}
+
+	private final ConversationController.ConversationStatemachine.ConversationStateListener conversationStateListener = new ConversationController.ConversationStatemachine.ConversationStateListener() {
+		@Override
+		public void onTextPhraseReached(String message, Actor actor, String phraseID) {
+			worldEventListeners.onScriptAreaStartedConversation(phraseID);
+		}
+		@Override public void onScriptEffectsApplied(ConversationController.ScriptEffectResult scriptEffectResult) { }
+		@Override public void onConversationEnded() { }
+		@Override public void onConversationEndedWithShop(Monster npc) { }
+		@Override public void onConversationEndedWithCombat(Monster npc) { }
+		@Override public void onConversationEndedWithRemoval(Monster npc) { }
+		@Override public void onConversationCanProceedWithNext() { }
+		@Override public void onConversationHasReply(Reply r, String message) { }
+	};
+	public void prepareScriptsOnCurrentMap() {
+		mapScriptExecutor = new ConversationController.ConversationStatemachine(world, controllers, conversationStateListener);
+	}
+
+	public void activateMapObjectGroup(PredefinedMap map, String group) {
+		map.activateMapObjectGroup(group);
+	}
+
+	public void deactivateMapObjectGroup(PredefinedMap map, String group) {
+		map.deactivateMapObjectGroup(group);
+	}
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/MonsterMovementController.java

@@ -27,7 +27,7 @@ public final class MonsterMovementController implements EvaluateWalkable {
 	public void moveMonsters() {
 		long currentTime = System.currentTimeMillis();
 
-		for (MonsterSpawnArea a : world.model.currentMap.spawnAreas) {
+		for (MonsterSpawnArea a : world.model.currentMaps.map.spawnAreas) {
 			for (Monster m : a.monsters) {
 				if (m.nextActionTime <= currentTime) {
 					moveMonster(m, a);
@@ -37,9 +37,9 @@ public final class MonsterMovementController implements EvaluateWalkable {
 	}
 
 	public void attackWithAgressiveMonsters() {
-		for (MonsterSpawnArea a : world.model.currentMap.spawnAreas) {
+		for (MonsterSpawnArea a : world.model.currentMaps.map.spawnAreas) {
 			for (Monster m : a.monsters) {
-				if (!m.isAgressive()) continue;
+				if (!m.isAgressive(world.model.player)) continue;
 				if (!m.isAdjacentTo(world.model.player)) continue;
 
 				int aggressionChanceBias = world.model.player.getSkillLevel(SkillCollection.SkillID.evasion) * SkillCollection.PER_SKILLPOINT_INCREASE_EVASION_MONSTER_ATTACK_CHANCE_PERCENTAGE;
@@ -52,43 +52,47 @@ public final class MonsterMovementController implements EvaluateWalkable {
 		}
 	}
 
-	public static boolean monsterCanMoveTo(final PredefinedMap map, final LayeredTileMap tilemap, final CoordRect p) {
+	public static boolean monsterCanMoveTo(final Monster movingMonster, final PredefinedMap map, final LayeredTileMap tilemap, final CoordRect p, boolean ignoreAreas) {
 		if (tilemap != null) {
 			if (!tilemap.isWalkable(p)) return false;
 		}
-		if (map.getMonsterAt(p) != null) return false;
-		MapObject m = map.getEventObjectAt(p.topLeft);
-		if (m != null) {
-			if (m.type == MapObject.MapObjectType.newmap) return false;
-			if (m.type == MapObject.MapObjectType.keyarea) return false;
+		if (map.getMonsterAt(p, movingMonster) != null) return false;
+
+		if (!ignoreAreas) {
+			for (MapObject mObj : map.eventObjects) {
+				if (mObj == null) continue;
+				if (!mObj.isActive) continue;
+				if (!mObj.position.intersects(p)) continue;
+				switch (mObj.type) {
+				case newmap:
+				case keyarea:
+				case rest:
+					return false;
+				}
+			}
 		}
 		return true;
 	}
 
 	private void moveMonster(final Monster m, final MonsterSpawnArea area) {
-		PredefinedMap map = world.model.currentMap;
-		LayeredTileMap tileMap = world.model.currentTileMap;
-		m.nextActionTime += getMillisecondsPerMove(m);
-		if (m.movementDestination == null) {
-			// Monster has waited and should start to move again.
-			m.movementDestination = new Coord(m.position);
-			if (Constants.rnd.nextBoolean()) {
-				m.movementDestination.x = area.area.topLeft.x + Constants.rnd.nextInt(area.area.size.width);
-			} else {
-				m.movementDestination.y = area.area.topLeft.y + Constants.rnd.nextInt(area.area.size.height);
-			}
-		} else if (m.position.equals(m.movementDestination)) {
+		if (m.getMoveCost() == Constants.MONSTER_IMMOBILE_MOVE_COST) {
+			return;
+		}
+		PredefinedMap map = world.model.currentMaps.map;
+		LayeredTileMap tileMap = world.model.currentMaps.tileMap;
+		m.nextActionTime = System.currentTimeMillis() + getMillisecondsPerMove(m);
+		if (m.movementDestination != null && m.position.equals(m.movementDestination)) {
 			// Monster has been moving and arrived at the destination.
 			cancelCurrentMonsterMovement(m);
 		} else {
 			determineMonsterNextPosition(m, area, world.model.player.position);
 
-			if (!monsterCanMoveTo(map, tileMap, m.nextPosition)) {
+			if (!monsterCanMoveTo(m, map, tileMap, m.nextPosition, area.ignoreAreas)) {
 				cancelCurrentMonsterMovement(m);
 				return;
 			}
 			if (m.nextPosition.contains(world.model.player.position)) {
-				if (!m.isAgressive()) {
+				if (!m.isAgressive(world.model.player)) {
 					cancelCurrentMonsterMovement(m);
 					return;
 				}
@@ -101,7 +105,7 @@ public final class MonsterMovementController implements EvaluateWalkable {
 	}
 
 	private void determineMonsterNextPosition(Monster m, MonsterSpawnArea area, Coord playerPosition) {
-		if (m.isAgressive()) {
+//		if (m.isAgressive()) {
 			boolean searchForPath = false;
 			if (m.getMovementAggressionType() == MonsterType.AggressionType.protectSpawn) {
 				if (area.area.contains(playerPosition)) searchForPath = true;
@@ -111,8 +115,18 @@ public final class MonsterMovementController implements EvaluateWalkable {
 			if (searchForPath) {
 				if (findPathFor(m, playerPosition)) return;
 			}
-		}
-
+//		}
+			
+			// Monster has waited and should start to move again.
+			if (m.movementDestination == null) {
+				m.movementDestination = new Coord(m.position);
+				if (Constants.rnd.nextBoolean()) {
+					m.movementDestination.x = area.area.topLeft.x + Constants.rnd.nextInt(area.area.size.width);
+				} else {
+					m.movementDestination.y = area.area.topLeft.y + Constants.rnd.nextInt(area.area.size.height);
+				}
+			}
+			
 		// Monster is moving in a straight line.
 		m.nextPosition.topLeft.set(
 				m.position.x + sgn(m.movementDestination.x - m.position.x)
@@ -122,12 +136,18 @@ public final class MonsterMovementController implements EvaluateWalkable {
 
 	private static void cancelCurrentMonsterMovement(final Monster m) {
 		m.movementDestination = null;
-		m.nextActionTime += getMillisecondsPerMove(m) * Constants.rollValue(Constants.monsterWaitTurns);
+		m.nextActionTime = System.currentTimeMillis() + (getMillisecondsPerMove(m) * Constants.rollValue(Constants.monsterWaitTurns));
 	}
 
 	private static int getMillisecondsPerMove(Monster m) {
 		return Constants.MONSTER_MOVEMENT_TURN_DURATION_MS * m.getMoveCost() / m.getMaxAP();
 	}
+	
+
+	private int getMillisecondsPerCombatMove(Monster m) {
+		if (controllers.preferences.attackspeed_milliseconds <= 0) return 0;
+		return controllers.preferences.attackspeed_milliseconds;
+	}
 
 	private static int sgn(int i) {
 		if (i <= -1) return -1;
@@ -137,17 +157,33 @@ public final class MonsterMovementController implements EvaluateWalkable {
 
 	private final PathFinder pathfinder = new PathFinder(Constants.MAX_MAP_WIDTH, Constants.MAX_MAP_HEIGHT, this);
 	public boolean findPathFor(Monster m, Coord to) {
-		return pathfinder.findPathBetween(m.rectPosition, to, m.nextPosition);
+		return pathfinder.findPathBetween(m.rectPosition, to, m.nextPosition, m);
 	}
 
 	@Override
-	public boolean isWalkable(CoordRect r) {
-		return monsterCanMoveTo(world.model.currentMap, world.model.currentTileMap, r);
+	public boolean isWalkable(CoordRect r, Monster m) {
+		return monsterCanMoveTo(null, world.model.currentMaps.map, world.model.currentMaps.tileMap, r, m.area.ignoreAreas);
 	}
 
-	public void moveMonsterToNextPosition(Monster m, PredefinedMap map) {
-		CoordRect previousPosition = new CoordRect(new Coord(m.position), m.rectPosition.size);
+	public void moveMonsterToNextPosition(final Monster m, final PredefinedMap map) {
+		moveMonsterToNextPositionWithCallback(m, map, getMillisecondsPerMove(m) / 4, null);
+	}
+	
+	public void moveMonsterToNextPositionDuringCombat(final Monster m, final PredefinedMap map, final VisualEffectController.VisualEffectCompletedCallback callback) {
+		moveMonsterToNextPositionWithCallback(m, map, getMillisecondsPerCombatMove(m) / 4, callback);
+	}
+	
+	private void moveMonsterToNextPositionWithCallback(final Monster m, final PredefinedMap map, int duration, final VisualEffectController.VisualEffectCompletedCallback callback) {
+		final CoordRect previousPosition = new CoordRect(new Coord(m.position), m.rectPosition.size);
+		m.lastPosition.set(previousPosition.topLeft);
 		m.position.set(m.nextPosition.topLeft);
-		monsterMovementListeners.onMonsterMoved(map, m, previousPosition);
+		controllers.effectController.startActorMoveEffect(m, map, previousPosition.topLeft, m.position, duration, new VisualEffectController.VisualEffectCompletedCallback() {
+			
+			@Override
+			public void onVisualEffectCompleted(int callbackValue) {
+				if (callback != null) callback.onVisualEffectCompleted(callbackValue);
+				monsterMovementListeners.onMonsterMoved(map, m, previousPosition);
+			}
+		}, 0);
 	}
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/MonsterSpawningController.java

@@ -51,20 +51,20 @@ public final class MonsterSpawningController {
 	}
 	public boolean TEST_spawnInArea(PredefinedMap map, LayeredTileMap tileMap, MonsterSpawnArea a, MonsterType type) { return spawnInArea(map, tileMap, a, type, null); }
 	private boolean spawnInArea(PredefinedMap map, LayeredTileMap tileMap, MonsterSpawnArea a, MonsterType type, Coord playerPosition) {
-		Coord p = getRandomFreePosition(map, tileMap, a.area, type.tileSize, playerPosition);
+		Coord p = getRandomFreePosition(map, tileMap, a, type.tileSize, playerPosition);
 		if (p == null) return false;
 		Monster m = a.spawn(p, type);
 		monsterSpawnListeners.onMonsterSpawned(map, m);
 		return true;
 	}
 
-	public static Coord getRandomFreePosition(PredefinedMap map, LayeredTileMap tileMap, CoordRect area, Size requiredSize, Coord playerPosition) {
+	public static Coord getRandomFreePosition(PredefinedMap map, LayeredTileMap tileMap, MonsterSpawnArea a, Size requiredSize, Coord playerPosition) {
 		CoordRect p = new CoordRect(requiredSize);
 		for(int i = 0; i < 100; ++i) {
 			p.topLeft.set(
-					area.topLeft.x + Constants.rnd.nextInt(area.size.width)
-					,area.topLeft.y + Constants.rnd.nextInt(area.size.height));
-			if (!MonsterMovementController.monsterCanMoveTo(map, tileMap, p)) continue;
+					a.area.topLeft.x + Constants.rnd.nextInt(a.area.size.width)
+					,a.area.topLeft.y + Constants.rnd.nextInt(a.area.size.height));
+			if (!MonsterMovementController.monsterCanMoveTo(null, map, tileMap, p, a.ignoreAreas)) continue;
 			if (playerPosition != null && p.contains(playerPosition)) continue;
 			return p.topLeft;
 		}
@@ -78,4 +78,18 @@ public final class MonsterSpawningController {
 		monsterSpawnListeners.onMonsterRemoved(map, m, m.rectPosition);
 	}
 
+	public void activateSpawnArea(PredefinedMap map, LayeredTileMap tileMap, MonsterSpawnArea spawnArea, boolean spawnAllMonsters) {
+		spawnArea.isSpawning = true;
+		if (spawnAllMonsters) {
+			boolean respawnUniqueMonsters = true;
+			spawnAllInArea(map, tileMap, spawnArea, respawnUniqueMonsters);
+		}
+	}
+
+	public void deactivateSpawnArea(MonsterSpawnArea spawnArea, boolean removeAllMonsters) {
+		spawnArea.isSpawning = false;
+		if (removeAllMonsters) {
+			spawnArea.removeAllMonsters();
+		}
+	}
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/MovementController.java

@@ -2,15 +2,21 @@ package com.gpl.rpg.AndorsTrail.controller;
 
 import android.content.res.Resources;
 import android.os.AsyncTask;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailPreferences;
 import com.gpl.rpg.AndorsTrail.context.ControllerContext;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.controller.listeners.PlayerMovementListeners;
+import com.gpl.rpg.AndorsTrail.model.MapBundle;
 import com.gpl.rpg.AndorsTrail.model.ModelContainer;
 import com.gpl.rpg.AndorsTrail.model.actor.Monster;
 import com.gpl.rpg.AndorsTrail.model.actor.Player;
 import com.gpl.rpg.AndorsTrail.model.item.Loot;
-import com.gpl.rpg.AndorsTrail.model.map.*;
+import com.gpl.rpg.AndorsTrail.model.map.LayeredTileMap;
+import com.gpl.rpg.AndorsTrail.model.map.MapObject;
+import com.gpl.rpg.AndorsTrail.model.map.MonsterSpawnArea;
+import com.gpl.rpg.AndorsTrail.model.map.PredefinedMap;
+import com.gpl.rpg.AndorsTrail.model.map.TMXMapTranslator;
 import com.gpl.rpg.AndorsTrail.resource.tiles.TileCollection;
 import com.gpl.rpg.AndorsTrail.util.Coord;
 import com.gpl.rpg.AndorsTrail.util.L;
@@ -19,7 +25,8 @@ import com.gpl.rpg.AndorsTrail.util.TimedMessageTask;
 public final class MovementController implements TimedMessageTask.Callback {
 	private final ControllerContext controllers;
 	private final WorldContext world;
-	private final TimedMessageTask movementHandler;
+	//TODO restore final modifier before release
+	private TimedMessageTask movementHandler;
 	public final PlayerMovementListeners playerMovementListeners = new PlayerMovementListeners();
 
 	public MovementController(ControllerContext controllers, WorldContext world) {
@@ -27,6 +34,12 @@ public final class MovementController implements TimedMessageTask.Callback {
 		this.world = world;
 		this.movementHandler = new TimedMessageTask(this, Constants.MINIMUM_INPUT_INTERVAL, false);
 	}
+	
+	//TODO remove this method before release
+	public void resetMovementHandler() {
+		this.movementHandler.stop();
+		this.movementHandler = new TimedMessageTask(this, Constants.MINIMUM_INPUT_INTERVAL, false);
+	}
 
 	public void placePlayerAsyncAt(final MapObject.MapObjectType objectType, final String mapName, final String placeName, final int offset_x, final int offset_y) {
 
@@ -44,7 +57,7 @@ public final class MovementController implements TimedMessageTask.Callback {
 			protected void onPostExecute(Void result) {
 				super.onPostExecute(result);
 				stopMovement();
-				playerMovementListeners.onPlayerEnteredNewMap(world.model.currentMap, world.model.player.position);
+				playerMovementListeners.onPlayerEnteredNewMap(world.model.currentMaps.map, world.model.player.position);
 				controllers.gameRoundController.resume();
 			}
 
@@ -65,9 +78,13 @@ public final class MovementController implements TimedMessageTask.Callback {
 			L.log("Cannot find place " + placeName + " of type " + objectType + " in map " + mapName);
 			return;
 		}
+		if (!place.isActive) {
+			L.log("Place " + placeName + " of type " + objectType + " in map " + mapName + " cannot be used as it is inactive");
+			return;
+		}
 		final ModelContainer model = world.model;
 
-		if (model.currentMap != null) model.currentMap.updateLastVisitTime();
+		if (model.currentMaps.map != null) model.currentMaps.map.updateLastVisitTime();
 		model.player.position.set(place.position.topLeft);
 		model.player.position.x += Math.min(offset_x, place.position.size.width-1);
 		model.player.position.y += Math.min(offset_y, place.position.size.height-1);
@@ -81,27 +98,37 @@ public final class MovementController implements TimedMessageTask.Callback {
 	}
 
 	private void playerVisitsMapFirstTime(PredefinedMap m) {
-		m.reset();
 		m.createAllContainerLoot();
 		world.maps.worldMapRequiresUpdate = true;
 	}
 
 	public void prepareMapAsCurrentMap(PredefinedMap newMap, Resources res, boolean spawnMonsters) {
 		final ModelContainer model = world.model;
-		model.currentMap = newMap;
-		cacheCurrentMapData(res, newMap);
+		MapBundle newMaps = new MapBundle();
+		newMaps.map = newMap;
+
+		LayeredTileMap mapTiles = TMXMapTranslator.readLayeredTileMap(res, world.tileManager.tileCache, newMaps.map);
+		mapTiles.changeColorFilter(newMaps.map.currentColorFilter);
+		TileCollection cachedTiles = world.tileManager.loadTilesFor(newMaps.map, mapTiles, world, res);
+		newMaps.tileMap = mapTiles;
+		newMaps.tiles = cachedTiles;
+		world.tileManager.cacheAdjacentMaps(res, world, newMaps.map);
+		world.model.currentMaps = newMaps;
+
+		//Apply replacements before spawning, so that MonsterSpawnArea's isActive variable is up to date.
+		controllers.mapController.applyCurrentMapReplacements(res, false);
 		if (spawnMonsters) {
 			if (!newMap.isRecentlyVisited()) {
-				controllers.monsterSpawnController.spawnAll(newMap, model.currentTileMap);
+				controllers.monsterSpawnController.spawnAll(newMap, model.currentMaps.tileMap);
 			}
 		}
-		controllers.mapController.applyCurrentMapReplacements(res, false);
+		controllers.mapController.prepareScriptsOnCurrentMap();
 		newMap.visited = true;
 		newMap.updateLastVisitTime();
-		moveBlockedActors(newMap, model.currentTileMap);
+		moveBlockedActors(newMap, model.currentMaps.tileMap);
 		refreshMonsterAggressiveness(newMap, model.player);
 		controllers.effectController.updateSplatters(newMap);
-		WorldMapController.updateWorldMap(world, res);
+		WorldMapController.updateWorldMap(controllers.getContext(), world, res);
 	}
 
 	private boolean mayMovePlayer() {
@@ -114,13 +141,13 @@ public final class MovementController implements TimedMessageTask.Callback {
 
 		if (!findWalkablePosition(dx, dy)) return;
 
-		Monster m = world.model.currentMap.getMonsterAt(world.model.player.nextPosition);
+		Monster m = world.model.currentMaps.map.getMonsterAt(world.model.player.nextPosition);
 		if (m != null) {
 			controllers.mapController.steppedOnMonster(m, world.model.player.nextPosition);
 			return;
 		}
 
-		moveToNextIfPossible(true);
+		moveToNextIfPossible();
 	}
 
 	private boolean findWalkablePosition(int dx, int dy) {
@@ -179,15 +206,15 @@ public final class MovementController implements TimedMessageTask.Callback {
 				,player.position.y + dy
 			);
 
-		if (!world.model.currentTileMap.isWalkable(player.nextPosition)) return false;
+		if (!world.model.currentMaps.tileMap.isWalkable(player.nextPosition)) return false;
 
 		// allow player to enter every field when he is NORMAL
 		// prevent player from entering "non-monster-fields" when he is AGGRESSIVE
 		// prevent player from entering "monster-fields" when he is DEFENSIVE
 		if (aggressiveness == AndorsTrailPreferences.MOVEMENTAGGRESSIVENESS_NORMAL) return true;
 
-		Monster m = world.model.currentMap.getMonsterAt(player.nextPosition);
-		if (m != null && !m.isAgressive()) return true; // avoid MOVEMENTAGGRESSIVENESS settings for NPCs
+		Monster m = world.model.currentMaps.map.getMonsterAt(player.nextPosition);
+		if (m != null && !m.isAgressive(player)) return true; // avoid MOVEMENTAGGRESSIVENESS settings for NPCs
 
 		if (aggressiveness == AndorsTrailPreferences.MOVEMENTAGGRESSIVENESS_AGGRESSIVE && m == null) return false;
 		if (aggressiveness == AndorsTrailPreferences.MOVEMENTAGGRESSIVENESS_DEFENSIVE && m != null) return false;
@@ -206,12 +233,13 @@ public final class MovementController implements TimedMessageTask.Callback {
 		else return -v;
 	}
 
-	public void moveToNextIfPossible(boolean handleEvents) {
+	public void moveToNextIfPossible() {
 		final Player player = world.model.player;
-		final PredefinedMap currentMap = world.model.currentMap;
+		final PredefinedMap currentMap = world.model.currentMaps.map;
 		final Coord newPosition = player.nextPosition;
 
 		for (MapObject o : currentMap.eventObjects) {
+			if (!o.isActive) continue;
 			if (o.type == MapObject.MapObjectType.keyarea) {
 				if (o.position.contains(newPosition)) {
 					if (!controllers.mapController.canEnterKeyArea(o)) return;
@@ -222,24 +250,29 @@ public final class MovementController implements TimedMessageTask.Callback {
 		player.lastPosition.set(player.position);
 		player.position.set(newPosition);
 		controllers.combatController.setCombatSelection(null, null);
-		playerMovementListeners.onPlayerMoved(newPosition, player.lastPosition);
+		
+		controllers.effectController.startActorMoveEffect(player, currentMap, player.lastPosition, newPosition, (int) (Constants.MINIMUM_INPUT_INTERVAL / 2), new VisualEffectController.VisualEffectCompletedCallback() {
+			
+			@Override
+			public void onVisualEffectCompleted(int callbackValue) {
 
-		if (handleEvents) {
-			MapObject o = currentMap.getEventObjectAt(newPosition);
-			if (o != null) {
-				if (!o.position.contains(player.lastPosition)) { // Do not trigger event if the player already was on the same MapObject before.
-					controllers.mapController.handleMapEvent(o, newPosition);
+				playerMovementListeners.onPlayerMoved(currentMap, newPosition, player.lastPosition);
+				controllers.mapController.handleMapEventsAfterMovement(currentMap, newPosition, player.lastPosition);
+
+				if (!world.model.uiSelections.isInCombat) {
+					//currentMap can be outdated due to mapchange events processed above.
+					Loot loot = world.model.currentMaps.map.getBagAt(newPosition);
+					if (loot != null) controllers.itemController.playerSteppedOnLootBag(loot);
 				}
 			}
-
-			Loot loot = currentMap.getBagAt(newPosition);
-			if (loot != null) controllers.itemController.playerSteppedOnLootBag(loot);
-		}
+		}, 0);
+		
+		
 	}
 
 	public void respawnPlayer(Resources res) {
 		placePlayerAt(res, MapObject.MapObjectType.rest, world.model.player.getSpawnMap(), world.model.player.getSpawnPlace(), 0, 0);
-		playerMovementListeners.onPlayerEnteredNewMap(world.model.currentMap, world.model.player.position);
+		playerMovementListeners.onPlayerEnteredNewMap(world.model.currentMaps.map, world.model.player.position);
 	}
 	public void respawnPlayerAsync() {
 		placePlayerAsyncAt(MapObject.MapObjectType.rest, world.model.player.getSpawnMap(), world.model.player.getSpawnPlace(), 0, 0);
@@ -261,7 +294,7 @@ public final class MovementController implements TimedMessageTask.Callback {
 		for (MonsterSpawnArea a : map.spawnAreas) {
 			for (Monster m : a.monsters) {
 				if (tileMap.isWalkable(m.rectPosition)) continue;
-				Coord p = MonsterSpawningController.getRandomFreePosition(map, tileMap, a.area, m.tileSize, playerPosition);
+				Coord p = MonsterSpawningController.getRandomFreePosition(map, tileMap, a, m.tileSize, playerPosition);
 				if (p == null) continue;
 				m.position.set(p);
 			}
@@ -282,20 +315,12 @@ public final class MovementController implements TimedMessageTask.Callback {
 
 	private static Coord getFirstMapChangeAreaPosition(PredefinedMap map) {
 		for (MapObject o : map.eventObjects) {
+			if (!o.isActive) continue;
 			if (o.type == MapObject.MapObjectType.newmap) return o.position.topLeft;
 		}
 		return null;
 	}
 
-	private void cacheCurrentMapData(final Resources res, final PredefinedMap nextMap) {
-		LayeredTileMap mapTiles = TMXMapTranslator.readLayeredTileMap(res, world.tileManager.tileCache, nextMap);
-		TileCollection cachedTiles = world.tileManager.loadTilesFor(nextMap, mapTiles, world, res);
-		world.model.currentTileMap = mapTiles;
-		world.tileManager.currentMapTiles = cachedTiles;
-		world.tileManager.cacheAdjacentMaps(res, world, nextMap);
-	}
-
-
 	private int movementDx;
 	private int movementDy;
 	public void startMovement(int dx, int dy, Coord destination) {
@@ -322,13 +347,14 @@ public final class MovementController implements TimedMessageTask.Callback {
 	}
 
 	public static void refreshMonsterAggressiveness(final PredefinedMap map, final Player player) {
-		for(MonsterSpawnArea a : map.spawnAreas) {
-			for (Monster m : a.monsters) {
-				String faction = m.getFaction();
-				if (faction == null) continue;
-				if (player.getAlignment(faction) < 0) m.forceAggressive();
-			}
-		}
+//	Faction-related agressiveness now dynamic, and unrelated to "forceAgressive".
+//		for(MonsterSpawnArea a : map.spawnAreas) {
+//			for (Monster m : a.monsters) {
+//				String faction = m.getFaction();
+//				if (faction == null) continue;
+//				if (player.getAlignment(faction) < 0) m.forceAggressive();
+//			}
+//		}
 	}
 
 	public static boolean hasAdjacentAggressiveMonster(PredefinedMap map, Player player) {
@@ -337,7 +363,7 @@ public final class MovementController implements TimedMessageTask.Callback {
 	public static Monster getAdjacentAggressiveMonster(PredefinedMap map, Player player) {
 		for (MonsterSpawnArea a : map.spawnAreas) {
 			for (Monster m : a.monsters) {
-				if (!m.isAgressive()) continue;
+				if (!m.isAgressive(player)) continue;
 				if (m.isAdjacentTo(player)) return m;
 			}
 		}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/PathFinder.java

@@ -1,17 +1,17 @@
 package com.gpl.rpg.AndorsTrail.controller;
 
+import java.util.Arrays;
+
+import com.gpl.rpg.AndorsTrail.model.actor.Monster;
 import com.gpl.rpg.AndorsTrail.util.Coord;
 import com.gpl.rpg.AndorsTrail.util.CoordRect;
 
-import java.util.Arrays;
-
 public class PathFinder {
 	private final int maxWidth;
 	private final int maxHeight;
 	private final boolean visited[];
 	private final ListOfCoords visitQueue;
 	private final EvaluateWalkable map;
-	public int iterations = 0;
 
 	public PathFinder(int maxWidth, int maxHeight, EvaluateWalkable map) {
 		this.maxWidth = maxWidth;
@@ -22,12 +22,12 @@ public class PathFinder {
 	}
 
 	public interface EvaluateWalkable {
-		public boolean isWalkable(CoordRect r);
+		public boolean isWalkable(CoordRect r, Monster m);
 	}
 
-	public boolean findPathBetween(final CoordRect from, final Coord to, CoordRect nextStep) {
-		iterations = 0;
-		if (from.equals(to)) return false;
+	public boolean findPathBetween(final CoordRect from, final Coord to, CoordRect nextStep, Monster m) {
+		int iterations = 0;
+		if (from.contains(to)) return false;
 
 		Coord measureDistanceTo = from.topLeft;
 		Coord p = nextStep.topLeft;
@@ -45,19 +45,19 @@ public class PathFinder {
 
 			if (from.isAdjacentTo(p)) return true;
 
-			p.x -= 1; visit(nextStep, measureDistanceTo);
-			p.x += 2; visit(nextStep, measureDistanceTo);
-			p.x -= 1; p.y -= 1; visit(nextStep, measureDistanceTo);
-			p.y += 2; visit(nextStep, measureDistanceTo);
-			p.x -= 1; visit(nextStep, measureDistanceTo);
-			p.x += 2; visit(nextStep, measureDistanceTo);
-			p.y -= 2; visit(nextStep, measureDistanceTo);
-			p.x -= 2; visit(nextStep, measureDistanceTo);
+			p.x -= 1; visit(nextStep, measureDistanceTo, m);
+			p.x += 2; visit(nextStep, measureDistanceTo, m);
+			p.x -= 1; p.y -= 1; visit(nextStep, measureDistanceTo, m);
+			p.y += 2; visit(nextStep, measureDistanceTo, m);
+			p.x -= 1; visit(nextStep, measureDistanceTo, m);
+			p.x += 2; visit(nextStep, measureDistanceTo, m);
+			p.y -= 2; visit(nextStep, measureDistanceTo, m);
+			p.x -= 2; visit(nextStep, measureDistanceTo, m);
 		}
 		return false;
 	}
 
-	private void visit(CoordRect r, Coord measureDistanceTo) {
+	private void visit(CoordRect r, Coord measureDistanceTo, Monster m) {
 		final int x = r.topLeft.x;
 		final int y = r.topLeft.y;
 
@@ -69,7 +69,7 @@ public class PathFinder {
 		final int i = (y * maxWidth) + x;
 		if (visited[i]) return;
 		visited[i] = true;
-		if (!map.isWalkable(r)) return;
+		if (!map.isWalkable(r, m)) return;
 
 		int dx = (measureDistanceTo.x - x);
 		int dy = (measureDistanceTo.y - y);
@@ -77,7 +77,8 @@ public class PathFinder {
 	}
 
 	private static final class ListOfCoords {
-		private final int coords[];
+		private final int xCoords[];
+		private final int yCoords[];
 		private final int weights[];
 		private final int maxIndex;
 		private int lastIndex; // Index of the last coord that was inserted
@@ -86,25 +87,21 @@ public class PathFinder {
 
 		public ListOfCoords(int maxSize) {
 			this.maxIndex = maxSize-1;
-			this.coords = new int[maxSize];
+			this.xCoords = new int[maxSize];
+			this.yCoords = new int[maxSize];
 			this.weights = new int[maxSize];
 		}
+
 		public void reset() {
 			lastIndex = -1;
 			frontIndex = 0;
 		}
-		private static int coordsToInt(int x, int y) {
-			return ((y << 8) & 0xff00) | (x & 0xff);
-		}
-		private static void intToCoords(int c, Coord dest) {
-			dest.x = c & 0xff;
-			dest.y = (c >> 8) & 0xff;
-		}
 
 		public void push(int x, int y, int weight) {
 			if (lastIndex == maxIndex) return;
 			++lastIndex;
-			coords[lastIndex] = coordsToInt(x, y);
+			xCoords[lastIndex] = x;
+			yCoords[lastIndex] = y;
 			weights[lastIndex] = weight;
 		}
 
@@ -120,7 +117,8 @@ public class PathFinder {
 					lowestWeight = weights[i];
 				}
 			}
-			intToCoords(coords[lowestWeightIndex], dest);
+			dest.x = xCoords[lowestWeightIndex];
+			dest.y = yCoords[lowestWeightIndex];
 			weights[lowestWeightIndex] = DISCARDED;
 
 			// Increase frontIndex to the first index that is not discarded.

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/SkillController.java

@@ -1,8 +1,8 @@
 package com.gpl.rpg.AndorsTrail.controller;
 
-import android.util.FloatMath;
 import com.gpl.rpg.AndorsTrail.context.ControllerContext;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
+import com.gpl.rpg.AndorsTrail.controller.listeners.CombatActionListeners;
 import com.gpl.rpg.AndorsTrail.model.ability.ActorConditionEffect;
 import com.gpl.rpg.AndorsTrail.model.ability.ActorConditionType;
 import com.gpl.rpg.AndorsTrail.model.ability.SkillCollection;
@@ -21,6 +21,8 @@ import com.gpl.rpg.AndorsTrail.util.ConstRange;
 public final class SkillController {
 	private final ControllerContext controllers;
 	private final WorldContext world;
+	public final CombatActionListeners combatActionListeners = new CombatActionListeners();
+	
 
 	public SkillController(ControllerContext controllers, WorldContext world) {
 		this.controllers = controllers;
@@ -70,7 +72,7 @@ public final class SkillController {
 		if (player == null) return 0;
 		if (!ItemTypeCollection.isGoldItemType(item.itemType.id)) return 0;
 
-		return getRollBias(item, player, SkillID.coinfinder, SkillCollection.PER_SKILLPOINT_INCREASE_COINFINDER_QUANTITY_PERCENT);
+		return getRollBias(item.quantity, player, SkillID.coinfinder, SkillCollection.PER_SKILLPOINT_INCREASE_COINFINDER_QUANTITY_PERCENT);
 	}
 
 	private static int getRollBias(DropItem item, Player player, SkillID skill, int perSkillpointIncrease) {
@@ -80,7 +82,7 @@ public final class SkillController {
 	private static int getRollBias(ConstRange chance, Player player, SkillID skill, int perSkillpointIncrease) {
 		int skillLevel = player.getSkillLevel(skill);
 		if (skillLevel <= 0) return 0;
-		return chance.current * skillLevel * perSkillpointIncrease / 100;
+		return chance.current * skillLevel * perSkillpointIncrease;
 	}
 
 
@@ -124,6 +126,9 @@ public final class SkillController {
 		int result = 0;
 		result += getActorConditionEffectChanceRollBiasFromResistanceSkills(effect, player);
 		result += getActorConditionEffectChanceRollBias(effect, player, SkillID.shadowBless, SkillCollection.PER_SKILLPOINT_INCREASE_RESISTANCE_SHADOW_BLESS);
+		if ("spore_poison".equals(effect.conditionType.conditionTypeID)) {
+			result += getActorConditionEffectChanceRollBias(effect, player, SkillID.sporeImmunity, 100);
+		}
 		return result;
 	}
 
@@ -136,6 +141,7 @@ public final class SkillController {
 			skill = SkillID.resistancePhysical; break;
 		case blood:
 			skill = SkillID.resistanceBlood; break;
+		case spiritual:
 		default:
 			return 0;
 		}
@@ -184,6 +190,7 @@ public final class SkillController {
 	public void applySkillEffectsFromMonsterAttack(AttackResult result, Monster monster) {
 		if (!result.isHit) {
 			if (rollForSkillChance(world.model.player, SkillID.taunt, SkillCollection.PER_SKILLPOINT_INCREASE_TAUNT_CHANCE)) {
+				combatActionListeners.onPlayerTauntsMonster(monster);
 				controllers.actorStatsController.changeActorAP(monster, -SkillCollection.TAUNT_AP_LOSS, false, false);
 			}
 		}
@@ -283,8 +290,10 @@ public final class SkillController {
 			else if (itemCategoryID.equals("axe") || itemCategoryID.equals("axe2h"))
 				return SkillID.weaponProficiencyAxe;
 			else if (itemCategoryID.equals("club") || itemCategoryID.equals("staff") || itemCategoryID.equals("mace")
-					|| itemCategoryID.equals("scepter") || itemCategoryID.equals("hammer") || itemCategoryID.equals("hammer2h"))
+					|| itemCategoryID.equals("scepter") || itemCategoryID.equals("hammer") || itemCategoryID.equals("hammer2h") || itemCategoryID.equals("whip"))
 				return SkillID.weaponProficiencyBlunt;
+            else if (itemCategoryID.equals("pole"))
+                return SkillID.weaponProficiencyPole;
 		} else if (category.isShield()) {
 			return SkillID.armorProficiencyShield;
 		} else if (category.isArmor()) {
@@ -301,6 +310,15 @@ public final class SkillController {
 		ItemType mainHandItem = player.inventory.getItemTypeInWearSlot(Inventory.WearSlot.weapon);
 		ItemType offHandItem = player.inventory.getItemTypeInWearSlot(Inventory.WearSlot.shield);
 
+		final int skillLevelFightStyleUnarmedUnarmored = player.getSkillLevel(SkillID.fightstyleUnarmedUnarmored);
+		if (skillLevelFightStyleUnarmedUnarmored > 0 && isUnarmored(player) && mainHandItem == null && offHandItem == null) {
+			player.blockChance += SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_UNARMORED_BC * skillLevelFightStyleUnarmedUnarmored;
+			player.damageResistance += SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_UNARMORED_DR * skillLevelFightStyleUnarmedUnarmored;
+			player.attackChance += SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_UNARMORED_AC * skillLevelFightStyleUnarmedUnarmored;
+			player.damagePotential.addToMax(SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_UNARMORED_DMG_MAX * skillLevelFightStyleUnarmedUnarmored);
+			player.criticalMultiplier = 1 + ((float)SkillCollection.PER_SKILLPOINT_INCREASE_UNARMED_UNARMORED_CM_PERCENT / 100) * skillLevelFightStyleUnarmedUnarmored;
+        }
+
 		if (isWielding2HandItem(mainHandItem, offHandItem)) {
 			int skillLevelFightStyle = player.getSkillLevel(SkillID.fightstyle2hand);
 			int skillLevelSpecialization = player.getSkillLevel(SkillID.specialization2hand);
@@ -327,12 +345,16 @@ public final class SkillController {
 				if (skillLevelFightStyle == 2) {
 					percent = SkillCollection.DUALWIELD_EFFICIENCY_LEVEL2;
 					playerTraits.attackCost = Math.max(attackCostMainHand, attackCostOffHand);
+					playerTraits.criticalMultiplier = Math.max(mainHandItem.effects_equip.stats.setCriticalMultiplier, getPercentage(offHandItem.effects_equip.stats.setCriticalMultiplier, SkillCollection.DUALWIELD_EFFICIENCY_LEVEL2, 0));
 				} else if (skillLevelFightStyle == 1) {
 					percent = SkillCollection.DUALWIELD_EFFICIENCY_LEVEL1;
-					playerTraits.attackCost = attackCostMainHand + getPercentage(attackCostOffHand, SkillCollection.DUALWIELD_LEVEL1_OFFHAND_AP_COST_PERCENT, 0);
+					//Take into account the case where the worst weapon AP-wise is in the off-hand.
+					playerTraits.attackCost = Math.max(attackCostMainHand, attackCostOffHand) + getPercentage( Math.min(attackCostMainHand, attackCostOffHand), SkillCollection.DUALWIELD_LEVEL1_OFFHAND_AP_COST_PERCENT, 0);
+					playerTraits.criticalMultiplier = Math.max(mainHandItem.effects_equip.stats.setCriticalMultiplier, getPercentage(offHandItem.effects_equip.stats.setCriticalMultiplier, SkillCollection.DUALWIELD_EFFICIENCY_LEVEL1, 0));
 				} else {
 					percent = SkillCollection.DUALWIELD_EFFICIENCY_LEVEL0;
 					playerTraits.attackCost = attackCostMainHand + attackCostOffHand;
+					playerTraits.criticalMultiplier = Math.max(mainHandItem.effects_equip.stats.setCriticalMultiplier, getPercentage(offHandItem.effects_equip.stats.setCriticalMultiplier, SkillCollection.DUALWIELD_EFFICIENCY_LEVEL0, 0));
 				}
 
 				final int skillLevel = getSkillLevelForItemType(player, offHandItem);
@@ -344,6 +366,14 @@ public final class SkillController {
 				addPercentBlockChance(player, offHandItem, percent, 100);
 				addPercentDamage(player, offHandItem, percent, 100);
 				addPercentCriticalSkill(player, offHandItem, percent, 100);
+				addPercentMaxHPBoost(player, offHandItem, percent, 100);
+				addPercentDamageResistance(player, offHandItem, percent, 100);
+				addPercentMaxAPBoost(player, offHandItem, percent, 100);
+				//Reversed parameters, as a positive value is a malus for these...
+				addPercentMoveCost(player, offHandItem, 100, percent);
+				addPercentReequipCost(player, offHandItem, 100, percent);
+				addPercentUseItemCost(player, offHandItem, 100, percent);
+				
 			}
 
 			int skillLevelSpecialization = player.getSkillLevel(SkillID.specializationDualWield);
@@ -368,20 +398,65 @@ public final class SkillController {
 		if (itemType.effects_equip == null) return;
 		player.damagePotential.addToMax(getPercentage(itemType.effects_equip.stats.increaseMaxDamage, percentForPositiveValues, percentForNegativeValues));
 		player.damagePotential.add(getPercentage(itemType.effects_equip.stats.increaseMinDamage, percentForPositiveValues, percentForNegativeValues), false);
+
+		if (itemType.isWeapon()) {
+			player.weaponDamage.addToMax(getPercentage(itemType.effects_equip.stats.increaseMaxDamage, percentForPositiveValues, percentForNegativeValues));
+			player.weaponDamage.add(getPercentage(itemType.effects_equip.stats.increaseMinDamage, percentForPositiveValues, percentForNegativeValues), false);
+		}
 	}
 
 	private static void addPercentCriticalSkill(Player player, ItemType itemType, int percentForPositiveValues, int percentForNegativeValues) {
 		if (itemType.effects_equip == null) return;
 		player.criticalSkill += getPercentage(itemType.effects_equip.stats.increaseCriticalSkill, percentForPositiveValues, percentForNegativeValues);
 	}
+	
+	private static void addPercentMaxHPBoost(Player player, ItemType itemType, int percentForPositiveValues, int percentForNegativeValues) {
+		if (itemType.effects_equip == null) return;
+		player.health.addToMax(getPercentage(itemType.effects_equip.stats.increaseMaxHP, percentForPositiveValues, percentForNegativeValues));
+	}
+	
+	private static void addPercentDamageResistance(Player player, ItemType itemType, int percentForPositiveValues, int percentForNegativeValues) {
+		if (itemType.effects_equip == null) return;
+		player.damageResistance += getPercentage(itemType.effects_equip.stats.increaseDamageResistance, percentForPositiveValues, percentForNegativeValues);
+	}
+	
+	private static void addPercentMaxAPBoost(Player player, ItemType itemType, int percentForPositiveValues, int percentForNegativeValues) {
+		if (itemType.effects_equip == null) return;
+		player.ap.addToMax(getPercentage(itemType.effects_equip.stats.increaseMaxAP, percentForPositiveValues, percentForNegativeValues));
+	}
+	
+	private static void addPercentMoveCost(Player player, ItemType itemType, int percentForPositiveValues, int percentForNegativeValues) {
+		if (itemType.effects_equip == null) return;
+		player.moveCost += getPercentage(itemType.effects_equip.stats.increaseMoveCost, percentForPositiveValues, percentForNegativeValues);
+	}
+	
+	private static void addPercentUseItemCost(Player player, ItemType itemType, int percentForPositiveValues, int percentForNegativeValues) {
+		if (itemType.effects_equip == null) return;
+		player.useItemCost += getPercentage(itemType.effects_equip.stats.increaseUseItemCost, percentForPositiveValues, percentForNegativeValues);
+	}
+	
+	private static void addPercentReequipCost(Player player, ItemType itemType, int percentForPositiveValues, int percentForNegativeValues) {
+		if (itemType.effects_equip == null) return;
+		player.reequipCost += getPercentage(itemType.effects_equip.stats.increaseReequipCost, percentForPositiveValues, percentForNegativeValues);
+	}
 
 	private static int getPercentage(int originalValue, int percentForPositiveValues, int percentForNegativeValues) {
 		if (originalValue == 0) {
 			return 0;
 		} else if (originalValue > 0) {
-			return (int) FloatMath.floor(originalValue * percentForPositiveValues / 100.0f);
+			return (int) Math.floor(originalValue * percentForPositiveValues / 100.0f);
 		} else {
-			return (int) FloatMath.floor(originalValue * percentForNegativeValues / 100.0f);
+			return (int) Math.floor(originalValue * percentForNegativeValues / 100.0f);
+		}
+	}
+	
+	private static float getPercentage(float originalValue, int percentForPositiveValues, int percentForNegativeValues) {
+		if (originalValue == 0) {
+			return 0;
+		} else if (originalValue > 0) {
+			return originalValue * percentForPositiveValues / 100.0f;
+		} else {
+			return originalValue * percentForNegativeValues / 100.0f;
 		}
 	}
 

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/VisualEffectController.java

@@ -3,10 +3,14 @@ package com.gpl.rpg.AndorsTrail.controller;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Paint.Align;
+import android.graphics.Rect;
 import android.os.Handler;
+
+import com.gpl.rpg.AndorsTrail.AndorsTrailPreferences;
 import com.gpl.rpg.AndorsTrail.context.ControllerContext;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.controller.listeners.VisualEffectFrameListeners;
+import com.gpl.rpg.AndorsTrail.model.actor.Actor;
 import com.gpl.rpg.AndorsTrail.model.actor.Monster;
 import com.gpl.rpg.AndorsTrail.model.actor.MonsterType;
 import com.gpl.rpg.AndorsTrail.model.map.PredefinedMap;
@@ -25,14 +29,14 @@ public final class VisualEffectController {
 	private final VisualEffectCollection effectTypes;
 
 	public final VisualEffectFrameListeners visualEffectFrameListeners = new VisualEffectFrameListeners();
-
+	
 	public VisualEffectController(ControllerContext controllers, WorldContext world) {
 		this.controllers = controllers;
 		this.world = world;
 		this.effectTypes = world.visualEffectTypes;
 	}
 
-	public void startEffect(Coord position, VisualEffectCollection.VisualEffectID effectID, int displayValue, VisualEffectCompletedCallback callback, int callbackValue) {
+	public void startEffect(Coord position, VisualEffectCollection.VisualEffectID effectID, String displayValue, VisualEffectCompletedCallback callback, int callbackValue) {
 		++effectCount;
 		(new VisualEffectAnimation(effectTypes.getVisualEffect(effectID), position, displayValue, callback, callbackValue))
 		.start();
@@ -50,20 +54,96 @@ public final class VisualEffectController {
 	}
 	public void startEnqueuedEffect(Coord position) {
 		if (enqueuedEffectID == null) return;
-		startEffect(position, enqueuedEffectID, enqueuedEffectValue, null, 0);
+		startEffect(position, enqueuedEffectID, (enqueuedEffectValue == 0) ? null : String.valueOf(enqueuedEffectValue), null, 0);
 		enqueuedEffectID = null;
 		enqueuedEffectValue = 0;
 	}
+	
+	public void startActorMoveEffect(Actor actor, PredefinedMap map, Coord origin, Coord destination, int duration, VisualEffectCompletedCallback callback, int callbackValue) {
+		++effectCount;
+		(new SpriteMoveAnimation(origin, destination, duration, actor, map, callback, callbackValue))
+		.start();
+	}
 
+	public final class SpriteMoveAnimation extends Handler implements Runnable {
+		
+//		private static final int millisecondsPerFrame=25;
+		
+		private final VisualEffectCompletedCallback callback;
+		private final int callbackValue;
+
+		public final int duration;
+		public final Actor actor;
+		public final PredefinedMap map;
+		public final Coord origin;
+		public final Coord destination;
+		
+		
+		@Override
+		public void run() {
+			onCompleted();
+//			update();
+//			if (System.currentTimeMillis() - actor.vfxStartTime >= duration) {
+//			} else {
+//				postDelayed(this, millisecondsPerFrame);
+//			}
+		}
+		
+		public SpriteMoveAnimation(Coord origin, Coord destination, int duration, Actor actor, PredefinedMap map, VisualEffectCompletedCallback callback, int callbackValue) {
+			this.callback = callback;
+			this.callbackValue = callbackValue;
+			this.duration = duration;
+			this.actor = actor;
+			this.map = map;
+			this.origin = origin;
+			this.destination = destination;
+
+		}
+		
+//		private void update() {
+//			
+//			visualEffectFrameListeners.onNewSpriteMoveFrame(this);
+//		}
+
+		private void onCompleted() {
+			--effectCount;
+			actor.hasVFXRunning = false;
+			if (callback != null) callback.onVisualEffectCompleted(callbackValue);
+			visualEffectFrameListeners.onSpriteMoveCompleted(this);
+		}
+		
+
+		public void start() {
+			actor.hasVFXRunning = true;
+			actor.vfxDuration = duration;
+			actor.vfxStartTime = System.currentTimeMillis();
+			visualEffectFrameListeners.onSpriteMoveStarted(this);
+			if (duration == 0 || !controllers.preferences.enableUiAnimations) onCompleted();
+			else {
+				postDelayed(this, duration);
+			}
+		}
+		
+		
+		
+	}
+
+	public static final Paint textPaint = new Paint();
+	static {
+		textPaint.setShadowLayer(2, 1, 1, Color.DKGRAY);
+		textPaint.setAlpha(255);
+		textPaint.setTextAlign(Align.CENTER);
+	}
+	
 	public final class VisualEffectAnimation extends Handler implements Runnable {
 
 		@Override
 		public void run() {
-			update();
-			if (currentFrame == effect.lastFrame) {
+			if (currentFrame >= effect.lastFrame) {
 				onCompleted();
 			} else {
-				postDelayed(this, effect.millisecondPerFrame);
+				postDelayed(this, effect.millisecondPerFrame * controllers.preferences.attackspeed_milliseconds / AndorsTrailPreferences.ATTACKSPEED_DEFAULT_MILLISECONDS);
+				update();
 			}
 		}
 
@@ -74,7 +154,7 @@ public final class VisualEffectController {
 			int tileID = effect.frameIconIDs[frame];
 			int textYOffset = -2 * (frame);
 			if (frame >= beginFadeAtFrame && displayText != null) {
-				this.textPaint.setAlpha(255 * (effect.lastFrame - frame) / (effect.lastFrame - beginFadeAtFrame));
+				textPaint.setAlpha(255 * (effect.lastFrame - frame) / (effect.lastFrame - beginFadeAtFrame));
 			}
 			area.topLeft.y = position.y - 1;
 			visualEffectFrameListeners.onNewAnimationFrame(this, tileID, textYOffset);
@@ -87,7 +167,8 @@ public final class VisualEffectController {
 		}
 
 		public void start() {
-			postDelayed(this, 0);
+			if (!controllers.preferences.enableUiAnimations) onCompleted();
+			else postDelayed(this, 0);
 		}
 
 		private int currentFrame = 0;
@@ -97,25 +178,29 @@ public final class VisualEffectController {
 		public final Coord position;
 		public final String displayText;
 		public final CoordRect area;
-		public final Paint textPaint = new Paint();
 		private final int beginFadeAtFrame;
 		private final VisualEffectCompletedCallback callback;
 		private final int callbackValue;
 
-		public VisualEffectAnimation(VisualEffect effect, Coord position, int displayValue, VisualEffectCompletedCallback callback, int callbackValue) {
+		public VisualEffectAnimation(VisualEffect effect, Coord position, String displayValue, VisualEffectCompletedCallback callback, int callbackValue) {
 			this.position = position;
 			this.callback = callback;
 			this.callbackValue = callbackValue;
-			this.area = new CoordRect(new Coord(position.x, position.y - 1), new Size(1, 2));
 			this.effect = effect;
-			this.displayText = (displayValue == 0) ? null : String.valueOf(displayValue);
-			this.textPaint.setColor(effect.textColor);
-			this.textPaint.setShadowLayer(2, 1, 1, Color.DKGRAY);
-			this.textPaint.setTextSize(world.tileManager.viewTileSize * 0.5f); // 32dp.
-			this.textPaint.setAlpha(255);
-			this.textPaint.setTextAlign(Align.CENTER);
+			this.displayText = displayValue == null ? "" : displayValue;
+			textPaint.setColor(effect.textColor);
+			textPaint.setTextSize(world.tileManager.tileSize * 0.5f); // 32dp.
+			Rect textBounds = new Rect();
+			textPaint.getTextBounds(displayText, 0, displayText.length(), textBounds);
+			int widthNeededInTiles = 1 + (textBounds.width() / world.tileManager.tileSize);
+			if (widthNeededInTiles % 2 == 0) widthNeededInTiles++;
+			this.area = new CoordRect(new Coord(position.x - (widthNeededInTiles / 2), position.y - 1), new Size(widthNeededInTiles, 2));
 			this.beginFadeAtFrame = effect.lastFrame / 2;
 		}
+		
+		public Paint getTextPaint(){
+			return textPaint;
+		}
 	}
 
 	public static interface VisualEffectCompletedCallback {
@@ -183,4 +268,10 @@ public final class VisualEffectController {
 			return -1;
 		}
 	}
+	
+	public void asyncUpdateArea(CoordRect area) {
+		visualEffectFrameListeners.onAsyncAreaUpdate(area);
+	}
+
+	
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/WorldMapController.java

@@ -1,5 +1,13 @@
 package com.gpl.rpg.AndorsTrail.controller;
 
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
 import android.content.Context;
 import android.content.Intent;
 import android.content.res.Resources;
@@ -8,8 +16,8 @@ import android.graphics.Bitmap.Config;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.os.AsyncTask;
-import android.os.Environment;
 import android.widget.Toast;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.activity.DisplayWorldMapActivity;
@@ -21,30 +29,23 @@ import com.gpl.rpg.AndorsTrail.model.map.WorldMapSegment;
 import com.gpl.rpg.AndorsTrail.model.map.WorldMapSegment.NamedWorldMapArea;
 import com.gpl.rpg.AndorsTrail.model.map.WorldMapSegment.WorldMapSegmentMap;
 import com.gpl.rpg.AndorsTrail.resource.tiles.TileCollection;
+import com.gpl.rpg.AndorsTrail.util.AndroidStorage;
 import com.gpl.rpg.AndorsTrail.util.Coord;
 import com.gpl.rpg.AndorsTrail.util.CoordRect;
 import com.gpl.rpg.AndorsTrail.util.L;
 import com.gpl.rpg.AndorsTrail.util.Size;
 
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-
 public final class WorldMapController {
 
 	private static final int WORLDMAP_SCREENSHOT_TILESIZE = 8;
 	public static final int WORLDMAP_DISPLAY_TILESIZE = WORLDMAP_SCREENSHOT_TILESIZE;
 
-	public static void updateWorldMap(final WorldContext world, final Resources res) {
-		updateWorldMap(world, world.model.currentMap, world.model.currentTileMap, world.tileManager.currentMapTiles, res);
+	public static void updateWorldMap(Context context, final WorldContext world, final Resources res) {
+		updateWorldMap(context, world, world.model.currentMaps.map, world.model.currentMaps.tileMap, world.model.currentMaps.tiles, res);
 	}
 
 	private static void updateWorldMap(
-			final WorldContext world,
+			Context context, final WorldContext world,
 			final PredefinedMap map,
 			final LayeredTileMap mapTiles,
 			final TileCollection cachedTiles,
@@ -52,15 +53,15 @@ public final class WorldMapController {
 		final String worldMapSegmentName = world.maps.getWorldMapSegmentNameForMap(map.name);
 		if (worldMapSegmentName == null) return;
 
-		if (!shouldUpdateWorldMap(map, worldMapSegmentName, world.maps.worldMapRequiresUpdate)) return;
+		if (!shouldUpdateWorldMap(context, map, worldMapSegmentName, world.maps.worldMapRequiresUpdate)) return;
 
 		(new AsyncTask<Void, Void, Void>() {
 			@Override
 			protected Void doInBackground(Void... arg0) {
 				final MapRenderer renderer = new MapRenderer(world, map, mapTiles, cachedTiles);
 				try {
-					updateCachedBitmap(map, renderer);
-					updateWorldMapSegment(res, world, worldMapSegmentName);
+					updateCachedBitmap(context, map, renderer);
+					updateWorldMapSegment(context, res, world, worldMapSegmentName);
 					world.maps.worldMapRequiresUpdate = false;
 					if (AndorsTrailApplication.DEVELOPMENT_DEBUGMESSAGES) {
 						L.log("WorldMapController: Updated worldmap segment " + worldMapSegmentName + " for map " + map.name);
@@ -73,22 +74,22 @@ public final class WorldMapController {
 		}).execute();
 	}
 
-	private static boolean shouldUpdateWorldMap(PredefinedMap map, String worldMapSegmentName, boolean forceUpdate) {
+	private static boolean shouldUpdateWorldMap(Context context, PredefinedMap map, String worldMapSegmentName, boolean forceUpdate) {
 		if (forceUpdate) return true;
 		if (!map.visited) return true;
-		File file = getFileForMap(map, false);
+		File file = getFileForMap(context, map, false);
 		if (!file.exists()) return true;
 
-		file = getCombinedWorldMapFile(worldMapSegmentName);
+		file = getCombinedWorldMapFile(context, worldMapSegmentName);
 		if (!file.exists()) return true;
 
 		return false;
 	}
 
-	private static void updateCachedBitmap(PredefinedMap map, MapRenderer renderer) throws IOException {
-		ensureWorldmapDirectoryExists();
+	private static void updateCachedBitmap(Context context, PredefinedMap map, MapRenderer renderer) throws IOException {
+		ensureWorldmapDirectoryExists(context);
 
-		File file = getFileForMap(map, false);
+		File file = getFileForMap(context, map, false);
 		if (file.exists()) return;
 
 		Bitmap image = renderer.drawMap();
@@ -114,7 +115,7 @@ public final class WorldMapController {
 			this.cachedTiles = cachedTiles;
 			this.tileSize = world.tileManager.tileSize;
 			this.scale = (float) WORLDMAP_SCREENSHOT_TILESIZE / world.tileManager.tileSize;
-			mapTiles.setColorFilter(mPaint);
+			mapTiles.setColorFilter(mPaint, null, true);
 		}
 
 		public Bitmap drawMap() {
@@ -124,9 +125,11 @@ public final class WorldMapController {
 			canvas.scale(scale, scale);
 
 			synchronized (cachedTiles) {
-				drawMapLayer(canvas, mapTiles.currentLayout.layerGround);
+				tryDrawMapLayer(canvas, mapTiles.currentLayout.layerBase);
+				tryDrawMapLayer(canvas, mapTiles.currentLayout.layerGround);
 				tryDrawMapLayer(canvas, mapTiles.currentLayout.layerObjects);
 				tryDrawMapLayer(canvas, mapTiles.currentLayout.layerAbove);
+				tryDrawMapLayer(canvas, mapTiles.currentLayout.layerTop);
 			}
 			return image;
 		}
@@ -148,9 +151,8 @@ public final class WorldMapController {
 		}
 	}
 
-	private static void ensureWorldmapDirectoryExists() throws IOException {
-		File root = Environment.getExternalStorageDirectory();
-		File dir = new File(root, Constants.FILENAME_SAVEGAME_DIRECTORY);
+	private static void ensureWorldmapDirectoryExists(Context context) throws IOException {
+		File dir = AndroidStorage.getStorageDirectory(context, Constants.FILENAME_SAVEGAME_DIRECTORY);
 		if (!dir.exists()) dir.mkdir();
 		dir = new File(dir, Constants.FILENAME_WORLDMAP_DIRECTORY);
 		if (!dir.exists()) dir.mkdir();
@@ -158,27 +160,32 @@ public final class WorldMapController {
 		File noMediaFile = new File(dir, ".nomedia");
 		if (!noMediaFile.exists()) noMediaFile.createNewFile();
 	}
-	private static File getFileForMap(PredefinedMap map, boolean verifyFileExists) {
+	public static boolean fileForMapExists(Context context, PredefinedMap map) {
 		if (map.lastSeenLayoutHash.length() > 0) {
-			File fileWithHash = getPngFile(map.name + "." + map.lastSeenLayoutHash);
+			return getPngFile(context, map.name + '.' + map.lastSeenLayoutHash).exists();
+		}
+		return getPngFile(context, map.name).exists();
+	}
+	private static File getFileForMap(Context context, PredefinedMap map, boolean verifyFileExists) {
+		if (map.lastSeenLayoutHash.length() > 0) {
+			File fileWithHash = getPngFile(context, map.name + '.' + map.lastSeenLayoutHash);
 			if (!verifyFileExists) return fileWithHash;
 			else if (fileWithHash.exists()) return fileWithHash;
 		}
-		return getPngFile(map.name);
+		return getPngFile(context, map.name);
 	}
-	private static File getPngFile(String fileName) {
-		return new File(getWorldmapDirectory(), fileName + ".png");
+	private static File getPngFile(Context context, String fileName) {
+		return new File(getWorldmapDirectory(context), fileName + ".png");
 	}
-	private static File getWorldmapDirectory() {
-		File dir = Environment.getExternalStorageDirectory();
-		dir = new File(dir, Constants.FILENAME_SAVEGAME_DIRECTORY);
+	private static File getWorldmapDirectory(Context context) {
+		File dir = AndroidStorage.getStorageDirectory(context, Constants.FILENAME_SAVEGAME_DIRECTORY);
 		return new File(dir, Constants.FILENAME_WORLDMAP_DIRECTORY);
 	}
-	public static File getCombinedWorldMapFile(String segmentName) {
-		return new File(getWorldmapDirectory(), Constants.FILENAME_WORLDMAP_HTMLFILE_PREFIX + segmentName + Constants.FILENAME_WORLDMAP_HTMLFILE_SUFFIX);
+	public static File getCombinedWorldMapFile(Context context, String segmentName) {
+		return new File(getWorldmapDirectory(context), Constants.FILENAME_WORLDMAP_HTMLFILE_PREFIX + segmentName + Constants.FILENAME_WORLDMAP_HTMLFILE_SUFFIX);
 	}
 
-	private static String getWorldMapSegmentAsHtml(Resources res, WorldContext world, String segmentName) {
+	private static String getWorldMapSegmentAsHtml(Context context, Resources res, WorldContext world, String segmentName) {
 		WorldMapSegment segment = world.maps.worldMapSegments.get(segmentName);
 
 		Map<String, File> displayedMapFilenamesPerMapName = new HashMap<String, File>(segment.maps.size());
@@ -187,7 +194,7 @@ public final class WorldMapController {
 			PredefinedMap predefinedMap = world.maps.findPredefinedMap(map.mapName);
 			if (predefinedMap == null) continue;
 			if (!predefinedMap.visited) continue;
-			File f = WorldMapController.getFileForMap(predefinedMap, true);
+			File f = WorldMapController.getFileForMap(context, predefinedMap, true);
 			if (!f.exists()) continue;
 			displayedMapFilenamesPerMapName.put(map.mapName, f);
 
@@ -286,16 +293,16 @@ public final class WorldMapController {
 		return new CoordRect(topLeft, new Size(bottomRight.x - topLeft.x, bottomRight.y - topLeft.y));
 	}
 
-	private static void updateWorldMapSegment(Resources res, WorldContext world, String segmentName) throws IOException {
-		String mapAsHtml = getWorldMapSegmentAsHtml(res, world, segmentName);
-		File outputFile = getCombinedWorldMapFile(segmentName);
+	public static void updateWorldMapSegment(Context context, Resources res, WorldContext world, String segmentName) throws IOException {
+		String mapAsHtml = getWorldMapSegmentAsHtml(context, res, world, segmentName);
+		File outputFile = getCombinedWorldMapFile(context, segmentName);
 		PrintWriter pw = new PrintWriter(outputFile);
 		pw.write(mapAsHtml);
 		pw.close();
 	}
 
 	public static boolean displayWorldMap(Context context, WorldContext world) {
-		String worldMapSegmentName = world.maps.getWorldMapSegmentNameForMap(world.model.currentMap.name);
+		String worldMapSegmentName = world.maps.getWorldMapSegmentNameForMap(world.model.currentMaps.map.name);
 		if (worldMapSegmentName == null) {
 			Toast.makeText(context, context.getResources().getString(R.string.display_worldmap_not_available), Toast.LENGTH_LONG).show();
 			return false;

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/listeners/ActorConditionListener.java

@@ -9,4 +9,7 @@ public interface ActorConditionListener {
 	public void onActorConditionDurationChanged(Actor actor, ActorCondition condition);
 	public void onActorConditionMagnitudeChanged(Actor actor, ActorCondition condition);
 	public void onActorConditionRoundEffectApplied(Actor actor, ActorCondition condition);
+	public void onActorConditionImmunityAdded(Actor actor, ActorCondition condition);
+	public void onActorConditionImmunityRemoved(Actor actor, ActorCondition condition);
+	public void onActorConditionImmunityDurationChanged(Actor actor, ActorCondition condition);
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/listeners/ActorConditionListeners.java

@@ -21,7 +21,16 @@ public final class ActorConditionListeners extends ListOfListeners<ActorConditio
 	private final Function2<ActorConditionListener, Actor, ActorCondition> onActorConditionRoundEffectApplied = new Function2<ActorConditionListener, Actor, ActorCondition>() {
 		@Override public void call(ActorConditionListener listener, Actor actor, ActorCondition condition) { listener.onActorConditionRoundEffectApplied(actor, condition); }
 	};
-
+	private final Function2<ActorConditionListener, Actor, ActorCondition> onActorConditionImmunityAdded = new Function2<ActorConditionListener, Actor, ActorCondition>() {
+		@Override public void call(ActorConditionListener listener, Actor actor, ActorCondition condition) { listener.onActorConditionImmunityAdded(actor, condition); }
+	};
+	private final Function2<ActorConditionListener, Actor, ActorCondition> onActorConditionImmunityRemoved = new Function2<ActorConditionListener, Actor, ActorCondition>() {
+		@Override public void call(ActorConditionListener listener, Actor actor, ActorCondition condition) { listener.onActorConditionImmunityRemoved(actor, condition); }
+	};
+	private final Function2<ActorConditionListener, Actor, ActorCondition> onActorConditionImmunityDurationChanged = new Function2<ActorConditionListener, Actor, ActorCondition>() {
+		@Override public void call(ActorConditionListener listener, Actor actor, ActorCondition condition) { listener.onActorConditionImmunityDurationChanged(actor, condition); }
+	};
+	
 	@Override
 	public void onActorConditionAdded(Actor actor, ActorCondition condition) {
 		callAllListeners(this.onActorConditionAdded, actor, condition);
@@ -46,4 +55,20 @@ public final class ActorConditionListeners extends ListOfListeners<ActorConditio
 	public void onActorConditionRoundEffectApplied(Actor actor, ActorCondition condition) {
 		callAllListeners(this.onActorConditionRoundEffectApplied, actor, condition);
 	}
+	
+
+	@Override
+	public void onActorConditionImmunityAdded(Actor actor, ActorCondition condition) {
+		callAllListeners(this.onActorConditionImmunityAdded, actor, condition);
+	}
+
+	@Override
+	public void onActorConditionImmunityRemoved(Actor actor, ActorCondition condition) {
+		callAllListeners(this.onActorConditionImmunityRemoved, actor, condition);
+	}
+
+	@Override
+	public void onActorConditionImmunityDurationChanged(Actor actor, ActorCondition condition) {
+		callAllListeners(this.onActorConditionImmunityDurationChanged, actor, condition);
+	}
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/listeners/ActorStatsListener.java

@@ -1,10 +1,13 @@
 package com.gpl.rpg.AndorsTrail.controller.listeners;
 
 import com.gpl.rpg.AndorsTrail.model.actor.Actor;
+import com.gpl.rpg.AndorsTrail.model.actor.Player;
 
 public interface ActorStatsListener {
 	void onActorHealthChanged(Actor actor);
 	void onActorAPChanged(Actor actor);
 	void onActorAttackCostChanged(Actor actor, int newAttackCost);
 	void onActorMoveCostChanged(Actor actor, int newMoveCost);
+	void onPlayerReequipCostChanged(Player actor, int newAttackCost);
+	void onPlayerUseCostChanged(Player actor, int newMoveCost);
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/listeners/ActorStatsListeners.java

@@ -1,6 +1,7 @@
 package com.gpl.rpg.AndorsTrail.controller.listeners;
 
 import com.gpl.rpg.AndorsTrail.model.actor.Actor;
+import com.gpl.rpg.AndorsTrail.model.actor.Player;
 import com.gpl.rpg.AndorsTrail.util.ListOfListeners;
 
 public final class ActorStatsListeners extends ListOfListeners<ActorStatsListener> implements ActorStatsListener {
@@ -20,6 +21,14 @@ public final class ActorStatsListeners extends ListOfListeners<ActorStatsListene
 	private final Function2<ActorStatsListener, Actor, Integer> onActorMoveCostChanged = new Function2<ActorStatsListener, Actor, Integer>() {
 		@Override public void call(ActorStatsListener listener, Actor actor, Integer newMoveCost) { listener.onActorMoveCostChanged(actor, newMoveCost); }
 	};
+	
+	private final Function2<ActorStatsListener, Player, Integer> onPlayerReequipCostChanged = new Function2<ActorStatsListener, Player, Integer>() {
+		@Override public void call(ActorStatsListener listener, Player actor, Integer newAttackCost) { listener.onPlayerReequipCostChanged(actor, newAttackCost); }
+	};
+
+	private final Function2<ActorStatsListener, Player, Integer> onPlayerUseCostChanged = new Function2<ActorStatsListener, Player, Integer>() {
+		@Override public void call(ActorStatsListener listener, Player actor, Integer newMoveCost) { listener.onPlayerUseCostChanged(actor, newMoveCost); }
+	};
 
 	@Override
 	public void onActorHealthChanged(Actor actor) {
@@ -40,4 +49,15 @@ public final class ActorStatsListeners extends ListOfListeners<ActorStatsListene
 	public void onActorMoveCostChanged(Actor actor, int newMoveCost) {
 		callAllListeners(this.onActorMoveCostChanged, actor, newMoveCost);
 	}
+	
+
+	@Override
+	public void onPlayerReequipCostChanged(Player actor, int newAttackCost) {
+		callAllListeners(this.onPlayerReequipCostChanged, actor, newAttackCost);
+	}
+
+	@Override
+	public void onPlayerUseCostChanged(Player actor, int newMoveCost) {
+		callAllListeners(this.onPlayerUseCostChanged, actor, newMoveCost);
+	}
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/listeners/CombatActionListener.java

@@ -1,6 +1,7 @@
 package com.gpl.rpg.AndorsTrail.controller.listeners;
 
 import com.gpl.rpg.AndorsTrail.controller.AttackResult;
+import com.gpl.rpg.AndorsTrail.model.ability.ActorConditionEffect;
 import com.gpl.rpg.AndorsTrail.model.actor.Monster;
 
 public interface CombatActionListener {
@@ -13,4 +14,8 @@ public interface CombatActionListener {
 	void onPlayerStartedFleeing();
 	void onPlayerFailedFleeing();
 	void onPlayerDoesNotHaveEnoughAP();
+	void onPlayerTauntsMonster(Monster attacker);
+	void onPlayerReceviesActorCondition(ActorConditionEffect conditionEffect);
+	void onMonsterReceivesActorCondition(ActorConditionEffect conditionEffect, Monster target);
+	
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/listeners/CombatActionListeners.java

@@ -1,6 +1,7 @@
 package com.gpl.rpg.AndorsTrail.controller.listeners;
 
 import com.gpl.rpg.AndorsTrail.controller.AttackResult;
+import com.gpl.rpg.AndorsTrail.model.ability.ActorConditionEffect;
 import com.gpl.rpg.AndorsTrail.model.actor.Monster;
 import com.gpl.rpg.AndorsTrail.util.ListOfListeners;
 
@@ -41,6 +42,18 @@ public final class CombatActionListeners extends ListOfListeners<CombatActionLis
 	private final Function<CombatActionListener> onPlayerDoesNotHaveEnoughAP = new Function<CombatActionListener>() {
 		@Override public void call(CombatActionListener listener) { listener.onPlayerDoesNotHaveEnoughAP(); }
 	};
+	
+	private final Function1<CombatActionListener, Monster> onPlayerTauntsMonster = new Function1<CombatActionListener, Monster>() {
+		@Override public void call(CombatActionListener listener, Monster attacker) { listener.onPlayerTauntsMonster(attacker); }
+	};
+	
+	private final Function1<CombatActionListener, ActorConditionEffect> onPlayerReceviesActorCondition = new Function1<CombatActionListener, ActorConditionEffect>() {
+		@Override public void call(CombatActionListener listener, ActorConditionEffect effect) { listener.onPlayerReceviesActorCondition(effect); }
+	};
+	
+	private final Function2<CombatActionListener, ActorConditionEffect, Monster> onMonsterReceivesActorCondition = new Function2<CombatActionListener, ActorConditionEffect, Monster>() {
+		@Override public void call(CombatActionListener listener, ActorConditionEffect effect, Monster target) { listener.onMonsterReceivesActorCondition(effect, target); }
+	};
 
 	@Override
 	public void onPlayerAttackMissed(Monster target, AttackResult attackResult) {
@@ -86,4 +99,20 @@ public final class CombatActionListeners extends ListOfListeners<CombatActionLis
 	public void onPlayerDoesNotHaveEnoughAP() {
 		callAllListeners(this.onPlayerDoesNotHaveEnoughAP);
 	}
+
+	@Override
+	public void onPlayerTauntsMonster(Monster attacker) {
+		callAllListeners(this.onPlayerTauntsMonster, attacker);
+	}
+
+	@Override
+	public void onPlayerReceviesActorCondition(ActorConditionEffect effect) {
+		callAllListeners(this.onPlayerReceviesActorCondition, effect);
+	}
+
+	@Override
+	public void onMonsterReceivesActorCondition(ActorConditionEffect effect, Monster target) {
+		callAllListeners(this.onMonsterReceivesActorCondition, effect, target);
+	}
+
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/listeners/PlayerMovementListener.java

@@ -4,6 +4,6 @@ import com.gpl.rpg.AndorsTrail.model.map.PredefinedMap;
 import com.gpl.rpg.AndorsTrail.util.Coord;
 
 public interface PlayerMovementListener {
-	void onPlayerMoved(Coord newPosition, Coord previousPosition);
+	void onPlayerMoved(PredefinedMap map, Coord newPosition, Coord previousPosition);
 	void onPlayerEnteredNewMap(PredefinedMap map, Coord p);
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/listeners/PlayerMovementListeners.java

@@ -6,8 +6,8 @@ import com.gpl.rpg.AndorsTrail.util.ListOfListeners;
 
 public final class PlayerMovementListeners extends ListOfListeners<PlayerMovementListener> implements PlayerMovementListener {
 
-	private final Function2<PlayerMovementListener, Coord, Coord> onPlayerMoved = new Function2<PlayerMovementListener, Coord, Coord>() {
-		@Override public void call(PlayerMovementListener listener, Coord newPosition, Coord previousPosition) { listener.onPlayerMoved(newPosition, previousPosition); }
+	private final Function3<PlayerMovementListener, PredefinedMap, Coord, Coord> onPlayerMoved = new Function3<PlayerMovementListener, PredefinedMap, Coord, Coord>() {
+		@Override public void call(PlayerMovementListener listener, PredefinedMap map, Coord newPosition, Coord previousPosition) { listener.onPlayerMoved(map, newPosition, previousPosition); }
 	};
 
 	private final Function2<PlayerMovementListener, PredefinedMap, Coord> onPlayerEnteredNewMap = new Function2<PlayerMovementListener, PredefinedMap, Coord>() {
@@ -15,8 +15,8 @@ public final class PlayerMovementListeners extends ListOfListeners<PlayerMovemen
 	};
 
 	@Override
-	public void onPlayerMoved(Coord newPosition, Coord previousPosition) {
-		callAllListeners(this.onPlayerMoved, newPosition, previousPosition);
+	public void onPlayerMoved(PredefinedMap map, Coord newPosition, Coord previousPosition) {
+		callAllListeners(this.onPlayerMoved, map, newPosition, previousPosition);
 	}
 
 	@Override

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/listeners/VisualEffectFrameListener.java

@@ -0,0 +1,14 @@
+package com.gpl.rpg.AndorsTrail.controller.listeners;
+
+import com.gpl.rpg.AndorsTrail.controller.VisualEffectController.SpriteMoveAnimation;
+import com.gpl.rpg.AndorsTrail.controller.VisualEffectController.VisualEffectAnimation;
+import com.gpl.rpg.AndorsTrail.util.CoordRect;
+
+public interface VisualEffectFrameListener {
+	void onNewAnimationFrame(VisualEffectAnimation animation, int tileID, int textYOffset);
+	void onAnimationCompleted(VisualEffectAnimation animation);
+	void onSpriteMoveStarted(SpriteMoveAnimation animation);
+	void onNewSpriteMoveFrame(SpriteMoveAnimation animation);
+	void onSpriteMoveCompleted(SpriteMoveAnimation animation);
+	void onAsyncAreaUpdate(CoordRect area);
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/listeners/VisualEffectFrameListeners.java

@@ -0,0 +1,63 @@
+package com.gpl.rpg.AndorsTrail.controller.listeners;
+
+import com.gpl.rpg.AndorsTrail.controller.VisualEffectController.SpriteMoveAnimation;
+import com.gpl.rpg.AndorsTrail.controller.VisualEffectController.VisualEffectAnimation;
+import com.gpl.rpg.AndorsTrail.util.CoordRect;
+import com.gpl.rpg.AndorsTrail.util.ListOfListeners;
+
+public final class VisualEffectFrameListeners extends ListOfListeners<VisualEffectFrameListener> implements VisualEffectFrameListener {
+
+	private final Function3<VisualEffectFrameListener, VisualEffectAnimation, Integer, Integer> onNewAnimationFrame = new Function3<VisualEffectFrameListener, VisualEffectAnimation, Integer, Integer>() {
+		@Override public void call(VisualEffectFrameListener listener, VisualEffectAnimation animation, Integer tileID, Integer textYOffset) { listener.onNewAnimationFrame(animation, tileID, textYOffset); }
+	};
+
+	private final Function1<VisualEffectFrameListener, VisualEffectAnimation> onAnimationCompleted = new Function1<VisualEffectFrameListener, VisualEffectAnimation>() {
+		@Override public void call(VisualEffectFrameListener listener, VisualEffectAnimation animation) { listener.onAnimationCompleted(animation); }
+	};
+	
+	private final Function1<VisualEffectFrameListener, SpriteMoveAnimation> onSpriteMoveStarted = new Function1<VisualEffectFrameListener, SpriteMoveAnimation>() {
+		@Override public void call(VisualEffectFrameListener listener, SpriteMoveAnimation animation) { listener.onSpriteMoveStarted(animation); }
+	};
+	
+	private final Function1<VisualEffectFrameListener, SpriteMoveAnimation> onNewSpriteMoveFrame = new Function1<VisualEffectFrameListener, SpriteMoveAnimation>() {
+		@Override public void call(VisualEffectFrameListener listener, SpriteMoveAnimation animation) { listener.onNewSpriteMoveFrame(animation); }
+	};
+	
+	private final Function1<VisualEffectFrameListener, SpriteMoveAnimation> onSpriteMoveCompleted = new Function1<VisualEffectFrameListener, SpriteMoveAnimation>() {
+		@Override public void call(VisualEffectFrameListener listener, SpriteMoveAnimation animation) { listener.onSpriteMoveCompleted(animation); }
+	};
+	
+	private final Function1<VisualEffectFrameListener, CoordRect> onAsyncAreaUpdate = new Function1<VisualEffectFrameListener, CoordRect>() {
+		@Override public void call(VisualEffectFrameListener listener, CoordRect area) { listener.onAsyncAreaUpdate(area); }
+	};
+	
+	@Override
+	public void onNewAnimationFrame(VisualEffectAnimation animation, int tileID, int textYOffset) {
+		callAllListeners(this.onNewAnimationFrame, animation, tileID, textYOffset);
+	}
+
+	@Override
+	public void onAnimationCompleted(VisualEffectAnimation animation) {
+		callAllListeners(this.onAnimationCompleted, animation);
+	}
+	
+	@Override
+	public void onSpriteMoveStarted(SpriteMoveAnimation animation) {
+		callAllListeners(this.onSpriteMoveStarted, animation);
+	}
+	
+	@Override
+	public void onNewSpriteMoveFrame(SpriteMoveAnimation animation) {
+		callAllListeners(this.onNewSpriteMoveFrame, animation);
+	}
+	
+	@Override
+	public void onSpriteMoveCompleted(SpriteMoveAnimation animation) {
+		callAllListeners(this.onSpriteMoveCompleted, animation);
+	}
+	
+	@Override
+	public void onAsyncAreaUpdate(CoordRect area) {
+		callAllListeners(this.onAsyncAreaUpdate, area);
+	}
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/listeners/WorldEventListener.java

@@ -1,13 +1,14 @@
 package com.gpl.rpg.AndorsTrail.controller.listeners;
 
+import java.util.Collection;
+
 import com.gpl.rpg.AndorsTrail.model.actor.Monster;
 import com.gpl.rpg.AndorsTrail.model.item.Loot;
 import com.gpl.rpg.AndorsTrail.model.map.MapObject;
 
-import java.util.Collection;
-
 public interface WorldEventListener {
 	void onPlayerStartedConversation(Monster m, String phraseID);
+	void onScriptAreaStartedConversation(String phraseID);
 	void onPlayerSteppedOnMonster(Monster m);
 	void onPlayerSteppedOnMapSignArea(MapObject area);
 	void onPlayerSteppedOnKeyArea(MapObject area);

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/controller/listeners/WorldEventListeners.java

@@ -1,18 +1,22 @@
 package com.gpl.rpg.AndorsTrail.controller.listeners;
 
+import java.util.Collection;
+
 import com.gpl.rpg.AndorsTrail.model.actor.Monster;
 import com.gpl.rpg.AndorsTrail.model.item.Loot;
 import com.gpl.rpg.AndorsTrail.model.map.MapObject;
 import com.gpl.rpg.AndorsTrail.util.ListOfListeners;
 
-import java.util.Collection;
-
 public final class WorldEventListeners extends ListOfListeners<WorldEventListener> implements WorldEventListener {
 
 	private final Function2<WorldEventListener, Monster, String> onPlayerStartedConversation = new Function2<WorldEventListener, Monster, String>() {
 		@Override public void call(WorldEventListener listener, Monster m, String phraseID) { listener.onPlayerStartedConversation(m, phraseID); }
 	};
 
+	private final Function1<WorldEventListener, String> onScriptAreaStartedConversation = new Function1<WorldEventListener, String>() {
+		@Override public void call(WorldEventListener listener, String phraseID) { listener.onScriptAreaStartedConversation(phraseID); }
+	};
+
 	private final Function1<WorldEventListener, Monster> onPlayerSteppedOnMonster = new Function1<WorldEventListener, Monster>() {
 		@Override public void call(WorldEventListener listener, Monster m) { listener.onPlayerSteppedOnMonster(m); }
 	};
@@ -58,6 +62,11 @@ public final class WorldEventListeners extends ListOfListeners<WorldEventListene
 		callAllListeners(this.onPlayerStartedConversation, m, phraseID);
 	}
 
+	@Override
+	public void onScriptAreaStartedConversation(String phraseID) {
+		callAllListeners(this.onScriptAreaStartedConversation, phraseID);
+	}
+
 	@Override
 	public void onPlayerSteppedOnMonster(Monster m) {
 		callAllListeners(this.onPlayerSteppedOnMonster, m);

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/model/GameStatistics.java

@@ -1,30 +1,48 @@
 package com.gpl.rpg.AndorsTrail.model;
 
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
+
 import android.content.res.Resources;
+
 import com.gpl.rpg.AndorsTrail.R;
 import com.gpl.rpg.AndorsTrail.context.WorldContext;
 import com.gpl.rpg.AndorsTrail.model.actor.MonsterType;
 import com.gpl.rpg.AndorsTrail.model.item.ItemType;
 import com.gpl.rpg.AndorsTrail.model.map.PredefinedMap;
 import com.gpl.rpg.AndorsTrail.model.quest.Quest;
-
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.io.IOException;
-import java.util.*;
-import java.util.Map.Entry;
+import com.gpl.rpg.AndorsTrail.util.HashMapHelper;
 
 public final class GameStatistics {
 	private int deaths = 0;
-	private final HashMap<String, Integer> killedMonsters = new HashMap<String, Integer>();
+	private final HashMap<String, Integer> killedMonstersByTypeID = new HashMap<String, Integer>();
+	private final HashMap<String, Integer> killedMonstersByName = new HashMap<String, Integer>();
 	private final HashMap<String, Integer> usedItems = new HashMap<String, Integer>();
 	private int spentGold = 0;
+	private boolean unlimitedSaves = true;
+	private int startLives = -1; // -1 --> unlimited
 
-	public GameStatistics() { }
-	public void addMonsterKill(String monsterTypeID) {
-		if (!killedMonsters.containsKey(monsterTypeID)) killedMonsters.put(monsterTypeID, 1);
-		else killedMonsters.put(monsterTypeID, killedMonsters.get(monsterTypeID) + 1);
+	public GameStatistics(boolean unlimitedSaves, int startLives) {
+		this.unlimitedSaves = unlimitedSaves;
+		this.startLives = startLives;
 	}
+
+	public void addMonsterKill(MonsterType monsterType) {
+		// Track monster kills by type ID, for savegame file
+		killedMonstersByTypeID.put(monsterType.id, getNumberOfKillsForMonsterType(monsterType.id) + 1);
+
+		// Also track by name, for statistics display (multiple IDs w/same name don't matter to player)
+		killedMonstersByName.put(monsterType.name, getNumberOfKillsForMonsterName(monsterType.name) + 1);
+	}
+
 	public void addPlayerDeath(int lostExp) {
 		++deaths;
 	}
@@ -33,8 +51,7 @@ public final class GameStatistics {
 	}
 	public void addItemUsage(ItemType type) {
 		final String n = type.id;
-		if (!usedItems.containsKey(n)) usedItems.put(n, 1);
-		else usedItems.put(n, usedItems.get(n) + 1);
+		usedItems.put(n, HashMapHelper.getOrDefault(usedItems, n,0) + 1);
 	}
 
 	public int getDeaths() {
@@ -45,31 +62,41 @@ public final class GameStatistics {
 		return spentGold;
 	}
 
+	public boolean hasUnlimitedSaves() { return unlimitedSaves; }
+
+	public boolean hasUnlimitedLives() { return startLives == -1; }
+
+	public int getStartLives() { return startLives; }
+
+	public int getLivesLeft() { return hasUnlimitedLives() ? -1 : startLives - deaths; }
+
+	public boolean isDead() { return !hasUnlimitedLives() && getLivesLeft() < 1; }
+
 	public int getNumberOfKillsForMonsterType(String monsterTypeID) {
-		Integer v = killedMonsters.get(monsterTypeID);
-		if (v == null) return 0;
-		return v;
+		return HashMapHelper.getOrDefault(killedMonstersByTypeID, monsterTypeID, 0);
+	}
+
+	public int getNumberOfKillsForMonsterName(String monsterName) {
+		return HashMapHelper.getOrDefault(killedMonstersByName, monsterName, 0);
 	}
 
 	public String getTop5MostCommonlyKilledMonsters(WorldContext world, Resources res) {
-		if (killedMonsters.isEmpty()) return null;
-		List<Entry<String, Integer>> entries = new ArrayList<Entry<String, Integer>>(killedMonsters.entrySet());
+		if (killedMonstersByTypeID.isEmpty()) return null;
+		List<Entry<String, Integer>> entries = new ArrayList<Entry<String, Integer>>(killedMonstersByName.entrySet());
 		Collections.sort(entries, descendingValueComparator);
 		StringBuilder sb = new StringBuilder(100);
 		int i = 0;
 		for (Entry<String, Integer> e : entries) {
 			if (i++ >= 5) break;
-			MonsterType t = world.monsterTypes.getMonsterType(e.getKey());
-			if (t == null) continue;
-			sb.append(res.getString(R.string.heroinfo_gamestats_name_and_qty, t.name, e.getValue())).append("\n");
+			sb.append(res.getString(R.string.heroinfo_gamestats_name_and_qty, e.getKey(), e.getValue())).append('\n');
 		}
 		return sb.toString();
 	}
 
 	public String getMostPowerfulKilledMonster(WorldContext world) {
-		if (killedMonsters.isEmpty()) return null;
-		HashMap<String, Integer> expPerMonsterType = new HashMap<String, Integer>(killedMonsters.size());
-		for (String monsterTypeID : killedMonsters.keySet()) {
+		if (killedMonstersByTypeID.isEmpty()) return null;
+		HashMap<String, Integer> expPerMonsterType = new HashMap<String, Integer>(killedMonstersByTypeID.size());
+		for (String monsterTypeID : killedMonstersByTypeID.keySet()) {
 			MonsterType t = world.monsterTypes.getMonsterType(monsterTypeID);
 			expPerMonsterType.put(monsterTypeID, t != null ? t.exp : 0);
 		}
@@ -113,15 +140,15 @@ public final class GameStatistics {
 	}
 
 	public int getNumberOfUsedItems() {
-		int result = 0;
-		for (int v : usedItems.values()) result += v;
-		return result;
+		return HashMapHelper.sumIntegerValues(usedItems);
+	}
+
+	public int getNumberOfTimesItemHasBeenUsed(String itemId) {
+		return HashMapHelper.getOrDefault(usedItems, itemId, 0);
 	}
 
 	public int getNumberOfKilledMonsters() {
-		int result = 0;
-		for (int v : killedMonsters.values()) result += v;
-		return result;
+		return HashMapHelper.sumIntegerValues(killedMonstersByTypeID);
 	}
 
 	private static final Comparator<Entry<String, Integer>> descendingValueComparator = new Comparator<Entry<String, Integer>>() {
@@ -145,8 +172,14 @@ public final class GameStatistics {
 				if (type == null) continue;
 				id = type.id;
 			}
-			this.killedMonsters.put(id, value);
+			this.killedMonstersByTypeID.put(id, value);
+
+			// Also track by name, for statistics display (multiple IDs w/same name don't matter to player)
+			MonsterType t = world.monsterTypes.getMonsterType(id);
+
+			if (t != null) 	killedMonstersByName.put(t.name, getNumberOfKillsForMonsterName(t.name) + value);
 		}
+
 		if (fileversion <= 17) return;
 
 		final int numItems = src.readInt();
@@ -156,11 +189,16 @@ public final class GameStatistics {
 			this.usedItems.put(name, value);
 		}
 		this.spentGold = src.readInt();
+
+		if (fileversion < 49) return;
+
+		this.startLives = src.readInt();
+		this.unlimitedSaves = src.readBoolean();
 	}
 
-	public void writeToParcel(DataOutputStream dest, int flags) throws IOException {
+	public void writeToParcel(DataOutputStream dest) throws IOException {
 		dest.writeInt(deaths);
-		Set<Entry<String, Integer> > set = killedMonsters.entrySet();
+		Set<Entry<String, Integer> > set = killedMonstersByTypeID.entrySet();
 		dest.writeInt(set.size());
 		for (Entry<String, Integer> e : set) {
 			dest.writeUTF(e.getKey());
@@ -173,5 +211,7 @@ public final class GameStatistics {
 			dest.writeInt(e.getValue());
 		}
 		dest.writeInt(spentGold);
+		dest.writeInt(startLives);
+		dest.writeBoolean(unlimitedSaves);
 	}
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/model/InterfaceData.java

@@ -1,13 +1,12 @@
 package com.gpl.rpg.AndorsTrail.model;
 
-import com.gpl.rpg.AndorsTrail.context.WorldContext;
-import com.gpl.rpg.AndorsTrail.model.actor.Monster;
-import com.gpl.rpg.AndorsTrail.util.Coord;
-
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
+import com.gpl.rpg.AndorsTrail.model.actor.Monster;
+import com.gpl.rpg.AndorsTrail.util.Coord;
+
 public final class InterfaceData {
 	public boolean isMainActivityVisible = false;
 	public boolean isInCombat = false;
@@ -17,12 +16,19 @@ public final class InterfaceData {
 	public String selectedTabHeroInfo = "";
 	public int selectedQuestFilter = 0; // Should not be parceled
 
+	public int selectedInventoryCategory = 0; //All
+	public int selectedInventorySort = 0; //Unsorted
+	public int oldSortSelection = 0; // Later will be used for reversing ascending/descending order
+	public int selectedSkillCategory = 0; //All
+	public int selectedSkillSort = 0; //Unsorted
+	public int selectedShopSort = 0; //Unsorted
+
 	public InterfaceData() { }
 
 
 	// ====== PARCELABLE ===================================================================
 
-	public InterfaceData(DataInputStream src, WorldContext world, int fileversion) throws IOException {
+	public InterfaceData(DataInputStream src, int fileversion) throws IOException {
 		this.isMainActivityVisible = src.readBoolean();
 		this.isInCombat = src.readBoolean();
 		final boolean hasSelectedPosition = src.readBoolean();
@@ -34,12 +40,12 @@ public final class InterfaceData {
 		this.selectedTabHeroInfo = src.readUTF();
 	}
 
-	public void writeToParcel(DataOutputStream dest, int flags) throws IOException {
+	public void writeToParcel(DataOutputStream dest) throws IOException {
 		dest.writeBoolean(isMainActivityVisible);
 		dest.writeBoolean(isInCombat);
 		if (selectedPosition != null) {
 			dest.writeBoolean(true);
-			selectedPosition.writeToParcel(dest, flags);
+			selectedPosition.writeToParcel(dest);
 		} else {
 			dest.writeBoolean(false);
 		}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/model/MapBundle.java

@@ -0,0 +1,11 @@
+package com.gpl.rpg.AndorsTrail.model;
+
+import com.gpl.rpg.AndorsTrail.model.map.LayeredTileMap;
+import com.gpl.rpg.AndorsTrail.model.map.PredefinedMap;
+import com.gpl.rpg.AndorsTrail.resource.tiles.TileCollection;
+
+public final class MapBundle {
+	public PredefinedMap map;
+	public LayeredTileMap tileMap;
+	public TileCollection tiles;
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/model/ModelContainer.java

@@ -1,15 +1,13 @@
 package com.gpl.rpg.AndorsTrail.model;
 
-import com.gpl.rpg.AndorsTrail.context.ControllerContext;
-import com.gpl.rpg.AndorsTrail.context.WorldContext;
-import com.gpl.rpg.AndorsTrail.model.actor.Player;
-import com.gpl.rpg.AndorsTrail.model.map.LayeredTileMap;
-import com.gpl.rpg.AndorsTrail.model.map.PredefinedMap;
-
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
+import com.gpl.rpg.AndorsTrail.context.ControllerContext;
+import com.gpl.rpg.AndorsTrail.context.WorldContext;
+import com.gpl.rpg.AndorsTrail.model.actor.Player;
+
 public final class ModelContainer {
 
 	public final Player player;
@@ -17,27 +15,26 @@ public final class ModelContainer {
 	public final CombatLog combatLog = new CombatLog();
 	public final GameStatistics statistics;
 	public final WorldData worldData;
-	public PredefinedMap currentMap;
-	public LayeredTileMap currentTileMap;
+	public MapBundle currentMaps = new MapBundle();;
 
-	public ModelContainer() {
+	public ModelContainer(int startLives, boolean unlimitedSaves) {
 		player = new Player();
 		uiSelections = new InterfaceData();
-		statistics = new GameStatistics();
+		statistics = new GameStatistics(unlimitedSaves, startLives);
 		worldData = new WorldData();
 	}
 
 	// ====== PARCELABLE ===================================================================
 
 	public ModelContainer(DataInputStream src, WorldContext world, ControllerContext controllers, int fileversion) throws IOException {
-		this.player = Player.readFromParcel(src, world, controllers, fileversion);
-		this.currentMap = world.maps.findPredefinedMap(src.readUTF());
-		this.uiSelections = new InterfaceData(src, world, fileversion);
+		this.player = Player.newFromParcel(src, world, controllers, fileversion);
+		this.currentMaps.map = world.maps.findPredefinedMap(src.readUTF());
+		this.uiSelections = new InterfaceData(src, fileversion);
 		if (uiSelections.selectedPosition != null) {
-			this.uiSelections.selectedMonster = currentMap.getMonsterAt(uiSelections.selectedPosition);
+			this.uiSelections.selectedMonster = currentMaps.map.getMonsterAt(uiSelections.selectedPosition);
 		}
 		this.statistics = new GameStatistics(src, world, fileversion);
-		this.currentTileMap = null;
+		this.currentMaps.tileMap = null;
 		if (fileversion >= 40) {
 			this.worldData = new WorldData(src, fileversion);
 		} else {
@@ -45,11 +42,11 @@ public final class ModelContainer {
 		}
 	}
 
-	public void writeToParcel(DataOutputStream dest, int flags) throws IOException {
-		player.writeToParcel(dest, flags);
-		dest.writeUTF(currentMap.name);
-		uiSelections.writeToParcel(dest, flags);
-		statistics.writeToParcel(dest, flags);
-		worldData.writeToParcel(dest, flags);
+	public void writeToParcel(DataOutputStream dest) throws IOException {
+		player.writeToParcel(dest);
+		dest.writeUTF(currentMaps.map.name);
+		uiSelections.writeToParcel(dest);
+		statistics.writeToParcel(dest);
+		worldData.writeToParcel(dest);
 	}
 }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/model/WorldData.java

@@ -0,0 +1,59 @@
+package com.gpl.rpg.AndorsTrail.model;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+public final class WorldData {
+	private long worldTime = 0; // Measured in number of game rounds
+	private final HashMap<String, Long> timers = new HashMap<String, Long>();
+
+	public WorldData() {}
+
+	public void tickWorldTime() {
+		++worldTime;
+	}
+	public void tickWorldTime(int ticks) {
+		worldTime += ticks;
+	}
+	public long getWorldTime() {
+		return worldTime;
+	}
+
+	public void createTimer(String name) {
+		timers.put(name, worldTime);
+	}
+
+	public void removeTimer(String name) {
+		timers.remove(name);
+	}
+
+	public boolean hasTimerElapsed(String name, long duration) {
+		Long v = timers.get(name);
+		if (v == null) return false;
+		return v + duration <= worldTime;
+	}
+
+	// ====== PARCELABLE ===================================================================
+
+	public WorldData(DataInputStream src, int fileversion) throws IOException {
+		worldTime = src.readLong();
+		final int numTimers = src.readInt();
+		for(int i = 0; i < numTimers; ++i) {
+			final String timerName = src.readUTF();
+			final long value = src.readLong();
+			this.timers.put(timerName, value);
+		}
+	}
+
+	public void writeToParcel(DataOutputStream dest) throws IOException {
+		dest.writeLong(worldTime);
+		dest.writeInt(timers.size());
+		for(Map.Entry<String, Long> e : timers.entrySet()) {
+			dest.writeUTF(e.getKey());
+			dest.writeLong(e.getValue());
+		}
+	}
+}

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/model/ability/ActorCondition.java

@@ -1,20 +1,25 @@
 package com.gpl.rpg.AndorsTrail.model.ability;
 
-import com.gpl.rpg.AndorsTrail.context.WorldContext;
-
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
+import com.gpl.rpg.AndorsTrail.context.WorldContext;
+
 public final class ActorCondition {
 	public static final int MAGNITUDE_REMOVE_ALL = -99;
 	public static final int DURATION_FOREVER = 999;
+	public static final int DURATION_NONE = 0;
 
 	public final ActorConditionType conditionType;
 	public int magnitude;
 	public int duration;
 
-	public ActorCondition(ActorConditionType conditionType, int magnitude, int duration) {
+	public ActorCondition(
+			ActorConditionType conditionType
+			, int magnitude
+			, int duration
+	) {
 		this.conditionType = conditionType;
 		this.magnitude = magnitude;
 		this.duration = duration;
@@ -35,7 +40,7 @@ public final class ActorCondition {
 		this.duration = src.readInt();
 	}
 
-	public void writeToParcel(DataOutputStream dest, int flags) throws IOException {
+	public void writeToParcel(DataOutputStream dest) throws IOException {
 		dest.writeUTF(conditionType.conditionTypeID);
 		dest.writeInt(magnitude);
 		dest.writeInt(duration);

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/model/ability/ActorConditionEffect.java

@@ -8,15 +8,24 @@ public final class ActorConditionEffect {
 	public final int duration;
 	public final ConstRange chance;
 
-	public ActorConditionEffect(ActorConditionType conditionType, int magnitude, int duration, ConstRange chance) {
+	public ActorConditionEffect(
+			ActorConditionType conditionType
+			, int magnitude
+			, int duration
+			, ConstRange chance
+	) {
 		this.conditionType = conditionType;
 		this.magnitude = magnitude;
 		this.duration = duration;
 		this.chance = chance;
 	}
 
+	public boolean isImmunity() {
+		return magnitude == ActorCondition.MAGNITUDE_REMOVE_ALL && duration != ActorCondition.DURATION_NONE;
+	}
+	
 	public boolean isRemovalEffect() {
-		return magnitude == ActorCondition.MAGNITUDE_REMOVE_ALL;
+		return magnitude == ActorCondition.MAGNITUDE_REMOVE_ALL && duration == ActorCondition.DURATION_NONE;
 	}
 
 	public ActorCondition createCondition() { return createCondition(duration); }

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/model/ability/ActorConditionType.java

@@ -19,15 +19,16 @@ public final class ActorConditionType {
 	public final AbilityModifierTraits abilityEffect;
 
 	public ActorConditionType(
-			String conditionTypeID,
-			String name,
-			int iconID,
-			ConditionCategory conditionCategory,
-			boolean isStacking,
-			boolean isPositive,
-			StatsModifierTraits statsEffect_everyRound,
-			StatsModifierTraits statsEffect_everyFullRound,
-			AbilityModifierTraits abilityEffect) {
+			String conditionTypeID
+			, String name
+			, int iconID
+			, ConditionCategory conditionCategory
+			, boolean isStacking
+			, boolean isPositive
+			, StatsModifierTraits statsEffect_everyRound
+			, StatsModifierTraits statsEffect_everyFullRound
+			, AbilityModifierTraits abilityEffect
+	) {
 		this.conditionTypeID = conditionTypeID;
 		this.name = name;
 		this.iconID = iconID;

AndorsTrail/app/src/main/java/com/gpl/rpg/AndorsTrail/model/ability/ActorConditionTypeCollection.java

@@ -1,11 +1,11 @@
 package com.gpl.rpg.AndorsTrail.model.ability;
 
+import java.util.HashMap;
+
 import com.gpl.rpg.AndorsTrail.AndorsTrailApplication;
 import com.gpl.rpg.AndorsTrail.resource.parsers.ActorConditionsTypeParser;
 import com.gpl.rpg.AndorsTrail.util.L;
 
-import java.util.HashMap;
-
 public final class ActorConditionTypeCollection {
 	private final HashMap<String, ActorConditionType> conditionTypes = new HashMap<String, ActorConditionType>();