[maven-release-plugin] prepare release forge-1.6.56

updated simplified chinese translation

.github/workflows/maven-publish.yml

@@ -0,0 +1,41 @@
+name: Publish Forge
+
+on:
+  workflow_dispatch:
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      deployments: write
+      packages: write
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up JDK 11
+        uses: actions/setup-java@v3
+        with:
+          java-version: '11'
+          distribution: 'temurin'
+          cache: 'maven'
+          server-id: cardforge-repo
+          server-username: ${{ secrets.FTP_USERNAME }}
+          server-password: ${{ secrets.FTP_PASSWORD }}
+          settings-path: ${{ github.workspace }} # location for the settings.xml file
+
+      - name: Install virtual framebuffer (if not available) to allow running GUI on a headless server
+        run: command -v Xvfb >/dev/null 2>&1 || { sudo apt update && sudo apt install -y xvfb; }
+
+      - name: Configure Git User
+        run: |
+          git config user.email "actions@github.com"
+          git config user.name "GitHub Actions"
+      - name: Build/Install/Publish to GitHub Packages Apache Maven
+        run: |
+          export DISPLAY=":1"
+          Xvfb :1 -screen 0 800x600x8 &
+          mvn -U -B clean -P windows-linux install release:clean release:prepare release:perform -T 1C -Dcardforge-repo.username=${{ secrets.FTP_USERNAME }} -Dcardforge-repo.password=${{ secrets.FTP_PASSWORD }}
+        env:
+          GITHUB_TOKEN: ${{ github.token }}

.github/workflows/stale.yml

@@ -0,0 +1,33 @@
+# This workflow warns and then closes issues and PRs that have had no activity for a specified amount of time.
+#
+# You can adjust the behavior by modifying this file.
+# For more information, see:
+# https://github.com/actions/stale
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+  - cron: '21 9 * * *'
+
+jobs:
+  stale:
+
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+
+    steps:
+    - uses: actions/stale@v5
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-message: "This issue has not been updated in a while and has now been marked as stale. Stale messages will be auto closed."
+        stale-pr-message: 'This PR has not been updated in a while nad has been marked on stale. Stale PRs will be auto closed'
+        close-issue-message: 'This issue was closed because it has been stalled for 5 days with no activity.'
+        stale-issue-label: 'no-issue-activity'
+        stale-pr-label: 'no-pr-activity'
+        exempt-pr-labels: 'awaiting-approval,work-in-progress'
+        days-before-issue-stale: 30
+        days-before-pr-stale: 45
+        days-before-issue-close: 5
+        days-before-pr-close: 10

.github/workflows/test-maven-settings.yml

@@ -0,0 +1,48 @@
+name: Maven test for settings
+
+on:
+  workflow_dispatch:
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      deployments: write
+      packages: write
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up JDK 11
+      uses: actions/setup-java@v3
+      with:
+        java-version: '11'
+        distribution: 'temurin'
+        cache: 'maven'
+        server-id: cardforge-repo
+        server-username: ${{ secrets.FTP_USERNAME }}
+        server-password: ${{ secrets.FTP_PASSWORD }}
+        settings-path: ${{ github.workspace }} # location for the settings.xml file
+
+    - name: Check settings after java setup
+      run: |
+        cat ${{ github.workspace }}/settings.xml
+        
+
+    - name: maven-settings-xml-action
+      uses: whelk-io/maven-settings-xml-action@v20
+      with:
+        servers: '[{ "id": "cardforge-repo", "username": "${{ secrets.FTP_USERNAME }}", "password": "Fake_password" }]'
+    
+    - name: Check settings after xml action
+      run: |
+        cat ~/.m2/settings.xml
+        
+    - name: Check settings after xml action
+      run: |
+        cat ${{ github.workspace }}/.mvn/local-settings.xml
+        
+    - name: Where are maven settings
+      run: |
+        mvn -X clean -Dcardforge-repo.username=${{ secrets.FTP_USERNAME }} -Dcardforge-repo.password=${{ secrets.FTP_PASSWORD }} | grep "settings"

.gitignore

@@ -36,6 +36,9 @@ gen
 # Ignore macOS Spotlight rubbish
 .DS_Store
 
+# ignore vim swapfiles
+*.swp
+
 # TODO: specify what these ignores are for (releasing?)
 
 forge.profile.properties
@@ -78,3 +81,4 @@ forge-gui/tools/AllCards.json
 forge-gui/tools/EditionTrackingResults
 forge-gui/tools/PerSetTrackingResults
 
+*.tiled-session

.mvn/local-settings.xml

@@ -12,4 +12,12 @@
             <url>http://4thline.org/m2</url>
         </mirror>
     </mirrors>
+
+    <servers>
+        <server>
+            <id>cardforge-repo</id>
+            <username>${cardforge-repo.username}</username>
+            <password>${cardforge-repo.password}</password>
+        </server>
+    </servers>
 </settings>

.mvn/maven.config

@@ -1 +1,2 @@
---settings ./.mvn/local-settings.xml
+--settings
+./.mvn/local-settings.xml

forge-adventure/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>forge</artifactId>
         <groupId>forge</groupId>
-        <version>1.6.50-SNAPSHOT</version>
+        <version>1.6.56</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -11,13 +11,17 @@
     <packaging>jar</packaging>
     <name>Forge Adventure</name>
     <repositories>
+        <repository>
+            <id>gdx-nightlies</id>
+            <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
+        </repository>
         <repository>
             <id>jitpack.io</id>
             <url>https://jitpack.io</url>
         </repository>
     </repositories>
     <build>
-        <sourceDirectory>src</sourceDirectory>
+        <sourceDirectory>src/main/java</sourceDirectory>
         <resources>
             <resource>
                 <directory>${project.basedir}</directory>
@@ -26,6 +30,8 @@
                     <include>**/*.frag</include>
                     <include>**/title_bg_lq.png</include>
                     <include>**/transition.png</include>
+                    <include>**/adv_bg_texture.jpg</include>
+                    <include>**/adv_bg_splash.png</include>
                     <include>**/bg_splash.png</include>
                     <include>**/bg_texture.jpg</include>
                     <include>**/font1.ttf</include>
@@ -54,11 +60,11 @@
                             </goals>
                             <configuration>
                                 <headerType>gui</headerType>
-                                <outfile>${project.build.directory}/forge-adventure-java8.exe</outfile>
+                                <outfile>${project.build.directory}/forge-adventure-editor-java8.exe</outfile>
                                 <jar>${project.build.finalName}-jar-with-dependencies.jar</jar>
                                 <dontWrapJar>true</dontWrapJar>
                                 <errTitle>forge</errTitle>
-                                <icon>src/main/config/forge-adventure.ico</icon>
+                                <icon>src/main/config/forge-adventure-editor.ico</icon>
                                 <classPath>
                                     <mainClass>forge.adventure.Main</mainClass>
                                     <addDependencies>false</addDependencies>
@@ -86,9 +92,9 @@
                                     <txtProductVersion>
                                         1.0.0.0
                                     </txtProductVersion>
-                                    <productName>forge-adventure</productName>
-                                    <internalName>forge-adventure</internalName>
-                                    <originalFilename>forge-adventure-java8.exe</originalFilename>
+                                    <productName>forge-adventure-editor</productName>
+                                    <internalName>forge-adventure-editor</internalName>
+                                    <originalFilename>forge-adventure-editor-java8.exe</originalFilename>
                                 </versionInfo>
                             </configuration>
                         </execution>
@@ -101,12 +107,12 @@
                             </goals>
                             <configuration>
                                 <headerType>gui</headerType>
-                                <outfile>${project.build.directory}/forge-adventure.exe</outfile>
+                                <outfile>${project.build.directory}/forge-adventure-editor.exe</outfile>
                                 <jar>${project.build.finalName}-jar-with-dependencies.jar</jar>
                                 <dontWrapJar>true</dontWrapJar>
                                 <errTitle>forge</errTitle>
                                 <downloadUrl>https://www.oracle.com/java/technologies/downloads/</downloadUrl>
-                                <icon>src/main/config/forge-adventure.ico</icon>
+                                <icon>src/main/config/forge-adventure-editor.ico</icon>
                                 <classPath>
                                     <mainClass>forge.adventure.Main</mainClass>
                                     <addDependencies>false</addDependencies>
@@ -119,10 +125,26 @@
                                     <opts>
                                         <opt>-Dfile.encoding=UTF-8</opt>
                                         <opt>--add-opens java.base/java.lang=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.base/java.math=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.base/jdk.internal.misc=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.base/java.nio=ALL-UNNAMED</opt>
+                                        <opt>--add-opens=java.base/sun.nio.ch=ALL-UNNAMED</opt>
                                         <opt>--add-opens java.base/java.util=ALL-UNNAMED</opt>
                                         <opt>--add-opens java.base/java.lang.reflect=ALL-UNNAMED</opt>
                                         <opt>--add-opens java.base/java.text=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.desktop/java.awt=ALL-UNNAMED</opt>
                                         <opt>--add-opens java.desktop/java.awt.font=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.desktop/java.awt.image=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.desktop/java.awt.color=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.desktop/sun.awt.image=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.desktop/javax.swing=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.desktop/javax.swing.border=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.desktop/javax.swing.event=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.desktop/sun.swing=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.desktop/java.beans=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.base/java.util.concurrent=ALL-UNNAMED</opt>
+                                        <opt>--add-opens java.base/java.net=ALL-UNNAMED</opt>
+                                        <opt>-Dio.netty.tryReflectionSetAccessible=true</opt>
                                     </opts>
                                 </jre>
                                 <versionInfo>
@@ -140,9 +162,9 @@
                                     <txtProductVersion>
                                         1.0.0.0
                                     </txtProductVersion>
-                                    <productName>forge-adventure</productName>
-                                    <internalName>forge-adventure</internalName>
-                                    <originalFilename>forge-adventure.exe</originalFilename>
+                                    <productName>forge-adventure-editor</productName>
+                                    <internalName>forge-adventure-editor</internalName>
+                                    <originalFilename>forge-adventure-editor.exe</originalFilename>
                                 </versionInfo>
                             </configuration>
                         </execution>
@@ -164,7 +186,7 @@
                 </executions>
                 <configuration>
                     <basedir>${basedir}/${configSourceDirectory}</basedir>
-                    <filesToInclude>forge-adventure.sh, forge-adventure.command, forge-adventure.cmd</filesToInclude>
+                    <filesToInclude>forge-adventure-editor.sh, forge-adventure-editor-mac.sh, forge-adventure-editor.command, forge-adventure-editor.cmd</filesToInclude>
                     <outputBasedir>${project.build.directory}</outputBasedir>
                     <outputDir>.</outputDir>
                     <regex>false</regex>
@@ -206,38 +228,39 @@
         </plugins>
     </build>
     <dependencies>
-        <dependency>
-            <groupId>com.github.jetopto1</groupId>
-            <artifactId>cling</artifactId>
-            <version>1.0.0</version>
-        </dependency>
         <dependency>
             <groupId>com.badlogicgames.gdx</groupId>
             <artifactId>gdx</artifactId>
-            <version>1.10.0</version>
+            <version>1.11.0</version>
             <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>com.badlogicgames.gdx</groupId>
             <artifactId>gdx-platform</artifactId>
-            <version>1.10.0</version>
+            <version>1.11.0</version>
             <classifier>natives-desktop</classifier>
         </dependency>
         <dependency>
             <groupId>com.badlogicgames.gdx</groupId>
             <artifactId>gdx-freetype</artifactId>
-            <version>1.10.0</version>
+            <version>1.11.0</version>
         </dependency>
         <dependency>
             <groupId>com.badlogicgames.gdx</groupId>
-            <artifactId>gdx-backend-lwjgl3</artifactId>
-            <version>1.10.0</version>
+            <artifactId>gdx-backend-lwjgl</artifactId>
+            <version>1.11.0</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.badlogicgames.gdx</groupId>
+            <artifactId>gdx-tools</artifactId>
+            <version>1.11.0</version>
             <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>com.badlogicgames.gdx</groupId>
             <artifactId>gdx-freetype-platform</artifactId>
-            <version>1.10.0</version>
+            <version>1.11.0</version>
             <classifier>natives-desktop</classifier>
         </dependency>
         <dependency>
@@ -245,16 +268,6 @@
             <artifactId>forge-core</artifactId>
             <version>${project.version}</version>
         </dependency>
-        <dependency>
-            <groupId>forge</groupId>
-            <artifactId>forge-game</artifactId>
-            <version>${project.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>forge</groupId>
-            <artifactId>forge-ai</artifactId>
-            <version>${project.version}</version>
-        </dependency>
         <dependency>
             <groupId>forge</groupId>
             <artifactId>forge-gui</artifactId>
@@ -272,10 +285,9 @@
             <scope>compile</scope>
         </dependency>
         <dependency>
-            <groupId>forge</groupId>
-            <artifactId>forge-gui-mobile</artifactId>
-            <version>1.6.50-SNAPSHOT</version>
-            <scope>compile</scope>
+            <groupId>com.badlogicgames.gdx-controllers</groupId>
+            <artifactId>gdx-controllers-desktop</artifactId>
+            <version>2.2.3-SNAPSHOT</version>
         </dependency>
     </dependencies>
 
@@ -284,4 +296,4 @@
         <maven.compiler.target>8</maven.compiler.target>
     </properties>
 
-</project>
+</project>

forge-adventure/shaders/grayscale.frag

@@ -6,10 +6,11 @@ varying vec4 v_color;
 varying vec2 v_texCoords;
 uniform sampler2D u_texture;
 uniform float u_grayness;
+uniform float u_bias;
 
 void main() {
   vec4 c = v_color * texture2D(u_texture, v_texCoords);
   float grey = dot( c.rgb, vec3(0.22, 0.707, 0.071) );
   vec3 blendedColor = mix(c.rgb, vec3(grey), u_grayness);
-  gl_FragColor = vec4(blendedColor.rgb, c.a);
+  gl_FragColor = mix(vec4(0.0, 0.0, 0.0, 1.0), vec4(blendedColor.rgb, c.a), u_bias);
 }

forge-adventure/shaders/underwater.frag

@@ -11,6 +11,7 @@ uniform sampler2D u_texture;
 uniform float u_amount;
 uniform float u_speed;
 uniform float u_time;
+uniform float u_bias;
 
 void main () {
     vec2 uv = v_texCoords;
@@ -19,5 +20,7 @@ void main () {
 
     uv.x += (sin((uv.y + (u_time * 0.07 * u_speed)) * 15.0) * 0.0029 * u_amount) + (sin((uv.y + (u_time * 0.1 * u_speed)) * 15.0) * 0.002 * u_amount);
 
-    gl_FragColor = texture2D(u_texture, uv);
+	vec4 texColor = texture2D(u_texture, uv);
+
+    gl_FragColor = mix(vec4(0.0, 0.0, 0.0, 1.0), texColor, u_bias);
 }

forge-adventure/src/main/config/forge-adventure-editor-mac.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+cd $(dirname "${0}")
+java -XstartOnFirstThread -Xmx4096m -Dfile.encoding=UTF-8 -jar $project.build.finalName$

forge-adventure/src/main/config/forge-adventure-editor.cmd

@@ -0,0 +1,25 @@
+@echo off
+
+pushd %~dp0
+
+java -version 1>nul 2>nul || (
+   echo no java installed
+   popd
+   exit /b 2
+)
+for /f tokens^=2^ delims^=.-_^+^" %%j in ('java -fullversion 2^>^&1') do set "jver=%%j"
+
+if %jver% GEQ 17 (
+  java --add-opens java.desktop/java.beans=ALL-UNNAMED --add-opens java.desktop/javax.swing.border=ALL-UNNAMED --add-opens java.desktop/javax.swing.event=ALL-UNNAMED --add-opens java.desktop/sun.swing=ALL-UNNAMED --add-opens java.desktop/java.awt.image=ALL-UNNAMED --add-opens java.desktop/java.awt.color=ALL-UNNAMED --add-opens java.desktop/sun.awt.image=ALL-UNNAMED --add-opens java.desktop/javax.swing=ALL-UNNAMED --add-opens java.desktop/java.awt=ALL-UNNAMED --add-opens java.base/java.util=ALL-UNNAMED --add-opens java.base/java.lang=ALL-UNNAMED --add-opens java.base/java.lang.reflect=ALL-UNNAMED --add-opens java.base/java.text=ALL-UNNAMED --add-opens java.desktop/java.awt.font=ALL-UNNAMED --add-opens java.base/jdk.internal.misc=ALL-UNNAMED --add-opens java.base/sun.nio.ch=ALL-UNNAMED --add-opens java.base/java.nio=ALL-UNNAMED --add-opens java.base/java.math=ALL-UNNAMED --add-opens java.base/java.util.concurrent=ALL-UNNAMED --add-opens java.base/java.net=ALL-UNNAMED -Dio.netty.tryReflectionSetAccessible=true -Xmx4096m -Dfile.encoding=UTF-8 -jar $project.build.finalName$
+  popd
+  exit /b 0
+)
+
+if %jver% GEQ 11 (
+  java --illegal-access=permit -Xmx4096m -Dfile.encoding=UTF-8 -jar $project.build.finalName$
+  popd
+  exit /b 0
+)
+
+java -Xmx4096m -Dfile.encoding=UTF-8 -jar $project.build.finalName$
+popd

forge-adventure/src/main/config/forge-adventure.cmd

@@ -1,25 +0,0 @@
-@echo off
-
-pushd %~dp0
-
-java -version 1>nul 2>nul || (
-   echo no java installed
-   popd
-   exit /b 2
-)
-for /f tokens^=2^ delims^=.-_^+^" %%j in ('java -fullversion 2^>^&1') do set "jver=%%j"
-
-if %jver% GEQ 17 (
-  java --add-opens java.base/java.lang=ALL-UNNAMED --add-opens java.base/java.util=ALL-UNNAMED --add-opens java.base/java.lang.reflect=ALL-UNNAMED --add-opens java.base/java.text=ALL-UNNAMED --add-opens java.desktop/java.awt.font=ALL-UNNAMED -Xmx4096m -Dfile.encoding=UTF-8 -jar $project.build.finalName$
-  popd
-  exit /b 0
-)
-
-if %jver% GEQ 11 (
-  java --illegal-access=permit -Xmx4096m -Dfile.encoding=UTF-8 -jar $project.build.finalName$
-  popd
-  exit /b 0
-)
-
-java -Xmx4096m -Dfile.encoding=UTF-8 -jar $project.build.finalName$
-popd

forge-adventure/src/main/java/forge/adventure/Main.java

@@ -1,29 +1,10 @@
 package forge.adventure;
 
-import com.badlogic.gdx.ApplicationListener;
-import com.badlogic.gdx.Gdx;
-import com.badlogic.gdx.backends.lwjgl3.Lwjgl3Application;
-import com.badlogic.gdx.backends.lwjgl3.Lwjgl3ApplicationConfiguration;
-import com.badlogic.gdx.backends.lwjgl3.Lwjgl3Clipboard;
-import com.badlogic.gdx.backends.lwjgl3.Lwjgl3Window;
-import com.badlogic.gdx.backends.lwjgl3.Lwjgl3WindowListener;
-import com.badlogic.gdx.graphics.glutils.HdpiMode;
-import forge.Forge;
+import forge.GuiMobile;
+import forge.adventure.editor.EditorMainWindow;
 import forge.adventure.util.Config;
-import forge.interfaces.IDeviceAdapter;
-import forge.util.BuildInfo;
-import forge.util.FileUtil;
-import forge.util.OperatingSystem;
-import forge.util.RestartUtil;
-import io.sentry.Sentry;
+import forge.gui.GuiBase;
 
-import javax.imageio.ImageIO;
-import java.awt.*;
-import java.awt.image.BufferedImage;
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
 import java.nio.file.Files;
 import java.nio.file.Paths;
 
@@ -33,158 +14,9 @@ import java.nio.file.Paths;
 public class Main {
 
     public static void main(String[] args) {
-
-        Sentry.init(options -> {
-            options.setEnableExternalConfiguration(true);
-            options.setRelease(BuildInfo.getVersionString());
-            options.setEnvironment(System.getProperty("os.name"));
-            options.setTag("Java Version", System.getProperty("java.version"));
-        }, true);
-
-        // HACK - temporary solution to "Comparison method violates it's general contract!" crash
-        System.setProperty("java.util.Arrays.useLegacyMergeSort", "true");
-
-        //Turn off the Java 2D system's use of Direct3D to improve rendering speed (particularly when Full Screen)
-        System.setProperty("sun.java2d.d3d", "false");
-
-
-        Lwjgl3ApplicationConfiguration config = new Lwjgl3ApplicationConfiguration();
-        config.setResizable(false);
-        ApplicationListener start = Forge.getApp(new Lwjgl3Clipboard(), new DesktopAdapter(""), Files.exists(Paths.get("./res"))?"./":"../forge-gui/", true, false, 0, true, 0, "", "");
-
-        if (Config.instance().getSettingData().fullScreen) {
-            config.setFullscreenMode(Lwjgl3ApplicationConfiguration.getDisplayMode());
-            config.setAutoIconify(true);
-            config.setHdpiMode(HdpiMode.Logical);
-        } else {
-            config.setWindowedMode(Config.instance().getSettingData().width, Config.instance().getSettingData().height);
-        }
-        config.setTitle("Forge Adventure Mobile");
-        config.setWindowIcon(Config.instance().getFilePath("forge-adventure.png"));
-        config.setWindowListener(new Lwjgl3WindowListener() {
-            @Override
-            public void created(Lwjgl3Window lwjgl3Window) {
-
-            }
-
-            @Override
-            public void iconified(boolean b) {
-
-            }
-
-            @Override
-            public void maximized(boolean b) {
-
-            }
-
-            @Override
-            public void focusLost() {
-
-            }
-
-            @Override
-            public void focusGained() {
-
-            }
-
-            @Override
-            public boolean closeRequested() {
-                //use the device adpater to exit properly
-                if (Forge.safeToClose)
-                    Forge.exit(true);
-                return false;
-            }
-
-            @Override
-            public void filesDropped(String[] strings) {
-
-            }
-
-            @Override
-            public void refreshRequested() {
-
-            }
-        });
-
-
-        new Lwjgl3Application(start, config);
-
-    }
-
-    private static class DesktopAdapter implements IDeviceAdapter {
-        private final String switchOrientationFile;
-
-        private DesktopAdapter(String switchOrientationFile0) {
-            switchOrientationFile = switchOrientationFile0;
-        }
-
-        //just assume desktop always connected to wifi
-        @Override
-        public boolean isConnectedToInternet() {
-            return true;
-        }
-
-        @Override
-        public boolean isConnectedToWifi() {
-            return true;
-        }
-
-        @Override
-        public String getDownloadsDir() {
-            return System.getProperty("user.home") + "/Downloads/";
-        }
-
-        @Override
-        public boolean openFile(String filename) {
-            try {
-                Desktop.getDesktop().open(new File(filename));
-                return true;
-            }
-            catch (IOException e) {
-                e.printStackTrace();
-            }
-            return false;
-        }
-
-        @Override
-        public void restart() {
-            if (RestartUtil.prepareForRestart()) {
-                Gdx.app.exit();
-                System.exit(0);
-            }
-        }
-
-        @Override
-        public void exit() {
-            Gdx.app.exit(); //can just use Gdx.app.exit for desktop
-            System.exit(0);
-        }
-
-        @Override
-        public boolean isTablet() {
-            return true; //treat desktop the same as a tablet
-        }
-
-        @Override
-        public void setLandscapeMode(boolean landscapeMode) {
-            //create file to indicate that landscape mode should be used
-            if (landscapeMode) {
-                FileUtil.writeFile(switchOrientationFile, "1");
-            }
-            else {
-                FileUtil.deleteFile(switchOrientationFile);
-            }
-        }
-
-        @Override
-        public void preventSystemSleep(boolean preventSleep) {
-            OperatingSystem.preventSystemSleep(preventSleep);
-        }
-
-        @Override
-        public void convertToJPEG(InputStream input, OutputStream output) throws IOException {
-            BufferedImage image = ImageIO.read(input);
-            ImageIO.write(image, "jpg", output);
-        }
+        GuiBase.setInterface(new GuiMobile(Files.exists(Paths.get("./res"))?"./":"../forge-gui/"));
+        GuiBase.setDeviceInfo("", "", 0, 0);
+        Config.instance();
+        new EditorMainWindow();
     }
 }

forge-adventure/src/main/java/forge/adventure/editor/ActionEdit.java

@@ -0,0 +1,156 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.DialogData;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+
+/**
+ * Editor class to edit configuration, maybe moved or removed
+ */
+public class ActionEdit extends FormPanel {
+    DialogData.ActionData currentData;
+
+    JTextField issueQuest = new JTextField();
+    JTextField mapFlagName = new JTextField();
+    JTextField questFlagName = new JTextField();
+    JTextField advanceMapFlag = new JTextField();
+    JTextField advanceQuestFlag = new JTextField();
+    JTextField battleWithActorID = new JTextField();
+    JTextField deleteMapObject = new JTextField();
+    JTextField setColorIdentity = new JTextField();
+    JSpinner addReputation = new JSpinner(new SpinnerNumberModel(0, -1000, 1000, 1));
+    JSpinner addLife = new JSpinner(new SpinnerNumberModel(0, -1000, 1000, 1));
+    JTextField POIReference = new JTextField();
+    JTextField removeItem = new JTextField();
+    JSpinner mapFlagValue = new JSpinner(new SpinnerNumberModel(0, 0, 1000, 1));
+    JSpinner questFlagValue = new JSpinner(new SpinnerNumberModel(0, 0, 1000, 1));
+
+    private boolean updating=false;
+
+    public ActionEdit()
+    {
+
+        //todo: add info pane to explain primary usage
+
+        add("Issue Quest:",issueQuest);
+        add("Set Map Flag Name:",mapFlagName);
+        add("Map Flag value to set:",mapFlagValue);
+        add("Set Quest Flag name:",questFlagName);
+        add("Quest Flag value to set:",questFlagValue);
+
+        add("Advance Map Flag name:",advanceMapFlag);
+        add("Advance Quest Flag name:",advanceQuestFlag);
+        add("Battle with actor ID:",battleWithActorID);
+        add("Delete map object:",deleteMapObject);
+        add("Set color identity:",setColorIdentity);
+        add("Add Reputation:",addReputation);
+        add("Add Life:",addLife);
+        add("POI Reference:",POIReference);
+        add("Remove Item:",removeItem);
+
+        issueQuest.getDocument().addDocumentListener(new DocumentChangeListener(ActionEdit.this::updateAction));
+        mapFlagName.getDocument().addDocumentListener(new DocumentChangeListener(ActionEdit.this::updateAction));
+        mapFlagValue.getModel().addChangeListener(e -> ActionEdit.this.updateAction());
+        questFlagName.getDocument().addDocumentListener(new DocumentChangeListener(ActionEdit.this::updateAction));
+        questFlagValue.getModel().addChangeListener(e -> ActionEdit.this.updateAction());
+        advanceMapFlag.getDocument().addDocumentListener(new DocumentChangeListener(ActionEdit.this::updateAction));
+        advanceQuestFlag.getDocument().addDocumentListener(new DocumentChangeListener(ActionEdit.this::updateAction));
+        battleWithActorID.getDocument().addDocumentListener(new DocumentChangeListener(ActionEdit.this::updateAction));
+        deleteMapObject.getDocument().addDocumentListener(new DocumentChangeListener(ActionEdit.this::updateAction));
+        setColorIdentity.getDocument().addDocumentListener(new DocumentChangeListener(ActionEdit.this::updateAction));
+        addLife.getModel().addChangeListener(e -> ActionEdit.this.updateAction());
+        addReputation.getModel().addChangeListener(e -> ActionEdit.this.updateAction());
+        POIReference.getDocument().addDocumentListener(new DocumentChangeListener(ActionEdit.this::updateAction));
+        removeItem.getDocument().addDocumentListener(new DocumentChangeListener(ActionEdit.this::updateAction));
+
+    }
+
+    private void updateAction() {
+        if(updating)
+            return;
+        if (currentData == null)
+            currentData = new DialogData.ActionData();
+
+        DialogData.ActionData.QuestFlag mapFlag = new DialogData.ActionData.QuestFlag();
+        mapFlag.key = mapFlagName.getText();
+        mapFlag.val = (int)mapFlagValue.getModel().getValue();
+        currentData.setMapFlag= mapFlag;
+
+        DialogData.ActionData.QuestFlag questFlag = new DialogData.ActionData.QuestFlag();
+        questFlag.key = questFlagName.getText();
+        questFlag.val = (int)questFlagValue.getModel().getValue();
+        currentData.setQuestFlag= questFlag;
+
+        currentData.issueQuest = issueQuest.getText(); //This is currently a boolean effect, eventually needs arguments
+        currentData.advanceMapFlag= advanceMapFlag.getText();
+        currentData.advanceQuestFlag= advanceQuestFlag.getText();
+        currentData.battleWithActorID= Integer.parseInt(battleWithActorID.getText());
+        currentData.deleteMapObject= Integer.parseInt(deleteMapObject.getText());
+        currentData.setColorIdentity= setColorIdentity.getText();
+        currentData.addLife= (int) addLife.getModel().getValue();
+        currentData.addMapReputation= (int)addReputation.getModel().getValue();
+        currentData.POIReference= POIReference.getText();
+        currentData.removeItem= removeItem.getText();
+
+        //These need a dedicated effect editor
+//        JTextField setEffect = new JTextField();
+//        JTextField giveBlessing = new JTextField();
+//        currentData.giveBlessing= giveBlessing.getText();
+//        currentData.setEffect= setEffect.getText();
+
+        //These are valid pre-existing fields, but should be handled through the dedicated rewards editor
+//        currentData.addGold =;
+//        currentData.addItem=;
+//        currentData.grantRewards =;
+
+        ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
+        if (listeners != null && listeners.length > 0) {
+            ChangeEvent evt = new ChangeEvent(this);
+            for (ChangeListener listener : listeners) {
+                listener.stateChanged(evt);
+            }
+        }
+
+    }
+    public void addChangeListener(ChangeListener l) {
+        listenerList.add(ChangeListener.class, l);
+    }
+    public void setCurrentAction(DialogData.ActionData data)
+    {
+        currentData=data;
+        refresh();
+    }
+
+    private void refresh() {
+        setEnabled(currentData!=null);
+        if(currentData==null)
+        {
+            return;
+        }
+        updating=true;
+
+        mapFlagName.setText(currentData.setMapFlag==null?"":currentData.setMapFlag.key);
+        mapFlagValue.getModel().setValue(currentData.setMapFlag==null?0:currentData.setMapFlag.val);
+
+        questFlagName.setText(currentData.setQuestFlag==null?"":currentData.setQuestFlag.key);
+        questFlagValue.getModel().setValue(currentData.setQuestFlag==null?0:currentData.setQuestFlag.val);
+
+        issueQuest.setText(currentData.issueQuest);
+        advanceMapFlag.setText(currentData.advanceMapFlag);
+        advanceQuestFlag.setText(currentData.advanceQuestFlag);
+
+        battleWithActorID.setText("" + currentData.battleWithActorID);
+        deleteMapObject.setText("" + currentData.deleteMapObject);
+        setColorIdentity.setText(currentData.setColorIdentity);
+        addLife.getModel().setValue(currentData.addLife);
+        addReputation.getModel().setValue(currentData.addMapReputation);
+
+        POIReference.setText(currentData.POIReference);
+        removeItem.setText(currentData.removeItem);
+
+        updating=false;
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/ActionEditor.java

@@ -0,0 +1,141 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.DialogData;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.*;
+import java.awt.event.ActionListener;
+
+/**
+ * Editor class to edit configuration, maybe moved or removed
+ */
+public class ActionEditor extends JComponent{
+    DefaultListModel<DialogData.ActionData> model = new DefaultListModel<>();
+    JList<DialogData.ActionData> list = new JList<>(model);
+    JToolBar toolBar = new JToolBar("toolbar");
+    ActionEdit edit=new ActionEdit();
+    boolean updating;
+
+
+    public class RewardDataRenderer extends DefaultListCellRenderer {
+        @Override
+        public Component getListCellRendererComponent(
+                JList list, Object value, int index,
+                boolean isSelected, boolean cellHasFocus) {
+            JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+            if(!(value instanceof DialogData.ActionData))
+                return label;
+            DialogData.ActionData action=(DialogData.ActionData) value;
+            StringBuilder builder=new StringBuilder();
+//            if(action.type==null||action.type.isEmpty())
+                builder.append("Action");
+//            else
+//                builder.append(action.type);
+            label.setText(builder.toString());
+            return label;
+        }
+    }
+    public void addButton(String name, ActionListener action)
+    {
+        JButton newButton=new JButton(name);
+        newButton.addActionListener(action);
+        toolBar.add(newButton);
+
+    }
+
+    public ActionEditor()
+    {
+
+        list.setCellRenderer(new RewardDataRenderer());
+        list.addListSelectionListener(e -> ActionEditor.this.updateEdit());
+        addButton("add", e -> ActionEditor.this.addAction());
+        addButton("remove", e -> ActionEditor.this.remove());
+        addButton("copy", e -> ActionEditor.this.copy());
+        BorderLayout layout=new BorderLayout();
+        setLayout(layout);
+        add(list, BorderLayout.LINE_START);
+        add(toolBar, BorderLayout.PAGE_START);
+        add(edit,BorderLayout.CENTER);
+
+
+        edit.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                emitChanged();
+            }
+        });
+    }
+    protected void emitChanged() {
+        if (updating)
+            return;
+        ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
+        if (listeners != null && listeners.length > 0) {
+            ChangeEvent evt = new ChangeEvent(this);
+            for (ChangeListener listener : listeners) {
+                listener.stateChanged(evt);
+            }
+        }
+    }
+    private void copy() {
+
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        DialogData.ActionData data=new DialogData.ActionData(model.get(selected));
+        model.add(model.size(),data);
+    }
+
+    private void updateEdit() {
+
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        edit.setCurrentAction(model.get(selected));
+    }
+
+    void addAction()
+    {
+        DialogData.ActionData data=new DialogData.ActionData();
+        model.add(model.size(),data);
+    }
+    void remove()
+    {
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        model.remove(selected);
+    }
+    public void setAction(DialogData.ActionData[] actions) {
+
+        model.clear();
+        if(actions==null)
+            return;
+        for (int i=0;i<actions.length;i++) {
+            if (actions[i].grantRewards.length > 0){
+                continue; //handled in separate editor and joined in on save, will get duplicated if it appears here
+            }
+            model.add(i,actions[i]);
+        }
+    }
+
+    public DialogData.ActionData[] getAction() {
+
+        DialogData.ActionData[] action= new DialogData.ActionData[model.getSize()];
+        for(int i=0;i<model.getSize();i++)
+        {
+            action[i]=model.get(i);
+        }
+        return action;
+    }
+
+    public void clear(){
+        updating = true;
+        model.clear();
+        updating = false;
+    }
+    public void addChangeListener(ChangeListener listener) {
+        listenerList.add(ChangeListener.class, listener);
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/BiomeEdit.java

@@ -0,0 +1,125 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.BiomeData;
+
+import javax.swing.*;
+
+public class BiomeEdit extends FormPanel {
+    BiomeData currentData;
+
+    public JSpinner startPointX= new JSpinner(new SpinnerNumberModel(0.0f, 0.f, 1f, 0.1f));
+    public JSpinner startPointY= new JSpinner(new SpinnerNumberModel(0.0f, 0.f, 1f, 0.1f));
+    public JSpinner noiseWeight= new JSpinner(new SpinnerNumberModel(0.0f, 0.f, 1f, 0.1f));
+    public JSpinner distWeight= new JSpinner(new SpinnerNumberModel(0.0f, 0.f, 1f, 0.1f));
+    public JTextField name=new JTextField();
+    public FilePicker tilesetAtlas=new FilePicker(new String[]{"atlas"});
+    public JTextField tilesetName=new JTextField();
+    public JSpinner width= new JSpinner(new SpinnerNumberModel(0.0f, 0.f, 1f, 0.1f));
+    public JSpinner height= new JSpinner(new SpinnerNumberModel(0.0f, 0.f, 1f, 0.1f));
+    public JTextField color=new JTextField();
+    public JCheckBox collision=new JCheckBox();
+    public TextListEdit spriteNames =new TextListEdit();
+    public TextListEdit enemies =new TextListEdit();
+    public TextListEdit pointsOfInterest =new TextListEdit();
+
+    public TerrainsEditor terrain =new TerrainsEditor();
+    public StructureEditor structures =new StructureEditor();
+    private boolean updating=false;
+
+    public BiomeEdit()
+    {
+
+        FormPanel center=new FormPanel() {  };
+
+        center.add("startPointX:",startPointX);
+        center.add("startPointY:",startPointY);
+        center.add("noiseWeight:",noiseWeight);
+        center.add("distWeight:",distWeight);
+        center.add("name:",name);
+        center.add("tilesetAtlas:",tilesetAtlas);
+        center.add("tilesetName:",tilesetName);
+        center.add("width:",width);
+        center.add("height:",height);
+        center.add("spriteNames:",spriteNames);
+        center.add("enemies:",enemies);
+        center.add("POITags:",pointsOfInterest);
+        center.add("color:",color);
+        center.add("collision:",collision);
+        center.add("terrain/structures:",new JLabel(""));
+
+        add(center);
+        add(terrain);
+        add(structures);
+
+        name.getDocument().addDocumentListener(new DocumentChangeListener(() -> BiomeEdit.this.updateTerrain()));
+        tilesetName.getDocument().addDocumentListener(new DocumentChangeListener(() -> BiomeEdit.this.updateTerrain()));
+        color.getDocument().addDocumentListener(new DocumentChangeListener(() -> BiomeEdit.this.updateTerrain()));
+        collision.addChangeListener(e -> BiomeEdit.this.updateTerrain());
+        spriteNames.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> BiomeEdit.this.updateTerrain()));
+        enemies.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> BiomeEdit.this.updateTerrain()));
+        terrain.addChangeListener(e -> BiomeEdit.this.updateTerrain());
+
+
+        startPointX.addChangeListener(e -> BiomeEdit.this.updateTerrain());
+        startPointY.addChangeListener(e -> BiomeEdit.this.updateTerrain());
+        noiseWeight.addChangeListener(e -> BiomeEdit.this.updateTerrain());
+        distWeight.addChangeListener(e -> BiomeEdit.this.updateTerrain());
+        tilesetAtlas.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> BiomeEdit.this.updateTerrain()));
+        width.addChangeListener(e -> BiomeEdit.this.updateTerrain());
+        height.addChangeListener(e -> BiomeEdit.this.updateTerrain());
+        refresh();
+    }
+
+    protected void updateTerrain() {
+        if(currentData==null||updating)
+            return;
+        currentData.startPointX    = (Float) startPointX.getValue();
+        currentData.startPointY    = (Float) startPointY.getValue();
+        currentData.noiseWeight    = (Float) noiseWeight.getValue();
+        currentData.distWeight      = (Float)distWeight.getValue();
+        currentData.name            = name.getText();
+        currentData.tilesetAtlas    = tilesetAtlas.edit.getText();
+        currentData.tilesetName    = tilesetName.getText();
+        currentData.terrain    = terrain.getBiomeTerrainData();
+        currentData.structures    = structures.getBiomeStructureData();
+        currentData.width    = (Float) width.getValue();
+        currentData.height    = (Float) height.getValue();
+        currentData.color    = color.getText();
+        currentData.collision    = collision.isSelected();
+        currentData.spriteNames    = spriteNames.getList();
+        currentData.enemies    = enemies.getList();
+        currentData.pointsOfInterest    = pointsOfInterest.getList();
+    }
+
+    public void setCurrentBiome(BiomeData data)
+    {
+        currentData=data;
+        refresh();
+    }
+
+    private void refresh() {
+        setEnabled(currentData!=null);
+        if(currentData==null)
+        {
+            return;
+        }
+        updating=true;
+        startPointX.setValue(currentData.startPointX);
+        startPointY.setValue(currentData.startPointY);
+        noiseWeight.setValue(currentData.noiseWeight);
+        distWeight.setValue(currentData.distWeight);
+        name.setText(currentData.name);
+        tilesetAtlas.edit.setText( currentData.tilesetAtlas);
+        tilesetName.setText(currentData.tilesetName);
+        terrain.setTerrains(currentData);
+        structures.setStructures(currentData);
+        width.setValue(currentData.width);
+        height.setValue(currentData.height);
+        color.setText(currentData.color);
+        spriteNames.setText(currentData.spriteNames);
+        enemies.setText(currentData.enemies);
+        collision.setSelected(currentData.collision);
+        pointsOfInterest.setText(currentData.pointsOfInterest);
+        updating=false;
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/BiomeStructureDataMappingEditor.java

@@ -0,0 +1,171 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.BiomeStructureData;
+import forge.adventure.util.Config;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionListener;
+
+public class BiomeStructureDataMappingEditor extends JComponent {
+    DefaultListModel<BiomeStructureData.BiomeStructureDataMapping> model = new DefaultListModel<>();
+    JList<BiomeStructureData.BiomeStructureDataMapping> list = new JList<>(model);
+    JToolBar toolBar = new JToolBar("toolbar");
+    BiomeStructureDataMappingEdit edit=new BiomeStructureDataMappingEdit();
+    private BiomeStructureData data;
+
+    public void setCurrent(BiomeStructureData data) {
+        this.data=data;
+        model.clear();
+        if(data==null||data.mappingInfo==null)
+            return;
+        for(int i=0;i<data.mappingInfo.length;i++)
+            model.addElement(data.mappingInfo[i]);
+
+        list.setSelectedIndex(0);
+    }
+
+    public BiomeStructureData.BiomeStructureDataMapping[] getCurrent()
+    {
+        BiomeStructureData.BiomeStructureDataMapping[] array=new BiomeStructureData.BiomeStructureDataMapping[model.size()];
+        for(int i=0;i<array.length;i++)
+            array[i]=model.get(i);
+        return array;
+    }
+
+    public class BiomeStructureDataMappingRenderer extends DefaultListCellRenderer {
+        private final BiomeStructureDataMappingEditor editor;
+
+        public BiomeStructureDataMappingRenderer(BiomeStructureDataMappingEditor biomeStructureDataMappingEditor) {
+            this.editor=biomeStructureDataMappingEditor;
+        }
+
+        @Override
+        public Component getListCellRendererComponent(
+                JList list, Object value, int index,
+                boolean isSelected, boolean cellHasFocus) {
+            JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+            if(!(value instanceof BiomeStructureData.BiomeStructureDataMapping))
+                return label;
+            BiomeStructureData.BiomeStructureDataMapping data=(BiomeStructureData.BiomeStructureDataMapping) value;
+            // Get the renderer component from parent class
+
+            label.setText(data.name);
+            if(editor.data!=null)
+            {
+                SwingAtlas itemAtlas=new SwingAtlas(Config.instance().getFile(editor.data.structureAtlasPath));
+                if(itemAtlas.has(data.name))
+                    label.setIcon(itemAtlas.get(data.name));
+                else
+                {
+                    ImageIcon img=itemAtlas.getAny();
+                    if(img!=null)
+                        label.setIcon(img);
+                }
+            }
+
+            return label;
+        }
+    }
+    public void addButton(String name, ActionListener action)
+    {
+        JButton newButton=new JButton(name);
+        newButton.addActionListener(action);
+        toolBar.add(newButton);
+
+    }
+    public BiomeStructureDataMappingEditor()
+    {
+
+        list.setCellRenderer(new BiomeStructureDataMappingEditor.BiomeStructureDataMappingRenderer(this));
+        list.addListSelectionListener(e -> BiomeStructureDataMappingEditor.this.updateEdit());
+        addButton("add", e -> BiomeStructureDataMappingEditor.this.add());
+        addButton("remove", e -> BiomeStructureDataMappingEditor.this.remove());
+        addButton("copy", e -> BiomeStructureDataMappingEditor.this.copy());
+        BorderLayout layout=new BorderLayout();
+        setLayout(layout);
+        add(new JScrollPane(list), BorderLayout.WEST);
+        add(toolBar, BorderLayout.NORTH);
+        add(edit,BorderLayout.CENTER);
+    }
+    private void copy() {
+
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        BiomeStructureData.BiomeStructureDataMapping data=new BiomeStructureData.BiomeStructureDataMapping(model.get(selected));
+        model.add(model.size(),data);
+    }
+    private void updateEdit() {
+
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        edit.setCurrent(model.get(selected));
+    }
+
+    void add()
+    {
+        BiomeStructureData.BiomeStructureDataMapping data=new BiomeStructureData.BiomeStructureDataMapping();
+        data.name="Structure "+model.getSize();
+        model.add(model.size(),data);
+    }
+    void remove()
+    {
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        model.remove(selected);
+    }
+
+    private class BiomeStructureDataMappingEdit extends FormPanel{
+        BiomeStructureData.BiomeStructureDataMapping currentData;
+
+
+        public JTextField name=new JTextField();
+        public JTextField color=new JTextField();
+        public JCheckBox collision=new JCheckBox();
+        private boolean updating=false;
+
+        public BiomeStructureDataMappingEdit()
+        {
+
+
+            add("name:",name);
+            add("color:",color);
+            add("collision:",collision);
+
+            name.getDocument().addDocumentListener(new DocumentChangeListener(() -> BiomeStructureDataMappingEdit.this.update()));
+            color.getDocument().addDocumentListener(new DocumentChangeListener(() -> BiomeStructureDataMappingEdit.this.update()));
+            collision.addChangeListener(e -> BiomeStructureDataMappingEdit.this.update());
+            refresh();
+        }
+
+        private void update() {
+            if(currentData==null||updating)
+                return;
+            currentData.name        = name.getText();
+            currentData.color       = color.getText();
+            currentData.collision   = collision.isSelected();
+        }
+
+        public void setCurrent(BiomeStructureData.BiomeStructureDataMapping data)
+        {
+            currentData=data;
+            refresh();
+        }
+
+        private void refresh() {
+            setEnabled(currentData!=null);
+            if(currentData==null)
+            {
+                return;
+            }
+            updating=true;
+            name.setText(currentData.name);
+            color.setText(currentData.color);
+            collision.setSelected(currentData.collision);
+            updating=false;
+        }
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/BiomeStructureEdit.java

@@ -0,0 +1,136 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.BiomeData;
+import forge.adventure.data.BiomeStructureData;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+public class BiomeStructureEdit extends FormPanel {
+    private boolean updating=false;
+    BiomeStructureData currentData;
+    BiomeData currentBiomeData;
+    public JTextField structureAtlasPath=new JTextField();
+    public FloatSpinner x= new FloatSpinner();
+    public FloatSpinner y= new FloatSpinner();
+    public FloatSpinner width= new FloatSpinner();
+    public FloatSpinner height= new FloatSpinner();
+    public JCheckBox randomPosition=new JCheckBox();
+    public IntSpinner N= new IntSpinner();
+    public JTextField sourcePath= new JTextField();
+    public JTextField maskPath= new JTextField();
+    public JCheckBox periodicInput= new JCheckBox();
+    public IntSpinner ground= new IntSpinner();
+    public IntSpinner symmetry= new IntSpinner();
+    public JCheckBox periodicOutput= new JCheckBox();
+    public BiomeStructureDataMappingEditor data=new BiomeStructureDataMappingEditor();
+    public BiomeStructureEdit()
+    {
+        FormPanel center=new FormPanel();
+
+        center.add("structureAtlasPath:",structureAtlasPath);
+        center.add("x:",x);
+        center.add("y:",y);
+        center.add("width:",width);
+        center.add("height:",height);
+        center.add("N:",N);
+        center.add("sourcePath:",sourcePath);
+        center.add("maskPath:",maskPath);
+        center.add("periodicInput:",periodicInput);
+        center.add("ground:",ground);
+        center.add("symmetry:",symmetry);
+        center.add("periodicOutput:",periodicOutput);
+
+        add(center);
+        add(data);
+
+        structureAtlasPath.getDocument().addDocumentListener(new DocumentChangeListener(() -> BiomeStructureEdit.this.updateStructure()));
+
+
+        x.addChangeListener(e -> BiomeStructureEdit.this.updateStructure());
+        y.addChangeListener(e -> BiomeStructureEdit.this.updateStructure());
+        width.addChangeListener(e -> BiomeStructureEdit.this.updateStructure());
+        height.addChangeListener(e -> BiomeStructureEdit.this.updateStructure());
+        randomPosition.addChangeListener(e -> BiomeStructureEdit.this.updateStructure());
+
+        N.addChangeListener(e -> BiomeStructureEdit.this.updateStructure());
+        sourcePath.getDocument().addDocumentListener(new DocumentChangeListener(() -> BiomeStructureEdit.this.updateStructure()));
+        maskPath.getDocument().addDocumentListener(new DocumentChangeListener(() -> BiomeStructureEdit.this.updateStructure()));
+        periodicInput.addChangeListener(e -> BiomeStructureEdit.this.updateStructure());
+        ground.addChangeListener(e -> BiomeStructureEdit.this.updateStructure());
+        symmetry.addChangeListener(e -> BiomeStructureEdit.this.updateStructure());
+        periodicOutput.addChangeListener(e -> BiomeStructureEdit.this.updateStructure());
+        refresh();
+    }
+    private void refresh() {
+        setEnabled(currentData!=null);
+        if(currentData==null)
+        {
+            data.setCurrent(null);
+            return;
+        }
+        updating=true;
+        structureAtlasPath.setText(currentData.structureAtlasPath);
+        x.setValue(currentData.x);
+        y.setValue(currentData.y);
+        width.setValue(currentData.width);
+        height.setValue(currentData.height);
+        randomPosition.setSelected(currentData.randomPosition);
+        N.setValue(currentData.N);
+        sourcePath.setText(currentData.sourcePath);
+        maskPath.setText(currentData.maskPath);
+        periodicInput.setSelected(currentData.periodicInput);
+        ground.setValue(currentData.ground);
+        symmetry.setValue(currentData.symmetry);
+        periodicOutput.setSelected(currentData.periodicOutput);
+
+        data.setCurrent(currentData);
+
+
+
+        updating=false;
+    }
+    public void updateStructure()
+    {
+
+        if(currentData==null||updating)
+            return;
+        currentData.structureAtlasPath=structureAtlasPath.getText();
+
+        currentData.x= x.floatValue();
+        currentData.y= y.floatValue();
+        currentData.width= width.floatValue();
+        currentData.height= height.floatValue();
+        currentData.randomPosition=randomPosition.isSelected();
+        currentData.mappingInfo= data.getCurrent();
+
+        currentData.N= N.intValue();
+        currentData.sourcePath= sourcePath.getText();
+        currentData.maskPath= maskPath.getText();
+        currentData.periodicInput= periodicInput.isSelected();
+        currentData.ground= ground.intValue();
+        currentData.symmetry= symmetry.intValue();
+        currentData.periodicOutput= periodicOutput.isSelected();
+        emitChanged();
+    }
+    public void setCurrentStructure(BiomeStructureData biomeTerrainData, BiomeData data) {
+        currentData =biomeTerrainData;
+        currentBiomeData=data;
+        refresh();
+    }
+
+    public void addChangeListener(ChangeListener listener) {
+        listenerList.add(ChangeListener.class, listener);
+    }
+    protected void emitChanged() {
+        ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
+        if (listeners != null && listeners.length > 0) {
+            ChangeEvent evt = new ChangeEvent(this);
+            for (ChangeListener listener : listeners) {
+                listener.stateChanged(evt);
+            }
+        }
+    }
+
+}

forge-adventure/src/main/java/forge/adventure/editor/BiomeTerrainEdit.java

@@ -0,0 +1,84 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.BiomeData;
+import forge.adventure.data.BiomeTerrainData;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+public class BiomeTerrainEdit extends FormPanel {
+    SwingAtlasPreview preview=new SwingAtlasPreview(128);
+    private boolean updating=false;
+    BiomeTerrainData currentData;
+    BiomeData currentBiomeData;
+    public JTextField spriteName=new JTextField();
+    public JSpinner min= new JSpinner(new SpinnerNumberModel(0.0f, 0.f, 1f, 0.1f));
+    public JSpinner max= new JSpinner(new SpinnerNumberModel(0.0f, 0.f, 1f, 0.1f));
+    public JSpinner resolution= new JSpinner(new SpinnerNumberModel(0.0f, 0.f, 1f, 0.1f));
+
+    public BiomeTerrainEdit()
+    {
+        FormPanel center=new FormPanel() {  };
+
+        center.add("spriteName:",spriteName);
+        center.add("min:",min);
+        center.add("max:",max);
+        center.add("resolution:",resolution);
+        add(center,preview);
+
+        spriteName.getDocument().addDocumentListener(new DocumentChangeListener(() -> BiomeTerrainEdit.this.updateTerrain()));
+
+        min.addChangeListener(e -> BiomeTerrainEdit.this.updateTerrain());
+        max.addChangeListener(e -> BiomeTerrainEdit.this.updateTerrain());
+        resolution.addChangeListener(e -> BiomeTerrainEdit.this.updateTerrain());
+
+
+        refresh();
+    }
+    private void refresh() {
+        setEnabled(currentData!=null);
+        if(currentData==null)
+        {
+            return;
+        }
+        updating=true;
+        spriteName.setText(currentData.spriteName);
+        min.setValue(currentData.min);
+        max.setValue(currentData.max);
+        resolution.setValue(currentData.resolution);
+        if(currentBiomeData!=null&&currentData!= null)
+            preview.setSpritePath(currentBiomeData.tilesetAtlas,currentData.spriteName);
+        updating=false;
+    }
+    public void updateTerrain()
+    {
+
+        if(currentData==null||updating)
+            return;
+        currentData.spriteName=spriteName.getText();
+        currentData.min= (float) min.getValue();
+        currentData.max= (float) max.getValue();
+        currentData.resolution= (float) resolution.getValue();
+        preview.setSpritePath(currentBiomeData.tilesetAtlas,currentData.spriteName);
+        emitChanged();
+    }
+    public void setCurrentTerrain(BiomeTerrainData biomeTerrainData, BiomeData data) {
+        currentData =biomeTerrainData;
+        currentBiomeData=data;
+        refresh();
+    }
+
+    public void addChangeListener(ChangeListener listener) {
+        listenerList.add(ChangeListener.class, listener);
+    }
+    protected void emitChanged() {
+        ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
+        if (listeners != null && listeners.length > 0) {
+            ChangeEvent evt = new ChangeEvent(this);
+            for (ChangeListener listener : listeners) {
+                listener.stateChanged(evt);
+            }
+        }
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/DialogEdit.java

@@ -0,0 +1,155 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.DialogData;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import java.awt.*;
+
+public class DialogEdit extends FormPanel {
+    private boolean updating=false;
+    DialogData currentData;
+
+    public JTextField name=new JTextField(80);
+    public JTextField text=new JTextField(80);
+    public JTextField locname=new JTextField(80);
+    public JTextField loctext=new JTextField(80);
+
+    JPanel namePanel;
+    JPanel locNamePanel;
+
+    public JButton addNode = new JButton("Add node");
+    public JButton removeNode = new JButton("Remove node");
+
+    public DialogEdit()
+    {
+        FormPanel center=new FormPanel() {  };
+
+        name.getDocument().addDocumentListener(new DocumentListener() {
+            @Override
+            public void insertUpdate(DocumentEvent e) {
+                if (!updating)
+                    emitChanged();
+            }
+
+            @Override
+            public void removeUpdate(DocumentEvent e) {
+                if (!updating)
+                    emitChanged();
+            }
+
+            @Override
+            public void changedUpdate(DocumentEvent e) {
+                if (!updating)
+                    emitChanged();
+            }
+        });
+
+        text.getDocument().addDocumentListener(new DocumentListener() {
+            @Override
+            public void insertUpdate(DocumentEvent e) {
+               if (!updating)
+                    emitChanged();
+            }
+
+            @Override
+            public void removeUpdate(DocumentEvent e) {
+                if (!updating)
+                    emitChanged();
+            }
+
+            @Override
+            public void changedUpdate(DocumentEvent e) {
+                if (!updating)
+                    emitChanged();
+            }
+        });
+
+
+        JPanel editData = new JPanel();
+        editData.setLayout(new BoxLayout(editData, BoxLayout.Y_AXIS));
+
+        namePanel = new JPanel();
+        namePanel.setLayout(new FlowLayout());
+        namePanel.add(new JLabel("Name:"));
+        namePanel.add(name);
+        editData.add(namePanel);
+
+        JPanel textPanel = new JPanel();
+        textPanel.setLayout(new FlowLayout());
+        textPanel.add(new JLabel("Text:"));
+        textPanel.add(text);
+        editData.add(textPanel);
+
+        JPanel buttonPanel = new JPanel();
+        buttonPanel.setLayout(new FlowLayout());
+        buttonPanel.add(addNode);
+        buttonPanel.add(removeNode);
+        editData.add(buttonPanel);
+
+        editData.add(new JLabel("localization tokens for translation"));
+
+        locNamePanel = new JPanel();
+        locNamePanel.setLayout(new FlowLayout());
+        locNamePanel.add(new JLabel("Name Token:"));
+        locNamePanel.add(locname);
+
+
+        JPanel locTextPanel = new JPanel();
+        locTextPanel.setLayout(new FlowLayout());
+        locTextPanel.add(new JLabel("Text Token:"));
+        locTextPanel.add(loctext);
+
+        editData.add(locNamePanel);
+        editData.add(locTextPanel);
+        center.add(editData);
+
+        add(center);
+
+        refresh();
+    }
+
+    public void refresh(){
+        refresh(false);
+    }
+
+    public void refresh(boolean onRootNode) {
+        setEnabled(currentData!=null);
+        if(currentData==null)
+        {
+            return;
+        }
+        updating=true;
+        name.setText(currentData.name);
+        locname.setText(currentData.locname);
+        text.setText(currentData.text);
+
+        loctext.setText(currentData.loctext);
+
+        namePanel.setVisible(!onRootNode);
+        locNamePanel.setVisible(!onRootNode);
+
+
+
+
+
+        updating=false;
+    }
+
+    public void addChangeListener(ChangeListener listener) {
+        listenerList.add(ChangeListener.class, listener);
+    }
+
+    protected void emitChanged() {
+        ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
+        if (listeners != null && listeners.length > 0) {
+            ChangeEvent evt = new ChangeEvent(this);
+            for (ChangeListener listener : listeners) {
+                listener.stateChanged(evt);
+            }
+        }
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/DialogEditor.java

@@ -0,0 +1,242 @@
+package forge.adventure.editor;
+
+import com.google.common.collect.ObjectArrays;
+import forge.adventure.data.DialogData;
+import forge.adventure.data.RewardData;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+
+/**
+ * Editor class to edit configuration, maybe moved or removed
+ */
+public class DialogEditor extends JComponent{
+
+    private boolean updating = false;
+    private java.util.List<DialogData> allNodes = new ArrayList<>();
+
+    public JTextArea text =new JTextArea("(Initial dialog text)", 3, 80);
+    public RewardsEditor rewardsEditor = new RewardsEditor();
+    public ActionEditor actionEditor = new ActionEditor();
+    public DialogOptionEditor optionEditor = new DialogOptionEditor();
+    public DialogTree navTree = new DialogTree();
+
+    public DialogEdit edit = new DialogEdit();
+
+    private DialogData root = new DialogData();
+    private DialogData current = new DialogData();
+
+    public DialogEditor(){
+        buildUI();
+
+        navTree.addSelectionListener(q -> loadNewNodeSelection());
+        edit.addChangeListener(q-> acceptEdits());
+        edit.addNode.addActionListener(q -> addNode());
+        edit.removeNode.addActionListener(q -> removeNode());
+    }
+
+    public void loadData(DialogData rootDialogData){
+        updating = true;
+        if (rootDialogData == null)
+        {
+            rootDialogData = new DialogData();
+        }
+        root = rootDialogData;
+        navTree.loadDialog(rootDialogData);
+        text.setText(rootDialogData.text);
+
+        updating = false;
+    }
+
+    public DialogData getDialogData(){
+
+        return root;
+    }
+
+    JTabbedPane tabs = new JTabbedPane();
+    JToolBar conditionsToolbar = new JToolBar("conditionsToolbar");
+    JToolBar actionsToolbar = new JToolBar("actionsToolbar");
+    JToolBar optionsToolbar = new JToolBar("optionsToolbar");
+    JToolBar tokensToolbar = new JToolBar("tokensToolbar");
+
+    JPanel conditionsPanel = new JPanel();
+    JPanel actionsPanel = new JPanel();
+    JPanel optionsPanel = new JPanel();
+    JPanel rewardsPanel = new JPanel();
+    JPanel tokensPanel = new JPanel();
+
+    class QuestTextDocumentListener implements DocumentListener {
+        public void changedUpdate(DocumentEvent e) {
+            root.text = text.getText();
+            emitChanged();
+        }
+        public void removeUpdate(DocumentEvent e) {
+            root.text = text.getText();
+            emitChanged();
+        }
+        public void insertUpdate(DocumentEvent e) {
+            root.text = text.getText();
+            emitChanged();
+        }
+    }
+
+    public void buildUI(){
+        buildTabs();
+        BorderLayout layout=new BorderLayout();
+        setLayout(layout);
+        JPanel textArea = new JPanel();
+        textArea.setLayout(new FlowLayout());
+        textArea.add(new JLabel("Dialog Start"));
+        textArea.add(text);
+        text.getDocument().addDocumentListener(new QuestTextDocumentListener());
+
+        JSplitPane splitPane = new JSplitPane();
+        splitPane.setLeftComponent(navTree);
+        splitPane.setRightComponent(tabs);
+        splitPane.setResizeWeight(0.2);
+        splitPane.setDividerLocation(.2);
+
+        add(textArea, BorderLayout.NORTH);
+        add(splitPane, BorderLayout.CENTER);
+    }
+
+    public void loadNewNodeSelection(){
+        updating = true;
+        current = navTree.getSelectedData();
+        edit.currentData = navTree.getSelectedData();
+        edit.refresh(root.equals(current));
+        rewardsEditor.clear();
+        actionEditor.clear();
+        if (navTree.getSelectedData() != null) {
+            for (DialogData.ActionData action : navTree.getSelectedData().action) {
+                if (action.grantRewards != null && action.grantRewards.length > 0)
+                    rewardsEditor.setRewards(action.grantRewards);
+            }
+            actionEditor.setAction(navTree.getSelectedData().action);
+        }
+        updating = false;
+    }
+
+    public void acceptEdits(){
+        if (current == null)
+            return;
+        current.name = edit.name.getText();
+        current.text = edit.text.getText();
+        current.locname = edit.locname.getText();
+        current.loctext = edit.loctext.getText();
+        root.text = text.getText();
+
+        DialogData.ActionData[] action = actionEditor.getAction();
+
+        ArrayList<DialogData.ActionData> actionsList = new ArrayList<>(Arrays.stream(action).collect(Collectors.toList()));
+
+        RewardData[] rewards= rewardsEditor.getRewards();
+        if (rewards.length > 0)
+        {
+            DialogData.ActionData rewardAction = new DialogData.ActionData();
+            rewardAction.grantRewards = rewards;
+            actionsList.add(rewardAction);
+        }
+
+        current.action = actionsList.toArray(current.action);
+
+        navTree.replaceCurrent();
+        emitChanged();
+    }
+
+    public void addNode(){
+        DialogData newNode = new DialogData();
+        newNode.name = "NewResponse";
+        DialogData parent = navTree.getSelectedData()!=null?navTree.getSelectedData():root;
+        parent.options = ObjectArrays.concat(parent.options, newNode);
+        navTree.loadDialog(root);
+        navTree.setSelectedData(newNode);
+        emitChanged();
+    }
+    public void removeNode(){
+        if (navTree.getSelectedData() == null)
+            return;
+        navTree.removeSelectedData();
+        emitChanged();
+    }
+
+    public void buildTabs(){
+        buildToolBars();
+
+        actionsPanel.add(actionsToolbar);
+        actionsPanel.add(actionEditor);
+        optionsPanel.add(edit);
+        rewardsPanel.add(rewardsEditor);
+        rewardsEditor.addChangeListener(e -> DialogEditor.this.acceptEdits());
+        actionEditor.addChangeListener(e -> DialogEditor.this.acceptEdits());
+        tokensPanel.add(tokensToolbar);
+        tokensPanel.add(new JLabel("Insert token editor here"));
+
+        tabs.addTab("Options", optionsPanel);
+        tabs.addTab("Conditions", conditionsPanel);
+        tabs.addTab("Actions", actionsPanel);
+        tabs.addTab("Rewards", rewardsPanel);
+        tabs.addTab("Tokens",tokensPanel);
+    }
+
+    public void buildToolBars(){
+        conditionsToolbar.setFloatable(false);
+        actionsToolbar.setFloatable(false);
+        optionsToolbar.setFloatable(false);
+
+        JButton addOption = new JButton("Add Option");
+        addOption.addActionListener(e -> DialogEditor.this.addOption());
+        optionsToolbar.add(addOption);
+
+        JButton copyOption = new JButton("Copy Selected");
+        copyOption.addActionListener(e -> DialogEditor.this.copyOption());
+        optionsToolbar.add(copyOption);
+
+        JButton removeOption = new JButton("Remove Selected");
+        removeOption.addActionListener(e -> DialogEditor.this.removeOption());
+        optionsToolbar.add(removeOption);
+
+    }
+        public void addOption(){
+        optionEditor.addOption();
+            emitChanged();
+    }
+
+    public void copyOption(){
+        emitChanged();
+    }
+
+    public void removeOption(){
+        int selected=optionEditor.list.getSelectedIndex();
+        if(selected<0)
+            return;
+        optionEditor.model.remove(selected);
+        emitChanged();
+    }
+
+    protected void emitChanged() {
+        if (updating)
+            return;
+
+        ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
+        if (listeners != null && listeners.length > 0) {
+            ChangeEvent evt = new ChangeEvent(this);
+            for (ChangeListener listener : listeners) {
+                listener.stateChanged(evt);
+            }
+        }
+    }
+
+    public void addChangeListener(ChangeListener listener) {
+        listenerList.add(ChangeListener.class, listener);
+    }
+
+}

forge-adventure/src/main/java/forge/adventure/editor/DialogOptionEdit.java

@@ -0,0 +1,85 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.DialogData;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.*;
+
+/**
+ * Editor class to edit configuration, maybe moved or removed
+ */
+public class DialogOptionEdit extends FormPanel {
+    DialogData currentData;
+
+    JLabel nameLabel = new JLabel("Name (Player dialog / action)");
+    JLabel textLabel = new JLabel("Text (Game response to Name - Leave blank to end dialog)");
+    JTextArea text =new JTextArea(3,80);
+    JTextArea name =new JTextArea(3,80);
+    JButton add = new JButton();
+    JButton load = new JButton();
+
+    private boolean updating=false;
+
+    public DialogOptionEdit()
+    {
+        setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
+
+        JPanel upper = new JPanel();
+        upper.setLayout(new BorderLayout());
+
+        upper.add(nameLabel, BorderLayout.NORTH);
+        upper.add(name, BorderLayout.CENTER);
+        add(upper);
+
+        JPanel middle = new JPanel();
+        middle.setLayout(new BorderLayout());
+        middle.add(textLabel, BorderLayout.NORTH);
+        middle.add(text, BorderLayout.CENTER);
+
+        add(middle);
+
+        name.getDocument().addDocumentListener(new DocumentChangeListener(() -> DialogOptionEdit.this.updateDialog()));
+        text.getDocument().addDocumentListener(new DocumentChangeListener(() -> DialogOptionEdit.this.updateDialog()));
+
+
+    }
+
+    private void updateDialog() {
+        if(currentData==null||updating)
+            return;
+
+        currentData.text = text.getText().trim();
+        currentData.name = name.getText().trim();
+
+        //currentData.condition = conditionEditor.getConditions();
+
+        ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
+        if (listeners != null && listeners.length > 0) {
+            ChangeEvent evt = new ChangeEvent(this);
+            for (ChangeListener listener : listeners) {
+                listener.stateChanged(evt);
+            }
+        }
+
+    }
+    public void addChangeListener(ChangeListener l) {
+        listenerList.add(ChangeListener.class, l);
+    }
+    public void setCurrentOption(DialogData data)
+    {
+        currentData=data;
+        refresh();
+    }
+
+    private void refresh() {
+        setEnabled(currentData!=null);
+        updating=true;
+
+        text.setText(currentData.text!=null?currentData.text:"");
+        name.setText(currentData.name!=null?currentData.name:"");
+
+        updating=false;
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/DialogOptionEditor.java

@@ -0,0 +1,139 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.DialogData;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.*;
+import java.awt.event.ActionListener;
+
+/**
+ * Editor class to edit configuration, maybe moved or removed
+ */
+public class DialogOptionEditor extends JComponent{
+    DefaultListModel<DialogData> model = new DefaultListModel<>();
+    JList<DialogData> list = new JList<>(model);
+    JToolBar toolBar = new JToolBar("toolbar");
+    DialogOptionEdit edit=new DialogOptionEdit();
+
+
+
+    public class DialogDataRenderer extends DefaultListCellRenderer {
+        @Override
+        public Component getListCellRendererComponent(
+                JList list, Object value, int index,
+                boolean isSelected, boolean cellHasFocus) {
+            JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+            if(!(value instanceof DialogData))
+                return label;
+            DialogData dialog=(DialogData) value;
+            StringBuilder builder=new StringBuilder();
+            if(dialog.name==null||dialog.name.isEmpty())
+                builder.append("[[Blank Option]]");
+            else
+                builder.append(dialog.name, 0, Math.min(dialog.name.length(), 25));
+            label.setText(builder.toString());
+            return label;
+        }
+    }
+    public void addButton(String name, ActionListener action)
+    {
+        JButton newButton=new JButton(name);
+        newButton.addActionListener(action);
+        toolBar.add(newButton);
+
+    }
+
+    public DialogOptionEditor()
+    {
+
+        list.setCellRenderer(new DialogDataRenderer());
+        list.addListSelectionListener(e -> DialogOptionEditor.this.updateEdit());
+        addButton("add", e -> DialogOptionEditor.this.addOption());
+        addButton("remove", e -> DialogOptionEditor.this.remove());
+        addButton("copy", e -> DialogOptionEditor.this.copy());
+        BorderLayout layout=new BorderLayout();
+        setLayout(layout);
+        add(list, BorderLayout.LINE_START);
+        add(toolBar, BorderLayout.PAGE_START);
+        toolBar.setFloatable(false);
+        add(edit,BorderLayout.CENTER);
+        edit.setVisible(false);
+
+        edit.addChangeListener(e -> emitChanged());
+    }
+    protected void emitChanged() {
+        ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
+        if (listeners != null && listeners.length > 0) {
+            ChangeEvent evt = new ChangeEvent(this);
+            for (ChangeListener listener : listeners) {
+                listener.stateChanged(evt);
+            }
+        }
+    }
+
+    private void copy() {
+
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        DialogData data=new DialogData(model.get(selected));
+        model.add(model.size(),data);
+    }
+
+    private void updateEdit() {
+
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            edit.setCurrentOption(new DialogData());
+        else
+            edit.setCurrentOption(model.get(selected));
+    }
+
+    void addOption()
+    {
+        DialogData data=new DialogData();
+        model.add(model.size(),data);
+        edit.setVisible(true);
+        list.setSelectedIndex(model.size() - 1);
+    }
+    void remove()
+    {
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        model.remove(selected);
+        edit.setVisible(model.size() > 0);
+    }
+    public void setOptions(DialogData[] options) {
+        model.clear();
+        if(options==null || options.length == 0)
+            options = new DialogData[0];
+        for (int i=0;i<options.length;i++) {
+            model.add(i,options[i]);
+        }
+        if (model.size() > 0)
+        {
+            edit.setVisible(true);
+            list.setSelectedIndex(0);
+            updateEdit();
+        }
+        else{
+            edit.setVisible(false);
+        }
+    }
+
+    public DialogData[] getOptions() {
+        DialogData[] options= new DialogData[model.getSize()];
+        for(int i=0;i<model.getSize();i++)
+        {
+            options[i]=model.get(i);
+        }
+        return options;
+    }
+    public void addChangeListener(ChangeListener listener) {
+        listenerList.add(ChangeListener.class, listener);
+    }
+
+}

forge-adventure/src/main/java/forge/adventure/editor/DialogTree.java

@@ -0,0 +1,121 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.DialogData;
+
+import javax.swing.*;
+import javax.swing.event.*;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreePath;
+import javax.swing.tree.TreeSelectionModel;
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class DialogTree extends JPanel {
+    private JTree dialogTree;
+    private JScrollPane scrollPane;
+
+
+    public DialogTree(){
+        setLayout(new BorderLayout());
+        // Create the JTree component
+        dialogTree = new JTree();
+        dialogTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
+        addSelectionListener();
+        // Create a scroll pane to contain the JTree
+        scrollPane = new JScrollPane(dialogTree);
+        // Add the scroll pane to the panel
+        add(scrollPane, BorderLayout.CENTER);
+    }
+
+    public void loadDialog(DialogData dialogData){
+//        rootNode = buildBranches(dialogData);
+//        ((DefaultTreeModel)dialogTree.getModel()).setRoot(rootNode);
+        ((DefaultTreeModel)dialogTree.getModel()).setRoot(buildBranches(dialogData));
+    }
+
+    public DefaultMutableTreeNode buildBranches(DialogData dialogData)
+    {
+        DefaultMutableTreeNode node = new DefaultMutableTreeNode(dialogData);
+        for (DialogData option : dialogData.options){
+            node.add(buildBranches(option));
+        }
+        return node;
+    }
+
+    private final List<TreeSelectionListener> selectionListeners = new ArrayList<>();
+
+    public void addSelectionListener(){
+        //subscribe to valueChanged, change to that object in edit pane
+        dialogTree.getSelectionModel().addTreeSelectionListener(new TreeSelectionListener() {
+            @Override
+            public void valueChanged(TreeSelectionEvent e) {
+                emitChanged(e);
+            }
+        });
+
+    }
+
+    public void addSelectionListener(final TreeSelectionListener listener) {
+        selectionListeners.remove(listener); //ensure listener not added multiple times
+        selectionListeners.add(listener);
+    }
+
+    protected void emitChanged(TreeSelectionEvent evt) {
+        if (selectionListeners != null && selectionListeners.size() > 0) {
+            for (TreeSelectionListener listener : selectionListeners) {
+                listener.valueChanged(evt);
+            }
+        }
+    }
+
+    public void replaceCurrent(){
+        if (dialogTree.getSelectionPath() == null || dialogTree.getSelectionPath().getLastPathComponent() == null)
+            return;
+        dialogTree.updateUI();
+    }
+
+    public DialogData getSelectedData() {
+        DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) dialogTree.getLastSelectedPathComponent();
+        if (selectedNode != null) {
+            return (DialogData) selectedNode.getUserObject();
+        }
+        return null;
+    }
+
+    public void removeSelectedData() {
+        //Todo: Enhance this to not collapse any nodes (after setSelectedData other paths are still collapsed)
+        DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) dialogTree.getLastSelectedPathComponent();
+
+        DialogData parentData = (DialogData) ((DefaultMutableTreeNode)selectedNode.getParent()).getUserObject();
+        parentData.options = Arrays.stream(parentData.options).filter(q -> q != selectedNode.getUserObject()).toArray(DialogData[]::new);
+       ((DefaultTreeModel) dialogTree.getModel()).removeNodeFromParent(selectedNode);
+        ((DefaultTreeModel) dialogTree.getModel()).reload();
+
+        setSelectedData(parentData);
+    }
+    public void setSelectedData(DialogData data) {
+        // Find the node with the given data object and select it in the tree
+        DefaultMutableTreeNode node = findNode((DefaultMutableTreeNode)dialogTree.getModel().getRoot(), data);
+        if (node != null) {
+            dialogTree.setSelectionPath(new TreePath(node.getPath()));
+        }
+    }
+
+    private DefaultMutableTreeNode findNode(DefaultMutableTreeNode parent, DialogData data) {
+        // Search for the node with the given data object in the subtree rooted at the parent node
+        if (parent.getUserObject() == data) {
+            return parent;
+        }
+        for (int i = 0; i < parent.getChildCount(); i++) {
+            DefaultMutableTreeNode child = (DefaultMutableTreeNode) parent.getChildAt(i);
+            DefaultMutableTreeNode result = findNode(child, data);
+            if (result != null) {
+                return result;
+            }
+        }
+        return null;
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/EditorMainWindow.java

@@ -1,5 +1,9 @@
 package forge.adventure.editor;
 
+
+
+import com.badlogic.gdx.tools.particleeditor.ParticleEditor;
+
 import javax.swing.*;
 import java.awt.*;
 
@@ -7,18 +11,42 @@ import java.awt.*;
  * Editor class to edit configuration, maybe moved or removed
  */
 public class EditorMainWindow extends JFrame {
+    public final static WorldEditor worldEditor = new WorldEditor();
     JTabbedPane tabs =new JTabbedPane();
 
     public EditorMainWindow()
     {
+        UIManager.LookAndFeelInfo[] var1 = UIManager.getInstalledLookAndFeels();
+        int var2 = var1.length;
+
+        for(int var3 = 0; var3 < var2; ++var3) {
+            UIManager.LookAndFeelInfo info = var1[var3];
+            if ("Nimbus".equals(info.getName())) {
+                try {
+                    UIManager.setLookAndFeel(info.getClassName());
+                } catch (Throwable var6) {
+                }
+                break;
+            }
+        }
         BorderLayout layout=new BorderLayout();
+        JToolBar toolBar = new JToolBar("toolbar");
+        JButton newButton=new JButton("open ParticleEditor");
+        newButton.addActionListener(e -> EventQueue.invokeLater(() ->new ParticleEditor()));
+        toolBar.add(newButton);
         setLayout(layout);
-        add(tabs);
+        toolBar.setFloatable(false);
+        add(toolBar, BorderLayout.NORTH);
+        add(tabs, BorderLayout.CENTER);
+        tabs.addTab("World",worldEditor);
         tabs.addTab("POI",new PointOfInterestEditor());
-        tabs.addTab("World",new WorldEditor());
         tabs.addTab("Items",new ItemsEditor());
         tabs.addTab("Enemies",new EnemyEditor());
+        tabs.addTab("Quests",new QuestEditor());
+
         setVisible(true);
         setSize(800,600);
+        GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().setFullScreenWindow( this );
+
     }
 }

forge-adventure/src/main/java/forge/adventure/editor/EffectEditor.java

@@ -5,7 +5,6 @@ import forge.adventure.data.EffectData;
 import javax.swing.*;
 import javax.swing.event.ChangeEvent;
 import javax.swing.event.ChangeListener;
-import java.awt.*;
 
 public class EffectEditor extends JComponent  {
     EffectData currentData;
@@ -25,16 +24,15 @@ public class EffectEditor extends JComponent  {
         if(!isOpponentEffect)
             opponent=new EffectEditor(true);
         setLayout(new BoxLayout(this,BoxLayout.Y_AXIS));
-        JPanel parameters=new JPanel();
+        FormPanel parameters=new FormPanel();
         parameters.setBorder(BorderFactory.createTitledBorder("Effect"));
-        parameters.setLayout(new GridLayout(7,2)) ;
 
-        parameters.add(new JLabel("Name:"));                        parameters.add(name);
-        parameters.add(new JLabel("Start with extra cards:"));      parameters.add(changeStartCards);
-        parameters.add(new JLabel("Change life:"));                 parameters.add(lifeModifier);
-        parameters.add(new JLabel("Movement speed:"));              parameters.add(moveSpeed);
-        parameters.add(new JLabel("Start battle with cards:"));     parameters.add(startBattleWithCard);
-        parameters.add(new JLabel("color view:"));                  parameters.add(colorView);
+        parameters.add("Name:",  name);
+        parameters.add("Start with extra cards:",    changeStartCards);
+        parameters.add("Change life:",             lifeModifier);
+        parameters.add("Movement speed:",          moveSpeed);
+        parameters.add("Start battle with cards:",    startBattleWithCard);
+        parameters.add("color view:",              colorView);
         add(parameters);
         if(!isOpponentEffect)
         {    add(new JLabel("Opponent:")); add(opponent);}

forge-adventure/src/main/java/forge/adventure/editor/EnemyEdit.java

@@ -3,68 +3,270 @@ package forge.adventure.editor;
 import forge.adventure.data.EnemyData;
 
 import javax.swing.*;
+import javax.swing.event.ListDataEvent;
+import javax.swing.event.ListDataListener;
 import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.util.ArrayList;
+import java.util.Enumeration;
 
 /**
  * Editor class to edit configuration, maybe moved or removed
  */
-public class EnemyEdit extends JComponent {
+public class EnemyEdit extends FormPanel {
     EnemyData currentData;
-
-
     JTextField nameField=new JTextField();
+    JTextField nameOverride=new JTextField();
     JTextField colorField=new JTextField();
-    JSpinner lifeFiled= new JSpinner(new SpinnerNumberModel(0, 0, 1000, 1));
-    JSpinner spawnRate= new JSpinner(new SpinnerNumberModel(0.0, 0., 1, 0.1));
-    JSpinner difficulty= new JSpinner(new SpinnerNumberModel(0.0, 0., 1, 0.1));
-    JSpinner speed= new JSpinner(new SpinnerNumberModel(0.0, 0., 100., 1.0));
+    JTextField ai=new JTextField();
+    JCheckBox flying=new JCheckBox();
+    JCheckBox boss=new JCheckBox();
+    JCheckBox ignoreDungeonEffect=new JCheckBox();
+    FloatSpinner lifeFiled= new FloatSpinner(0, 1000, 1);
+    FloatSpinner spawnRate= new FloatSpinner(  0.f, 1, 0.1f);
+    FloatSpinner difficulty= new FloatSpinner(  0.f, 1, 0.1f);
+    FloatSpinner speed= new FloatSpinner( 0.f, 100.f, 1.0f);
     FilePicker deck=new FilePicker(new String[]{"dck","json"});
     FilePicker atlas=new FilePicker(new String[]{"atlas"});
     JTextField equipment=new JTextField();
     RewardsEditor rewards=new RewardsEditor();
     SwingAtlasPreview preview=new SwingAtlasPreview();
+    JTextField manualEntry = new JTextField(20);
     private boolean updating=false;
 
+    DefaultListModel<String> existingModel = new DefaultListModel<>();
+    DefaultListModel<String> enemyModel = new DefaultListModel<>();
+    JList<String> existingTags;
+    JList<String> enemyTags;
+
     public EnemyEdit()
     {
+        setLayout(new BorderLayout());
+        FormPanel top=new FormPanel() {  };
+        add(top, BorderLayout.NORTH);
 
-        JComponent center=new JComponent() {  };
-        center.setLayout(new GridLayout(9,2));
+        JTabbedPane tabs = new JTabbedPane();
+        add(tabs, BorderLayout.CENTER);
+        FormPanel basicInfo=new FormPanel() {  };
+        tabs.addTab("Basic Info", basicInfo);
 
-        center.add(new JLabel("Name:")); center.add(nameField);
-        center.add(new JLabel("Life:")); center.add(lifeFiled);
-        center.add(new JLabel("Spawn rate:")); center.add(spawnRate);
-        center.add(new JLabel("Difficulty:")); center.add(difficulty);
-        center.add(new JLabel("Speed:")); center.add(speed);
-        center.add(new JLabel("Deck:")); center.add(deck);
-        center.add(new JLabel("Sprite:")); center.add(atlas);
-        center.add(new JLabel("Equipment:")); center.add(equipment);
-        center.add(new JLabel("Colors:")); center.add(colorField);
-        BorderLayout layout=new BorderLayout();
-        setLayout(layout);
-        add(center,BorderLayout.PAGE_START);
-        add(rewards,BorderLayout.CENTER);
-        add(preview,BorderLayout.LINE_START);
+        top.add("Name:",nameField);
+        top.add("Display Name:", nameOverride);
 
-        equipment.getDocument().addDocumentListener(new DocumentChangeListener(() -> EnemyEdit.this.updateEnemy()));
-        atlas.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> EnemyEdit.this.updateEnemy()));
-        colorField.getDocument().addDocumentListener(new DocumentChangeListener(() -> EnemyEdit.this.updateEnemy()));
-        nameField.getDocument().addDocumentListener(new DocumentChangeListener(() -> EnemyEdit.this.updateEnemy()));
-        deck.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> EnemyEdit.this.updateEnemy()));
+        basicInfo.add("Life:",lifeFiled);
+        basicInfo.add("Spawn rate:",spawnRate);
+        basicInfo.add("Difficulty:",difficulty);
+        basicInfo.add("Speed:",speed);
+        basicInfo.add("Deck:",deck);
+        basicInfo.add("Equipment:",equipment);
+        basicInfo.add("Colors:",colorField);
+
+        basicInfo.add("ai:",ai);
+        basicInfo.add("flying:",flying);
+        basicInfo.add("boss:",boss);
+
+        JPanel visual = new JPanel();
+
+        visual.add("Sprite:",atlas);
+        visual.add(preview);
+
+        JPanel tags = new JPanel();
+        existingTags = new JList<>();
+
+
+        existingTags.getInputMap(JList.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
+                KeyStroke.getKeyStroke("ENTER"), "addSelected");
+        existingTags.getActionMap().put("addSelected", new AbstractAction() {
+
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                addSelected();
+
+                int index = existingTags.getSelectedIndex();
+
+                String selectedItem = existingTags.getSelectedValue();
+
+                if (selectedItem != null) {
+                    enemyModel.addElement(selectedItem);
+                    existingTags.grabFocus();
+                    existingTags.setSelectedIndex(index<existingModel.size()?index:index-1);
+
+                }
+            }
+        });
+
+
+
+        existingModel = QuestController.getInstance().getEnemyTags();
+        existingTags.setModel(existingModel);
+
+
+
+
+        enemyTags = new JList<>();
+        enemyModel = new DefaultListModel<>();
+        enemyTags.setModel(enemyModel);
+
+        enemyTags.getModel().addListDataListener(new ListDataListener() {
+                                           @Override
+                                           public void intervalAdded(ListDataEvent e) {
+                                               doUpdate();
+                                           }
+
+                                           @Override
+                                           public void intervalRemoved(ListDataEvent e) {
+                                               doUpdate();
+                                           }
+
+                                           @Override
+                                           public void contentsChanged(ListDataEvent e) {
+                                               doUpdate();
+                                           }
+                                       });
+
+        JButton select = new JButton("Select");
+        select.addActionListener(q -> addSelected());
+        JButton add = new JButton("Manual Add");
+        add.addActionListener(q -> manualAdd(enemyModel));
+        JButton remove = new JButton("Remove Item");
+        remove.addActionListener(q -> removeSelected());
+
+        tags.setLayout(new BorderLayout());
+
+        JPanel left = new JPanel();
+        left.setLayout(new BorderLayout());
+        left.add(new JLabel("Tags already in use"), BorderLayout.NORTH);
+        JScrollPane listScroller = new JScrollPane(existingTags);
+        listScroller.setMinimumSize(new Dimension(400, 800));
+        left.add(listScroller, BorderLayout.CENTER);
+        tags.add(left, BorderLayout.WEST);
+
+        FormPanel tagEdit = new FormPanel();
+        tagEdit.setLayout(new BorderLayout());
+
+        FormPanel mappedTags = new FormPanel();
+        mappedTags.setLayout(new BorderLayout());
+        mappedTags.add(new JLabel("Tags Mapped to this object"), BorderLayout.NORTH);
+        JScrollPane listScroller2 = new JScrollPane(enemyTags);
+        listScroller2.setMinimumSize(new Dimension(400, 800));
+        mappedTags.add(listScroller2, BorderLayout.CENTER);
+        tagEdit.add(mappedTags,BorderLayout.EAST);
+
+        JPanel controlPanel = new JPanel();
+
+        controlPanel.add(select);
+        controlPanel.add(add);
+        controlPanel.add(manualEntry);
+
+        manualEntry.getInputMap(JList.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
+                KeyStroke.getKeyStroke("ENTER"), "addTyped");
+        manualEntry.getActionMap().put("addTyped", new AbstractAction() {
+
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                if (!manualEntry.getText().trim().isEmpty()) {
+                    manualAdd(enemyModel);
+                    manualEntry.grabFocus();
+                }
+            }
+        });
+
+
+        controlPanel.add(remove);
+        tagEdit.add(controlPanel, BorderLayout.CENTER);
+        tags.add(tagEdit,BorderLayout.CENTER);
+
+        JTextArea right1 = new JTextArea("This is really just to pad some space\n" +
+                                        "but also to explain the use of tags.\n" +
+                                        "Rather than adding 100's of object names\n" +
+                                        "to every quest definition, instead we will\n"+
+                                        "categorize enemies and points of interest with\n"+
+                                        "tags and reference those categories in quests");
+        right1.setEnabled(false);
+        tags.add(right1, BorderLayout.EAST);
+        tabs.addTab("Sprite", visual);
+        tabs.addTab("Rewards", rewards);
+        tabs.addTab("Quest Tags", tags);
+
+
+        equipment.getDocument().addDocumentListener(new DocumentChangeListener(EnemyEdit.this::updateEnemy));
+        atlas.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(EnemyEdit.this::updateEnemy));
+        colorField.getDocument().addDocumentListener(new DocumentChangeListener(EnemyEdit.this::updateEnemy));
+        ai.getDocument().addDocumentListener(new DocumentChangeListener(EnemyEdit.this::updateEnemy));
+        flying.addChangeListener(e -> EnemyEdit.this.updateEnemy());
+        boss.addChangeListener(e -> EnemyEdit.this.updateEnemy());
+        ignoreDungeonEffect.addChangeListener(e -> EnemyEdit.this.updateEnemy());
+        nameField.getDocument().addDocumentListener(new DocumentChangeListener(EnemyEdit.this::updateEnemy));
+        nameOverride.getDocument().addDocumentListener(new DocumentChangeListener(EnemyEdit.this::updateEnemy));
+        deck.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(EnemyEdit.this::updateEnemy));
         lifeFiled.addChangeListener(e -> EnemyEdit.this.updateEnemy());
         speed.addChangeListener(e -> EnemyEdit.this.updateEnemy());
         difficulty.addChangeListener(e -> EnemyEdit.this.updateEnemy());
         spawnRate.addChangeListener(e -> EnemyEdit.this.updateEnemy());
         rewards.addChangeListener(e -> EnemyEdit.this.updateEnemy());
         lifeFiled.addChangeListener(e -> EnemyEdit.this.updateEnemy());
+        enemyModel.addListDataListener(new ListDataListener() {
+            @Override
+            public void intervalAdded(ListDataEvent e) {
+                EnemyEdit.this.updateEnemy();
+            }
+
+            @Override
+            public void intervalRemoved(ListDataEvent e) {
+                EnemyEdit.this.updateEnemy();
+            }
+
+            @Override
+            public void contentsChanged(ListDataEvent e) {
+                EnemyEdit.this.updateEnemy();
+            }
+        });
         refresh();
     }
 
-    private void updateEnemy() {
+
+    private void doUpdate(){
+        EnemyEdit.this.updateEnemy();
+    }
+
+    private void addSelected(){
+        if (existingTags.getSelectedIndex()>-1)
+            enemyModel.addElement(existingTags.getModel().getElementAt(existingTags.getSelectedIndex()));
+        doUpdate();
+    }
+
+    private void removeSelected(){
+        if (enemyTags.getSelectedIndex()>-1)
+            enemyModel.remove(enemyTags.getSelectedIndex());
+        doUpdate();
+    }
+
+    private void filterExisting(DefaultListModel<String> filter){
+        DefaultListModel<String> toReturn = new DefaultListModel<>();
+        for (Enumeration<String> e = QuestController.getInstance().getEnemyTags().elements(); e.hasMoreElements();){
+            String toTest = e.nextElement();
+            if (toTest != null & !filter.contains(toTest)){
+                toReturn.addElement(toTest);
+            }
+        }
+        existingTags.setModel(toReturn);
+    }
+
+    private void manualAdd(DefaultListModel<String> model){
+        if (!manualEntry.getText().trim().isEmpty())
+            model.addElement(manualEntry.getText().trim());
+        manualEntry.setText("");
+        doUpdate();
+    }
+
+    public void updateEnemy() {
         if(currentData==null||updating)
             return;
         currentData.name=nameField.getText();
         currentData.colors=colorField.getText();
+        currentData.ai=ai.getText();
+        currentData.flying=flying.isSelected();
+        currentData.boss=boss.isSelected();
         currentData.life= (int) lifeFiled.getValue();
         currentData.sprite= atlas.getEdit().getText();
         if(equipment.getText().isEmpty())
@@ -74,9 +276,18 @@ public class EnemyEdit extends JComponent {
         currentData.speed=  ((Double)  speed.getValue()).floatValue();
         currentData.spawnRate=((Double)  spawnRate.getValue()).floatValue();
         currentData.difficulty=((Double)  difficulty.getValue()).floatValue();
-        currentData.deck= deck.getEdit().getText();
+        currentData.deck= deck.getEdit().getText().split(",");
         currentData.rewards= rewards.getRewards();
         preview.setSpritePath(currentData.sprite);
+
+        ArrayList<String> tags = new ArrayList<>();
+        for (Enumeration<String> e = enemyModel.elements(); e.hasMoreElements();){
+            tags.add(e.nextElement());
+        }
+
+        currentData.questTags = tags.toArray(currentData.questTags);
+        QuestController.getInstance().refresh();
+        filterExisting(enemyModel);
     }
 
     public void setCurrentEnemy(EnemyData data)
@@ -94,18 +305,27 @@ public class EnemyEdit extends JComponent {
         updating=true;
         nameField.setText(currentData.name);
         colorField.setText(currentData.colors);
+        ai.setText(currentData.ai);
+        boss.setSelected(currentData.boss);
+        flying.setSelected(currentData.flying);
         lifeFiled.setValue(currentData.life);
         atlas.getEdit().setText(currentData.sprite);
         if(currentData.equipment!=null)
             equipment.setText(String.join(",",currentData.equipment));
         else
             equipment.setText("");
-        deck.getEdit().setText(currentData.deck);
+        deck.getEdit().setText(String.join(",",currentData.deck));
         speed.setValue(new Float(currentData.speed).doubleValue());
         spawnRate.setValue(new Float(currentData.spawnRate).doubleValue());
         difficulty.setValue(new Float(currentData.difficulty).doubleValue());
         rewards.setRewards(currentData.rewards);
         preview.setSpritePath(currentData.sprite);
+        enemyModel.clear();
+        for(String val : currentData.questTags) {
+            if (val != null)
+                enemyModel.addElement(val);
+        }
+        filterExisting(enemyModel);
         updating=false;
     }
 }

forge-adventure/src/main/java/forge/adventure/editor/EnemyEditor.java

@@ -9,10 +9,7 @@ import forge.adventure.util.Config;
 import forge.adventure.util.Paths;
 
 import javax.swing.*;
-import javax.swing.event.ListSelectionEvent;
-import javax.swing.event.ListSelectionListener;
 import java.awt.*;
-import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
 /**
@@ -61,45 +58,19 @@ public class EnemyEditor extends JComponent {
     {
 
         list.setCellRenderer(new EnemyDataRenderer());
-        list.addListSelectionListener(new ListSelectionListener() {
-            @Override
-            public void valueChanged(ListSelectionEvent e) {
-                EnemyEditor.this.updateEdit();
-            }
-        });
-        addButton("add", new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                EnemyEditor.this.addEnemy();
-            }
-        });
-        addButton("remove", new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                EnemyEditor.this.remove();
-            }
-        });
-        addButton("copy", new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                EnemyEditor.this.copy();
-            }
-        });
-        addButton("load", new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                EnemyEditor.this.load();
-            }
-        });
-        addButton("save", new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                EnemyEditor.this.save();
-            }
+        list.addListSelectionListener(e -> EnemyEditor.this.updateEdit());
+        addButton("add", e -> EnemyEditor.this.addEnemy());
+        addButton("remove", e -> EnemyEditor.this.remove());
+        addButton("copy", e -> EnemyEditor.this.copy());
+        addButton("load", e -> {
+            EnemyEditor.this.load();
+            QuestController.getInstance().load();
         });
+        addButton("save", e -> EnemyEditor.this.save());
         BorderLayout layout=new BorderLayout();
         setLayout(layout);
         add(new JScrollPane(list), BorderLayout.LINE_START);
+        toolBar.setFloatable(false);
         add(toolBar, BorderLayout.PAGE_START);
         add(edit,BorderLayout.CENTER);
         load();
@@ -118,6 +89,7 @@ public class EnemyEditor extends JComponent {
         if(selected<0)
             return;
         edit.setCurrentEnemy(model.get(selected));
+        edit.updateEnemy();
     }
 
     void save()
@@ -138,8 +110,7 @@ public class EnemyEditor extends JComponent {
         FileHandle handle = Config.instance().getFile(Paths.ENEMIES);
         if (handle.exists())
         {
-            Array readEnemies=json.fromJson(Array.class, EnemyData.class, handle);
-            allEnemies = readEnemies;
+            allEnemies = json.fromJson(Array.class, EnemyData.class, handle);
         }
         for (int i=0;i<allEnemies.size;i++) {
             model.add(i,allEnemies.get(i));

forge-adventure/src/main/java/forge/adventure/editor/FloatSpinner.java

@@ -0,0 +1,19 @@
+package forge.adventure.editor;
+
+import javax.swing.*;
+
+public class FloatSpinner extends JSpinner{
+
+    public FloatSpinner()
+    {
+        this( 0.f, 1f, 0.1f);
+    }
+    public FloatSpinner(float min,float max,float stepSize)
+    {
+        super(new SpinnerNumberModel(new Float(0.0f), new Float(min), new Float (max), new Float(stepSize)));
+    }
+    public float floatValue()
+    {
+        return ((Float)getValue()).floatValue();
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/FormPanel.java

@@ -0,0 +1,63 @@
+package forge.adventure.editor;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class FormPanel extends JPanel {
+    int row=0;
+    static final int MAXIMUM_LINES=300;
+    public FormPanel()
+    {
+        setLayout(new GridBagLayout()) ;
+
+
+        GridBagConstraints constraint=new GridBagConstraints();
+        constraint.weightx = 1.0;
+        constraint.weighty = 1.0;
+        constraint.gridy=MAXIMUM_LINES;
+        constraint.gridx=0;
+        constraint.gridwidth=2;
+        add(Box.createVerticalGlue(),constraint);
+        row++;
+    }
+    public void add(JComponent name,JComponent element)
+    {
+        GridBagConstraints constraint=new GridBagConstraints();
+        constraint.ipadx = 5;
+        constraint.ipady = 5;
+        constraint.weightx = 1.0;
+        constraint.weighty = 0.0;
+        constraint.gridy=row;
+        constraint.gridx=0;
+        constraint.anchor=GridBagConstraints.NORTHWEST;
+        add(name,constraint);
+        constraint.gridy=row;
+        constraint.gridx=1;
+        constraint.fill=GridBagConstraints.HORIZONTAL;
+        constraint.anchor=GridBagConstraints.NORTHEAST;
+        add(element,constraint);
+
+        row++;
+    }
+    public void add(String name,JComponent element)
+    {
+        add(new JLabel(name),element);
+    }
+    public void add(JComponent element)
+    {
+        GridBagConstraints constraint=new GridBagConstraints();
+        constraint.ipadx = 5;
+        constraint.ipady = 5;
+        constraint.weightx = 1.0;
+        constraint.weighty = 0.0;
+        constraint.gridy=row;
+        constraint.gridx=0;
+        constraint.gridwidth=2;
+        constraint.fill=GridBagConstraints.HORIZONTAL;
+        constraint.anchor=GridBagConstraints.NORTHEAST;
+        add(element,constraint);
+
+        row++;
+    }
+
+}

forge-adventure/src/main/java/forge/adventure/editor/IntSpinner.java

@@ -0,0 +1,20 @@
+package forge.adventure.editor;
+
+import javax.swing.*;
+
+
+public class IntSpinner extends JSpinner {
+
+    public IntSpinner()
+    {
+        this( 0, 100, 1);
+    }
+    public IntSpinner(int min,int max,int stepSize)
+    {
+        super(new SpinnerNumberModel(new Integer(0), new Integer(min), new Integer (max), new Integer(stepSize)));
+    }
+    public int intValue()
+    {
+        return ((Integer)getValue()).intValue();
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/ItemEdit.java

@@ -10,8 +10,6 @@ import java.awt.*;
  */
 public class ItemEdit extends JComponent {
     ItemData currentData;
-
-
     JTextField nameField=new JTextField();
     JTextField equipmentSlot=new JTextField();
     JTextField iconName=new JTextField();
@@ -26,19 +24,19 @@ public class ItemEdit extends JComponent {
     {
 
         setLayout(new BoxLayout(this,BoxLayout.Y_AXIS));
-        JPanel parameters=new JPanel();
+        FormPanel parameters=new FormPanel();
         parameters.setBorder(BorderFactory.createTitledBorder("Parameter"));
-        parameters.setLayout(new GridLayout(6,2)) ;
 
-        parameters.add(new JLabel("Name:")); parameters.add(nameField);
-        parameters.add(new JLabel("equipmentSlot:")); parameters.add(equipmentSlot);
-        parameters.add(new JLabel("description:")); parameters.add(description);
-        parameters.add(new JLabel("iconName")); parameters.add(iconName);
-        parameters.add(new JLabel("questItem")); parameters.add(questItem);
-        parameters.add(new JLabel("cost")); parameters.add(cost);
+        parameters.add("Name:",nameField);
+        parameters.add("equipmentSlot:",equipmentSlot);
+        parameters.add("description:",description);
+        parameters.add("iconName",iconName);
+        parameters.add("questItem",questItem);
+        parameters.add("cost",cost);
 
         add(parameters);
         add(effect);
+        add(new Box.Filler(new Dimension(0,0),new Dimension(0,Integer.MAX_VALUE),new Dimension(0,Integer.MAX_VALUE)));
 
         nameField.getDocument().addDocumentListener(new DocumentChangeListener(() -> ItemEdit.this.updateItem()));
         equipmentSlot.getDocument().addDocumentListener(new DocumentChangeListener(() -> ItemEdit.this.updateItem()));

forge-adventure/src/main/java/forge/adventure/editor/ItemsEditor.java

@@ -67,6 +67,7 @@ public class ItemsEditor extends JComponent {
         BorderLayout layout=new BorderLayout();
         setLayout(layout);
         add(new JScrollPane(list), BorderLayout.LINE_START);
+        toolBar.setFloatable(false);
         add(toolBar, BorderLayout.PAGE_START);
         add(edit,BorderLayout.CENTER);
         load();
@@ -105,8 +106,7 @@ public class ItemsEditor extends JComponent {
         FileHandle handle = Config.instance().getFile(Paths.ITEMS);
         if (handle.exists())
         {
-            Array readEnemies=json.fromJson(Array.class, ItemData.class, handle);
-            allEnemies = readEnemies;
+            allEnemies =json.fromJson(Array.class, ItemData.class, handle);
         }
         for (int i=0;i<allEnemies.size;i++) {
             model.add(i,allEnemies.get(i));

forge-adventure/src/main/java/forge/adventure/editor/Main.java

@@ -1,20 +0,0 @@
-package forge.adventure.editor;
-
-import forge.GuiMobile;
-import forge.adventure.util.Config;
-import forge.gui.GuiBase;
-
-import java.nio.file.Files;
-import java.nio.file.Paths;
-
-/**
- * Editor class to edit configuration, maybe moved or removed
- */
-public class Main {
-    public static void main(String[] args) {
-        GuiBase.setInterface(new GuiMobile(Files.exists(Paths.get("./res"))?"./":"../forge-gui/"));
-        GuiBase.setDeviceInfo("", "", 0, 0);
-        Config.instance();
-         new EditorMainWindow();
-    }
-}

forge-adventure/src/main/java/forge/adventure/editor/PointOfInterestEdit.java

@@ -0,0 +1,274 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.PointOfInterestData;
+
+import javax.swing.*;
+import javax.swing.event.ListDataEvent;
+import javax.swing.event.ListDataListener;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.util.ArrayList;
+import java.util.Enumeration;
+
+public class PointOfInterestEdit extends JComponent {
+
+    PointOfInterestData currentData;
+
+
+    JTextField  name        = new JTextField();
+    JTextField  type        = new JTextField();
+    JSpinner    count       = new JSpinner(new SpinnerNumberModel(0, 0, 1000, 1));
+    FilePicker  spriteAtlas = new FilePicker(new String[]{"atlas"});
+    JTextField  sprite      = new JTextField();
+    FilePicker  map         = new FilePicker(new String[]{"tmx"});
+    JSpinner    radiusFactor= new JSpinner(new SpinnerNumberModel(0.0f, 0.0f, 2.0f, 0.1f));
+    SwingAtlasPreview preview=new SwingAtlasPreview(256,2000);
+
+    JTextField manualEntry = new JTextField(20);
+    DefaultListModel<String> existingModel = new DefaultListModel<>();
+    DefaultListModel<String> POIModel = new DefaultListModel<>();
+    JList<String> existingTags;
+    JList<String> POITags;
+
+    private boolean updating=false;
+
+    public PointOfInterestEdit()
+    {
+        JTabbedPane tabs = new JTabbedPane();
+        add(tabs, BorderLayout.CENTER);
+
+        setLayout(new BoxLayout(this,BoxLayout.Y_AXIS));
+        FormPanel parameters=new FormPanel();
+        //parameters.setLayout(new BoxLayout(parameters, BoxLayout.Y_AXIS));
+        parameters.setBorder(BorderFactory.createTitledBorder("Parameter"));
+
+        JPanel tags = new JPanel();
+
+        tabs.addTab("Basic Info", parameters);
+        tabs.addTab("Quest Tags", tags);
+
+        parameters.add("Name:",name);
+        parameters.add("Type:",type);
+        parameters.add("Count:",count);
+        parameters.add("Sprite atlas:",spriteAtlas);
+        parameters.add("Sprite:",sprite);
+        parameters.add("Map:",map);
+        parameters.add("Radius factor:",radiusFactor);
+        parameters.add(preview);
+
+        name.getDocument().addDocumentListener(new DocumentChangeListener(PointOfInterestEdit.this::updateItem));
+        type.getDocument().addDocumentListener(new DocumentChangeListener(PointOfInterestEdit.this::updateItem));
+        count.addChangeListener(e -> PointOfInterestEdit.this.updateItem());
+        spriteAtlas.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(PointOfInterestEdit.this::updateItem));
+        sprite.getDocument().addDocumentListener(new DocumentChangeListener(PointOfInterestEdit.this::updateItem));
+        map.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(PointOfInterestEdit.this::updateItem));
+        radiusFactor.addChangeListener(e -> PointOfInterestEdit.this.updateItem());
+
+
+
+        existingTags = new JList<>();
+
+
+        existingTags.getInputMap(JList.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
+                KeyStroke.getKeyStroke("ENTER"), "addSelected");
+        existingTags.getActionMap().put("addSelected", new AbstractAction() {
+
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                int index = existingTags.getSelectedIndex();
+
+                String selectedItem = existingTags.getSelectedValue();
+
+                if (selectedItem != null) {
+                    POIModel.addElement(selectedItem);
+                    existingTags.grabFocus();
+                    existingTags.setSelectedIndex(index<existingModel.size()?index:index-1);
+
+                }
+            }
+        });
+
+
+
+        existingModel = QuestController.getInstance().getPOITags();
+        existingTags.setModel(existingModel);
+
+
+
+
+        POITags = new JList<>();
+        POIModel = new DefaultListModel<>();
+        POITags.setModel(POIModel);
+
+        POITags.getModel().addListDataListener(new ListDataListener() {
+            @Override
+            public void intervalAdded(ListDataEvent e) {
+                updateItem();
+            }
+
+            @Override
+            public void intervalRemoved(ListDataEvent e) {
+                updateItem();
+            }
+
+            @Override
+            public void contentsChanged(ListDataEvent e) {
+                updateItem();
+            }
+        });
+
+        JButton select = new JButton("Select");
+        select.addActionListener(q -> addSelected());
+        JButton add = new JButton("Manual Add");
+        add.addActionListener(q -> manualAdd(POIModel));
+        JButton remove = new JButton("Remove Item");
+        remove.addActionListener(q -> removeSelected());
+
+        tags.setLayout(new BorderLayout());
+
+        JPanel left = new JPanel();
+        left.setLayout(new BorderLayout());
+        left.add(new JLabel("Tags already in use"), BorderLayout.NORTH);
+        JScrollPane listScroller = new JScrollPane(existingTags);
+        listScroller.setMinimumSize(new Dimension(400, 800));
+        left.add(listScroller, BorderLayout.CENTER);
+        tags.add(left, BorderLayout.WEST);
+
+        FormPanel tagEdit = new FormPanel();
+        tagEdit.setLayout(new BorderLayout());
+
+        FormPanel mappedTags = new FormPanel();
+        mappedTags.setLayout(new BorderLayout());
+        mappedTags.add(new JLabel("Tags Mapped to this object"), BorderLayout.NORTH);
+        JScrollPane listScroller2 = new JScrollPane(POITags);
+        listScroller2.setMinimumSize(new Dimension(400, 800));
+        mappedTags.add(listScroller2, BorderLayout.CENTER);
+        tagEdit.add(mappedTags,BorderLayout.EAST);
+
+        JPanel controlPanel = new JPanel();
+
+        controlPanel.add(select);
+        controlPanel.add(add);
+        controlPanel.add(manualEntry);
+
+        manualEntry.getInputMap(JList.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
+                KeyStroke.getKeyStroke("ENTER"), "addTyped");
+        manualEntry.getActionMap().put("addTyped", new AbstractAction() {
+
+            @Override
+            public void actionPerformed(ActionEvent e) {
+
+                if (!manualEntry.getText().trim().isEmpty()) {
+                    manualAdd(POIModel);
+                    manualEntry.grabFocus();
+                }
+            }
+        });
+
+
+        controlPanel.add(remove);
+        tagEdit.add(controlPanel, BorderLayout.CENTER);
+        tags.add(tagEdit,BorderLayout.CENTER);
+
+        JTextArea right1 = new JTextArea("This is really just to pad some space\n" +
+                "but also to explain the use of tags.\n" +
+                "Rather than adding 100's of object names\n" +
+                "to every quest definition, instead we will\n"+
+                "categorize enemies and points of interest with\n"+
+                "tags and reference those categories in quests");
+        right1.setEnabled(false);
+        tags.add(right1, BorderLayout.EAST);
+
+
+
+
+
+
+
+
+
+        refresh();
+    }
+
+    private void updateItem() {
+        if(currentData==null||updating)
+            return;
+        currentData.name=name.getText();
+        currentData.type=  type.getText();
+        currentData.count= (Integer) count.getValue();
+        currentData.spriteAtlas=spriteAtlas.getEdit().getText();
+        currentData.sprite=sprite.getText();
+        currentData.map=map.getEdit().getText();
+        currentData.radiusFactor= (Float) radiusFactor.getValue();
+
+        ArrayList<String> tags = new ArrayList<>();
+        for (Enumeration<String> e = POIModel.elements(); e.hasMoreElements();){
+            tags.add(e.nextElement());
+        }
+
+        currentData.questTags = tags.toArray(currentData.questTags);
+        QuestController.getInstance().refresh();
+        filterExisting(POIModel);
+    }
+
+    public void setCurrent(PointOfInterestData data)
+    {
+        currentData=data;
+        refresh();
+    }
+
+    private void addSelected(){
+        if (existingTags.getSelectedIndex()>-1)
+            POIModel.addElement(existingTags.getModel().getElementAt(existingTags.getSelectedIndex()));
+        updateItem();
+    }
+
+    private void removeSelected(){
+        if (POITags.getSelectedIndex()>-1)
+            POIModel.remove(POITags.getSelectedIndex());
+        updateItem();
+    }
+
+    private void filterExisting(DefaultListModel<String> filter){
+        DefaultListModel<String> toReturn = new DefaultListModel<>();
+        for (Enumeration<String> e = QuestController.getInstance().getPOITags().elements(); e.hasMoreElements();){
+            String toTest = e.nextElement();
+            if (toTest != null & !filter.contains(toTest)){
+                toReturn.addElement(toTest);
+            }
+        }
+        existingTags.setModel(toReturn);
+    }
+
+    private void manualAdd(DefaultListModel<String> model){
+        if (!manualEntry.getText().trim().isEmpty())
+            model.addElement(manualEntry.getText().trim());
+        manualEntry.setText("");
+        updateItem();
+    }
+
+    private void refresh() {
+        setEnabled(currentData!=null);
+        if(currentData==null)
+        {
+            return;
+        }
+        updating=true;
+        name.setText(currentData.name);
+        type.setText(currentData.type);
+        count.setValue(currentData.count);
+        spriteAtlas.getEdit().setText(currentData.spriteAtlas);
+        sprite.setText(currentData.sprite);
+        map.getEdit().setText(currentData.map);
+        radiusFactor.setValue(currentData.radiusFactor);
+
+        preview.setSpritePath(currentData.spriteAtlas,currentData.sprite);
+        POIModel.clear();
+        for(String val : currentData.questTags) {
+            if (val != null)
+                POIModel.addElement(val);
+        }
+        filterExisting(POIModel);
+        updating=false;
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/PointOfInterestEditor.java

@@ -1,6 +1,134 @@
 package forge.adventure.editor;
 
-import java.awt.*;
+import com.badlogic.gdx.files.FileHandle;
+import com.badlogic.gdx.utils.Array;
+import com.badlogic.gdx.utils.Json;
+import com.badlogic.gdx.utils.JsonWriter;
+import forge.adventure.data.PointOfInterestData;
+import forge.adventure.util.Config;
+import forge.adventure.util.Paths;
 
-public class PointOfInterestEditor extends Component {
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionListener;
+import java.util.HashMap;
+
+public class PointOfInterestEditor extends JComponent {
+    DefaultListModel<PointOfInterestData> model = new DefaultListModel<>();
+    JList<PointOfInterestData> list = new JList<>(model);
+    JToolBar toolBar = new JToolBar("toolbar");
+    PointOfInterestEdit edit=new PointOfInterestEdit();
+
+    static HashMap<String,SwingAtlas> atlas=new HashMap<>();
+
+
+
+    public static class PointOfInterestRenderer extends DefaultListCellRenderer {
+        @Override
+        public Component getListCellRendererComponent(
+                JList list, Object value, int index,
+                boolean isSelected, boolean cellHasFocus) {
+            JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+            if(!(value instanceof PointOfInterestData))
+                return label;
+            PointOfInterestData poi=(PointOfInterestData) value;
+            // Get the renderer component from parent class
+
+            label.setText(poi.name);
+            if(!atlas.containsKey(poi.spriteAtlas))
+                atlas.put(poi.spriteAtlas,new SwingAtlas(Config.instance().getFile(poi.spriteAtlas)));
+
+            SwingAtlas poiAtlas = atlas.get(poi.spriteAtlas);
+
+            if(poiAtlas.has(poi.sprite))
+                label.setIcon(poiAtlas.get(poi.sprite));
+            else
+            {
+                ImageIcon img=poiAtlas.getAny();
+                if(img!=null)
+                    label.setIcon(img);
+            }
+            return label;
+        }
+    }
+    public void addButton(String name, ActionListener action)
+    {
+        JButton newButton=new JButton(name);
+        newButton.addActionListener(action);
+        toolBar.add(newButton);
+
+    }
+    public PointOfInterestEditor()
+    {
+
+        list.setCellRenderer(new PointOfInterestEditor.PointOfInterestRenderer());
+        list.addListSelectionListener(e -> PointOfInterestEditor.this.updateEdit());
+        addButton("add", e -> PointOfInterestEditor.this.addItem());
+        addButton("remove", e -> PointOfInterestEditor.this.remove());
+        addButton("copy", e -> PointOfInterestEditor.this.copy());
+        addButton("load", e -> PointOfInterestEditor.this.load());
+        addButton("save", e -> PointOfInterestEditor.this.save());
+        BorderLayout layout=new BorderLayout();
+        setLayout(layout);
+        add(new JScrollPane(list), BorderLayout.LINE_START);
+        toolBar.setFloatable(false);
+        add(toolBar, BorderLayout.PAGE_START);
+        add(edit,BorderLayout.CENTER);
+        load();
+    }
+    private void copy() {
+
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        PointOfInterestData data=new PointOfInterestData(model.get(selected));
+        model.add(model.size(),data);
+    }
+    private void updateEdit() {
+
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        edit.setCurrent(model.get(selected));
+    }
+
+    void save()
+    {
+        Array<PointOfInterestData> allEnemies=new Array<>();
+        for(int i=0;i<model.getSize();i++)
+            allEnemies.add(model.get(i));
+        Json json = new Json(JsonWriter.OutputType.json);
+        FileHandle handle = Config.instance().getFile(Paths.POINTS_OF_INTEREST);
+        handle.writeString(json.prettyPrint(json.toJson(allEnemies,Array.class, PointOfInterestData.class)),false);
+
+    }
+    void load()
+    {
+        model.clear();
+        Array<PointOfInterestData> allEnemies=new Array<>();
+        Json json = new Json();
+        FileHandle handle = Config.instance().getFile(Paths.POINTS_OF_INTEREST);
+        if (handle.exists())
+        {
+            allEnemies =json.fromJson(Array.class, PointOfInterestData.class, handle);
+        }
+        for (int i=0;i<allEnemies.size;i++) {
+            model.add(i,allEnemies.get(i));
+        }
+
+        QuestController.getInstance().load();
+    }
+    void addItem()
+    {
+        PointOfInterestData data=new PointOfInterestData();
+        data.name="PoI "+model.getSize();
+        model.add(model.size(),data);
+    }
+    void remove()
+    {
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        model.remove(selected);
+    }
 }

forge-adventure/src/main/java/forge/adventure/editor/QuestController.java

@@ -0,0 +1,236 @@
+package forge.adventure.editor;
+
+import com.badlogic.gdx.files.FileHandle;
+import com.badlogic.gdx.utils.Array;
+import com.badlogic.gdx.utils.Json;
+import com.badlogic.gdx.utils.JsonWriter;
+import forge.adventure.data.AdventureQuestData;
+import forge.adventure.data.EnemyData;
+import forge.adventure.data.PointOfInterestData;
+import forge.adventure.util.Config;
+import forge.adventure.util.Paths;
+
+import javax.swing.*;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class QuestController {
+
+    public final DefaultListModel<String> POITags = new DefaultListModel<>();
+    public final DefaultListModel<String> enemyTags = new DefaultListModel<>();
+    public final DefaultListModel<String> questEnemyTags = new DefaultListModel<>();
+    public final DefaultListModel<String> questTags = new DefaultListModel<>();
+    public final DefaultListModel<String> questPOITags = new DefaultListModel<>();
+    private final DefaultListModel<PointOfInterestData> allPOI = new DefaultListModel<>();
+    private final DefaultListModel<EnemyData> allEnemies = new DefaultListModel<>();
+    private final DefaultListModel<String> questSourceTags = new DefaultListModel<>();
+
+    private final DefaultListModel<AdventureQuestData> allQuests = new DefaultListModel<>();
+
+    private static QuestController instance;
+
+    public static QuestController getInstance() {
+        if (instance == null)
+            instance = new QuestController();
+        return instance;
+    }
+
+    public DefaultListModel<AdventureQuestData> getAllQuests() {
+            return allQuests;
+    }
+
+    private QuestController(){
+        load();
+    }
+
+    public DefaultListModel<String> getEnemyTags(){
+        DefaultListModel<String> toReturn = new DefaultListModel<>();
+        for (int i = 0; i < enemyTags.size(); i++){
+            toReturn.removeElement(enemyTags.get(i));
+            toReturn.addElement(enemyTags.get(i));
+        }
+
+        List<Object> sortedObjects = Arrays.stream(toReturn.toArray()).sorted().collect(Collectors.toList());
+
+        toReturn.clear();
+
+        for (Object sortedObject : sortedObjects) {
+            toReturn.addElement((String) sortedObject);
+        }
+
+        return toReturn;
+    }
+
+    public DefaultListModel<String> getPOITags(){
+        DefaultListModel<String> toReturn = new DefaultListModel<>();
+        for (int i = 0; i < POITags.size(); i++){
+            toReturn.removeElement(POITags.get(i));
+            toReturn.addElement(POITags.get(i));
+        }
+
+        List<Object> sortedObjects = Arrays.stream(toReturn.toArray()).sorted().collect(Collectors.toList());
+
+        toReturn.clear();
+
+        for (Object sortedObject : sortedObjects) {
+            toReturn.addElement((String) sortedObject);
+        }
+
+        return toReturn;
+    }
+
+    public DefaultListModel<String> getSourceTags(){
+        DefaultListModel<String> toReturn = new DefaultListModel<>();
+
+        for (int i = 0; i < questSourceTags.size(); i++)
+        {
+            toReturn.removeElement(questSourceTags.get(i));
+            toReturn.addElement(questSourceTags.get(i));
+        }
+
+        List<Object> sortedObjects = Arrays.stream(toReturn.toArray()).sorted().collect(Collectors.toList());
+
+        toReturn.clear();
+
+        for (Object sortedObject : sortedObjects) {
+            toReturn.addElement((String) sortedObject);
+        }
+
+        return toReturn;
+    }
+
+    public void refresh(){
+        enemyTags.clear();
+        POITags.clear();
+        questPOITags.clear();
+        questEnemyTags.clear();
+        questTags.clear();
+        questSourceTags.clear();
+
+        for (int i=0;i<allEnemies.size();i++) {
+            for (String tag : allEnemies.get(i).questTags)
+            {
+                enemyTags.removeElement(tag); //Ensure uniqueness
+                if (tag!= null)
+                    enemyTags.addElement(tag);
+            }
+        }
+
+        for (int i=0;i<allPOI.size();i++) {
+            for (String tag : allPOI.get(i).questTags)
+            {
+                POITags.removeElement(tag); //Ensure uniqueness
+                if (tag!= null)
+                    POITags.addElement(tag);
+            }
+        }
+
+        for (int i=0;i<allQuests.size();i++) {
+
+            for (String tag : allQuests.get(i).questEnemyTags)
+            {
+                questEnemyTags.removeElement(tag); //Ensure uniqueness
+                if (tag!= null)
+                    questEnemyTags.addElement(tag);
+            }
+            for (String tag : allQuests.get(i).questPOITags)
+            {
+                questPOITags.removeElement(tag); //Ensure uniqueness
+                if (tag!= null)
+                    questPOITags.addElement(tag);
+            }
+
+            for (String tag : allQuests.get(i).questSourceTags)
+            {
+                questSourceTags.removeElement(tag); //Ensure uniqueness
+                if (tag!= null)
+                    questSourceTags.addElement(tag);
+            }
+
+        }
+    }
+
+    public void load()
+    {
+        allEnemies.clear();
+        Array<EnemyData> enemyJSON=new Array<>();
+        Json json = new Json();
+        FileHandle handle = Config.instance().getFile(Paths.ENEMIES);
+        if (handle.exists())
+        {
+            enemyJSON = json.fromJson(Array.class, EnemyData.class, handle);
+        }
+        for (int i=0;i<enemyJSON.size;i++) {
+            allEnemies.add(i,enemyJSON.get(i));
+            for (String tag : enemyJSON.get(i).questTags)
+            {
+                enemyTags.removeElement(tag); //Ensure uniqueness
+                if (tag!= null)
+                    enemyTags.addElement(tag);
+            }
+        }
+
+        allPOI.clear();
+        Array<PointOfInterestData> POIJSON=new Array<>();
+        json = new Json();
+        handle = Config.instance().getFile(Paths.POINTS_OF_INTEREST);
+        if (handle.exists())
+        {
+            POIJSON = json.fromJson(Array.class, PointOfInterestData.class, handle);
+        }
+        for (int i=0;i<POIJSON.size;i++) {
+            allPOI.add(i,POIJSON.get(i));
+            for (String tag : POIJSON.get(i).questTags)
+            {
+                POITags.removeElement(tag); //Ensure uniqueness
+                if (tag!= null)
+                    POITags.addElement(tag);
+            }
+        }
+
+        allQuests.clear();
+        Array<AdventureQuestData> questJSON=new Array<>();
+        json = new Json();
+        handle = Config.instance().getFile(Paths.QUESTS);
+        if (handle.exists())
+        {
+            questJSON = json.fromJson(Array.class, AdventureQuestData.class, handle);
+        }
+        for (int i=0;i<questJSON.size;i++) {
+            AdventureQuestData template = questJSON.get(i);
+            template.isTemplate = true;
+
+            allQuests.add(i,template);
+
+            for (String tag : template.questEnemyTags)
+            {
+                questEnemyTags.removeElement(tag); //Ensure uniqueness
+                if (tag!= null)
+                    questEnemyTags.addElement(tag);
+            }
+            for (String tag : template.questPOITags)
+            {
+                questPOITags.removeElement(tag); //Ensure uniqueness
+                if (tag!= null)
+                    questPOITags.addElement(tag);
+            }
+            for (String tag : template.questSourceTags)
+            {
+                questSourceTags.removeElement(tag); //Ensure uniqueness
+                if (tag!= null)
+                    questSourceTags.addElement(tag);
+            }
+        }
+    }
+
+    void save()
+    {
+        Json json = new Json(JsonWriter.OutputType.json);
+        FileHandle handle = Config.instance().getFile(Paths.QUESTS);
+        AdventureQuestData[] saveData = Arrays.stream(allQuests.toArray()).map(AdventureQuestData.class::cast).toArray(AdventureQuestData[]::new);
+
+        handle.writeString(json.prettyPrint(json.toJson(saveData,Array.class, AdventureQuestData.class)),false);
+
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/QuestEdit.java

@@ -0,0 +1,374 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.AdventureQuestData;
+
+import javax.swing.*;
+import javax.swing.event.ListDataEvent;
+import javax.swing.event.ListDataListener;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.util.ArrayList;
+import java.util.Enumeration;
+
+public class QuestEdit extends FormPanel {
+    AdventureQuestData currentData;
+    //public JSpinner spawnWeight= new JSpinner(new SpinnerNumberModel(0.0f, 0.f, 1f, 0.1f));
+    public JLabel id = new JLabel();
+    public JTextField name=new JTextField();
+    public JTextField description=new JTextField();
+    public JTextField synopsis=new JTextField();
+    public JCheckBox storyQuest = new JCheckBox();
+    public JTextField rewardDescription=new JTextField();
+    public QuestStageEditor stages =new QuestStageEditor();
+
+
+    JTabbedPane tabs =new JTabbedPane();
+    public DialogEditor prologueEditor =new DialogEditor();
+    public DialogEditor epilogueEditor =new DialogEditor();
+    public DialogEditor offerEditor = new DialogEditor();
+    public DialogEditor failureEditor = new DialogEditor();
+    public DialogEditor declineEditor = new DialogEditor();
+    private boolean updating=false;
+
+    JTextField manualEntry = new JTextField(20);
+    DefaultListModel<String> existingModel = new DefaultListModel<>();
+    DefaultListModel<String> selectedTagModel = new DefaultListModel<>();
+    JList<String> existingTags;
+    JList<String> selectedTags;
+    JPanel tags = new JPanel();
+
+    public QuestEdit()
+    {
+
+        FormPanel center=new FormPanel() {  };
+
+        center.add("Quest ID:", id);
+        center.add("Name:",name);
+        //center.add("Synopsis (dev mode):",synopsis);
+        center.add("Description:",description);
+        center.add("Reward Description:",rewardDescription);
+        center.add("Storyline Quest", storyQuest);
+
+        add(center);
+
+        setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
+        add(tabs);
+        tabs.add("Quest Stages", getStagesTab());
+        tabs.add("Offer Dialog",getOfferTab());
+        tabs.add("Prologue",getPrologueTab());
+        tabs.add("Epilogue",getEpilogueTab());
+        tabs.add("Failure Dialog", getFailureTab());
+        tabs.add("Decline Dialog",getDeclineTab());
+        tabs.add("Quest Sources", getSourcesTab());
+
+
+
+        existingTags = new JList<>();
+
+
+        existingTags.getInputMap(JList.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
+                KeyStroke.getKeyStroke("ENTER"), "addSelected");
+        existingTags.getActionMap().put("addSelected", new AbstractAction() {
+
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                addSelected();
+
+                int index = existingTags.getSelectedIndex();
+
+                String selectedItem = existingTags.getSelectedValue();
+
+                if (selectedItem != null) {
+                    selectedTagModel.addElement(selectedItem);
+                    existingTags.grabFocus();
+                    existingTags.setSelectedIndex(index<existingModel.size()?index:index-1);
+
+                }
+            }
+        });
+
+
+
+        existingModel = QuestController.getInstance().getSourceTags();
+        existingTags.setModel(existingModel);
+
+
+
+
+        selectedTags = new JList<>();
+        selectedTagModel = new DefaultListModel<>();
+        selectedTags.setModel(selectedTagModel);
+
+        selectedTags.getModel().addListDataListener(new ListDataListener() {
+            @Override
+            public void intervalAdded(ListDataEvent e) {
+                doUpdate();
+            }
+
+            @Override
+            public void intervalRemoved(ListDataEvent e) {
+                doUpdate();
+            }
+
+            @Override
+            public void contentsChanged(ListDataEvent e) {
+                doUpdate();
+            }
+        });
+
+        JButton select = new JButton("Select");
+        select.addActionListener(q -> addSelected());
+        JButton add = new JButton("Manual Add");
+        add.addActionListener(q -> manualAdd(selectedTagModel));
+        JButton remove = new JButton("Remove Item");
+        remove.addActionListener(q -> removeSelected());
+
+        tags.setLayout(new BorderLayout());
+
+        JPanel left = new JPanel();
+        left.setLayout(new BorderLayout());
+        left.add(new JLabel("Tags already in use"), BorderLayout.NORTH);
+        JScrollPane listScroller = new JScrollPane(existingTags);
+        listScroller.setMinimumSize(new Dimension(400, 800));
+        left.add(listScroller, BorderLayout.CENTER);
+        tags.add(left, BorderLayout.WEST);
+
+        FormPanel tagEdit = new FormPanel();
+        tagEdit.setLayout(new BorderLayout());
+
+        FormPanel mappedTags = new FormPanel();
+        mappedTags.setLayout(new BorderLayout());
+        mappedTags.add(new JLabel("Tags Mapped to this object"), BorderLayout.NORTH);
+        JScrollPane listScroller2 = new JScrollPane(selectedTags);
+        listScroller2.setMinimumSize(new Dimension(400, 800));
+        mappedTags.add(listScroller2, BorderLayout.CENTER);
+        tagEdit.add(mappedTags,BorderLayout.EAST);
+
+        JPanel controlPanel = new JPanel();
+
+        controlPanel.add(select);
+        controlPanel.add(add);
+        controlPanel.add(manualEntry);
+
+        manualEntry.getInputMap(JList.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
+                KeyStroke.getKeyStroke("ENTER"), "addTyped");
+        manualEntry.getActionMap().put("addTyped", new AbstractAction() {
+
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                if (!manualEntry.getText().trim().isEmpty()) {
+                    manualAdd(selectedTagModel);
+                    manualEntry.grabFocus();
+                }
+            }
+        });
+
+
+        controlPanel.add(remove);
+        tagEdit.add(controlPanel, BorderLayout.CENTER);
+        tags.add(tagEdit,BorderLayout.CENTER);
+
+        JTextArea right1 = new JTextArea("This is really just to pad some space\n" +
+                "but also to explain the use of tags.\n" +
+                "Rather than adding 100's of object names\n" +
+                "to every quest definition, instead we will\n"+
+                "categorize enemies and points of interest with\n"+
+                "tags and reference those categories in quests");
+        right1.setEnabled(false);
+        tags.add(right1, BorderLayout.EAST);
+
+
+
+        name.getDocument().addDocumentListener(new DocumentChangeListener(QuestEdit.this::updateQuest));
+        description.getDocument().addDocumentListener(new DocumentChangeListener(QuestEdit.this::updateQuest));
+        synopsis.getDocument().addDocumentListener(new DocumentChangeListener(QuestEdit.this::updateQuest));
+        storyQuest.getModel().addChangeListener(q -> QuestEdit.this.updateQuest());
+        rewardDescription.getDocument().addDocumentListener(new DocumentChangeListener(QuestEdit.this::updateQuest));
+        stages.addChangeListener(e -> QuestEdit.this.updateQuest());
+        offerEditor.addChangeListener(e -> QuestEdit.this.updateQuest());
+        prologueEditor.addChangeListener(e -> QuestEdit.this.updateQuest());
+        epilogueEditor.addChangeListener(e -> QuestEdit.this.updateQuest());
+        failureEditor.addChangeListener(e -> QuestEdit.this.updateQuest());
+        declineEditor.addChangeListener(e -> QuestEdit.this.updateQuest());
+        stages.addChangeListener(e -> QuestEdit.this.updateQuest());
+        selectedTagModel.addListDataListener(new ListDataListener() {
+            @Override
+            public void intervalAdded(ListDataEvent e) {
+                QuestEdit.this.updateQuest();
+            }
+
+            @Override
+            public void intervalRemoved(ListDataEvent e) {
+                QuestEdit.this.updateQuest();
+            }
+
+            @Override
+            public void contentsChanged(ListDataEvent e) {
+                QuestEdit.this.updateQuest();
+            }
+        });
+
+        refresh();
+    }
+
+    private void doUpdate(){
+        QuestEdit.this.updateQuest();
+    }
+
+    private void addSelected(){
+        if (existingTags.getSelectedIndex()>-1)
+            selectedTagModel.addElement(existingTags.getModel().getElementAt(existingTags.getSelectedIndex()));
+        doUpdate();
+    }
+
+    private void removeSelected(){
+        if (selectedTags.getSelectedIndex()>-1)
+            selectedTagModel.remove(selectedTags.getSelectedIndex());
+        doUpdate();
+    }
+
+    private void filterExisting(DefaultListModel<String> filter){
+        DefaultListModel<String> toReturn = new DefaultListModel<>();
+        for (Enumeration<String> e = QuestController.getInstance().getSourceTags().elements(); e.hasMoreElements();){
+            String toTest = e.nextElement();
+            if (toTest != null & !filter.contains(toTest)){
+                toReturn.addElement(toTest);
+            }
+        }
+        existingTags.setModel(toReturn);
+    }
+
+    private void manualAdd(DefaultListModel<String> model){
+        if (!manualEntry.getText().trim().isEmpty())
+            model.addElement(manualEntry.getText().trim());
+        manualEntry.setText("");
+        doUpdate();
+    }
+
+    protected void updateQuest() {
+        if(currentData==null||updating)
+            return;
+
+        currentData.name                   = name.getText();
+        currentData.storyQuest             = storyQuest.isSelected();
+        currentData.synopsis               = synopsis.getText();
+        currentData.description            = description.getText();
+        currentData.rewardDescription      = rewardDescription.getText();
+        currentData.stages                 = stages.getStages();
+        currentData.offerDialog            = offerEditor.getDialogData();
+        currentData.prologue               = prologueEditor.getDialogData();
+        currentData.epilogue               = epilogueEditor.getDialogData();
+        currentData.failureDialog          = failureEditor.getDialogData();
+        currentData.declinedDialog         = declineEditor.getDialogData();
+
+        ArrayList<String> tags = new ArrayList<>();
+        for (Enumeration<String> e = selectedTagModel.elements(); e.hasMoreElements();){
+            tags.add(e.nextElement());
+        }
+
+        currentData.questSourceTags = tags.toArray(currentData.questSourceTags);
+        QuestController.getInstance().refresh();
+        filterExisting(selectedTagModel);
+    }
+
+    public void setCurrentQuest(AdventureQuestData data)
+    {
+        currentData=data;
+        refresh();
+    }
+
+    private void refresh() {
+        setEnabled(currentData!=null);
+        if(currentData==null)
+        {
+            return;
+        }
+        setVisible(true);
+        updating=true;
+        id.setText(currentData.getID() + "");
+        name.setText(currentData.name);
+        description.setText(currentData.description);
+        synopsis.setText(currentData.synopsis);
+        storyQuest.getModel().setSelected(currentData.storyQuest);
+        rewardDescription.setText(currentData.rewardDescription);
+        stages.setStages(currentData);
+
+        offerEditor.loadData(currentData.offerDialog);
+        prologueEditor.loadData(currentData.prologue);
+        epilogueEditor.loadData(currentData.epilogue);
+        failureEditor.loadData(currentData.failureDialog);
+        declineEditor.loadData(currentData.declinedDialog);
+
+        selectedTagModel.clear();
+        for(String val : currentData.questSourceTags) {
+            if (val != null)
+                selectedTagModel.addElement(val);
+        }
+        filterExisting(selectedTagModel);
+
+        updating=false;
+    }
+
+    public JPanel getOfferTab(){
+        JPanel offerTab = new JPanel();
+        offerTab.setLayout(new BoxLayout(offerTab, BoxLayout.Y_AXIS));
+        FormPanel center = new FormPanel();
+        center.add(offerEditor);
+        offerTab.add(center);
+        return offerTab;
+    }
+
+    public JPanel getPrologueTab(){
+        JPanel prologueTab = new JPanel();
+        prologueTab.setLayout(new BoxLayout(prologueTab, BoxLayout.Y_AXIS));
+        FormPanel center = new FormPanel();
+        center.add(prologueEditor);
+        prologueTab.add(center);
+        return prologueTab;
+    }
+
+    public JPanel getEpilogueTab(){
+        JPanel epilogueTab = new JPanel();
+        epilogueTab.setLayout(new BoxLayout(epilogueTab, BoxLayout.Y_AXIS));
+        FormPanel center = new FormPanel();
+        center.add(epilogueEditor);
+        epilogueTab.add(center);
+        return epilogueTab;
+    }
+
+    public JPanel getFailureTab(){
+        JPanel failureTab = new JPanel();
+        failureTab.setLayout(new BoxLayout(failureTab, BoxLayout.Y_AXIS));
+        FormPanel center = new FormPanel();
+        center.add(failureEditor);
+        failureTab.add(center);
+        return failureTab;
+    }
+
+    public JPanel getDeclineTab(){
+        JPanel declineTab = new JPanel();
+        declineTab.setLayout(new BoxLayout(declineTab, BoxLayout.Y_AXIS));
+        FormPanel center = new FormPanel();
+        center.add(declineEditor);
+        declineTab.add(center);
+        return declineTab;
+    }
+
+    public JPanel getStagesTab(){
+        JPanel stagesTab = new JPanel();
+        stagesTab.setLayout(new BoxLayout(stagesTab, BoxLayout.Y_AXIS));
+        FormPanel center = new FormPanel();
+        center.add(stages);
+        stagesTab.add(center);
+        return stagesTab;
+    }
+
+    public JPanel getSourcesTab(){
+        JPanel sourcesTab = new JPanel();
+        sourcesTab.setLayout(new BoxLayout(sourcesTab, BoxLayout.Y_AXIS));
+        FormPanel center = new FormPanel();
+        center.add(tags);
+        sourcesTab.add(center);
+        return sourcesTab;
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/QuestEditor.java

@@ -0,0 +1,104 @@
+package forge.adventure.editor;
+
+import com.badlogic.gdx.files.FileHandle;
+import com.badlogic.gdx.utils.Array;
+import com.badlogic.gdx.utils.Json;
+import com.badlogic.gdx.utils.JsonWriter;
+import forge.adventure.data.AdventureQuestData;
+import forge.adventure.util.Config;
+import forge.adventure.util.Paths;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionListener;
+
+/**
+ * Editor class to edit configuration, maybe moved or removed
+ */
+public class QuestEditor extends JComponent {
+    JList<AdventureQuestData> list = new JList<>(QuestController.getInstance().getAllQuests());
+    JToolBar toolBar = new JToolBar("toolbar");
+    QuestEdit edit=new QuestEdit();
+
+    public class QuestDataRenderer extends DefaultListCellRenderer {
+        @Override
+        public Component getListCellRendererComponent(
+                JList list, Object value, int index,
+                boolean isSelected, boolean cellHasFocus) {
+            JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+            if(!(value instanceof AdventureQuestData))
+                return label;
+            AdventureQuestData quest=(AdventureQuestData) value;
+            // Get the renderer component from parent class
+
+            label.setText(quest.name);
+            return label;
+        }
+    }
+    public void addButton(String name,ActionListener action)
+    {
+        JButton newButton=new JButton(name);
+        newButton.addActionListener(action);
+        toolBar.add(newButton);
+
+    }
+    public QuestEditor()
+    {
+
+        list.setCellRenderer(new QuestDataRenderer());
+        list.addListSelectionListener(e -> QuestEditor.this.updateEdit());
+        addButton("Add Quest", e -> QuestEditor.this.addStage());
+        addButton("Remove", e -> QuestEditor.this.remove());
+        addButton("Copy", e -> QuestEditor.this.copy());
+        addButton("Load", e -> QuestController.getInstance().load());
+        addButton("Save", e -> QuestEditor.this.save());
+        BorderLayout layout=new BorderLayout();
+        setLayout(layout);
+        add(new JScrollPane(list), BorderLayout.LINE_START);
+        toolBar.setFloatable(false);
+        add(toolBar, BorderLayout.PAGE_START);
+        add(edit,BorderLayout.CENTER);
+        edit.setVisible(false);
+    }
+    private void copy() {
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        AdventureQuestData data=new AdventureQuestData(QuestController.getInstance().getAllQuests().get(selected));
+        data.isTemplate = true;
+        QuestController.getInstance().getAllQuests().add(QuestController.getInstance().getAllQuests().size(),data);
+    }
+    private void updateEdit() {
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        edit.setCurrentQuest(QuestController.getInstance().getAllQuests().get(selected));
+    }
+
+    void save()
+    {
+        Array<AdventureQuestData> allQuests=new Array<>();
+        for(int i=0;i<QuestController.getInstance().getAllQuests().getSize();i++) {
+            allQuests.add(QuestController.getInstance().getAllQuests().get(i));
+        }
+        Json json = new Json(JsonWriter.OutputType.json);
+        FileHandle handle = Config.instance().getFile(Paths.QUESTS);
+        handle.writeString(json.prettyPrint(json.toJson(allQuests,Array.class, AdventureQuestData.class)),false);
+        QuestController.getInstance().save();
+    }
+    void addStage()
+    {
+        AdventureQuestData data=new AdventureQuestData();
+        data.name="New Quest "+QuestController.getInstance().getAllQuests().getSize();
+        data.isTemplate = true;
+        QuestController.getInstance().getAllQuests().add(QuestController.getInstance().getAllQuests().size(),data);
+    }
+    void remove()
+    {
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        QuestController.getInstance().getAllQuests().remove(selected);
+        edit.setVisible(false);
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/QuestStageEdit.java

@@ -0,0 +1,606 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.*;
+import forge.adventure.util.AdventureQuestController;
+
+import javax.swing.*;
+import javax.swing.border.EmptyBorder;
+import javax.swing.event.*;
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class QuestStageEdit extends FormPanel {
+    private boolean updating=false;
+    AdventureQuestStage currentData;
+    AdventureQuestData currentQuestData;
+    public JTextField name=new JTextField("", 25);
+    public JTextField description=new JTextField("", 25);
+    public TextListEdit itemNames =new TextListEdit();
+    public TextListEdit spriteNames =new TextListEdit();
+    public TextListEdit equipNames =new TextListEdit();
+    public TextListEdit prerequisites =new TextListEdit(currentQuestData!=null?(String[])Arrays.stream(currentQuestData.stages).filter(q -> !q.equals(currentData)).toArray():new String[]{}); //May not be the right way to do this, will come back to it.
+
+    JTabbedPane tabs =new JTabbedPane();
+    DialogEditor prologueEditor = new DialogEditor();
+    DialogEditor epilogueEditor = new DialogEditor();
+
+    public QuestStageEdit()
+    {
+        setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
+        add(getInfoTab());
+        add(tabs);
+        tabs.add("Objective", getObjectiveTab());
+        tabs.add("Prologue",getPrologueTab());
+        tabs.add("Epilogue",getEpilogueTab());
+        tabs.add("Prerequisites",getPrereqTab());
+
+        //temp
+        nyi.setForeground(Color.red);
+        //
+
+        addListeners();
+    }
+
+    public JPanel getInfoTab(){
+        JPanel infoTab = new JPanel();
+        FormPanel center=new FormPanel();
+        center.add("name:",name);
+        center.add("description:",description);
+        name.setSize(400, name.getHeight());
+        description.setSize(400, description.getHeight());
+        infoTab.add(center);
+        name.getDocument().addDocumentListener(new DocumentChangeListener(QuestStageEdit.this::updateStage));
+        description.getDocument().addDocumentListener(new DocumentChangeListener(QuestStageEdit.this::updateStage));
+        prerequisites.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(QuestStageEdit.this::updateStage));
+        return infoTab;
+    }
+
+    public JPanel getPrologueTab(){
+        JPanel prologueTab = new JPanel();
+        prologueTab.setLayout(new BoxLayout(prologueTab, BoxLayout.Y_AXIS));
+        FormPanel center = new FormPanel();
+        center.add(prologueEditor);
+        prologueTab.add(center);
+        return prologueTab;
+    }
+
+    public JPanel getEpilogueTab(){
+        JPanel epilogueTab = new JPanel();
+        epilogueTab.setLayout(new BoxLayout(epilogueTab, BoxLayout.Y_AXIS));
+        FormPanel center = new FormPanel();
+        center.add(epilogueEditor);
+        epilogueTab.add(center);
+        return epilogueTab;
+    }
+
+    private JComboBox<AdventureQuestController.ObjectiveTypes> objectiveType;
+
+    private final JLabel nyi = new JLabel("Not yet implemented");
+    private final JTextField deliveryItem=new JTextField(25);
+    private final JTextField mapFlag = new JTextField(25);
+
+    private Box mapFlagGroup;
+    private final JSpinner flagSpinner = new JSpinner(new SpinnerNumberModel(1, 1, 1000, 1));
+    private Box flagValueGroup;
+    private final JCheckBox anyPOI = new JCheckBox("Any Point of Interest matching");
+    private final JCheckBox here = new JCheckBox("Use current map instead of selecting tags");
+    private final JCheckBox mixedEnemies = new JCheckBox("Mixture of enemy types matching");
+    private final JLabel count1Description = new JLabel("(Count 1 description)");
+    private final JLabel count2Description = new JLabel("(Count 2 description)");
+    private final JLabel count3Description = new JLabel("(Count 3 description)");
+    private final JSpinner count1Spinner = new JSpinner(new SpinnerNumberModel(1, 0, 100, 1));
+    private final JSpinner count2Spinner = new JSpinner(new SpinnerNumberModel(1, 0, 100, 1));
+    private final JSpinner count3Spinner = new JSpinner(new SpinnerNumberModel(1, 0, 100, 1));
+
+    private final JLabel arenaLabel = new JLabel("Enter the arena and prove your worth. (Note: Please be sure the PoIs selected have an arena)");
+    private final JLabel clearLabel = new JLabel("Clear all enemies from the target area.");
+    private final JLabel defeatLabel = new JLabel("Defeat a number of enemies of the indicated type.");
+    private final JLabel deliveryLabel = new JLabel("Travel to the given destination to deliver an item (not tracked in inventory).");
+    private final JLabel escortLabel = new JLabel("Protect your target as they travel to their destination.");
+    private final JLabel fetchLabel = new JLabel("Obtain the requested items (not tracked in inventory).");
+    private final JLabel findLabel = new JLabel("Locate the and enter a PoI.");
+    private final JLabel gatherLabel = new JLabel("Have the requested item in your inventory (tracked in inventory)");
+    private final JLabel giveLabel = new JLabel("Have the requested items removed from your inventory.");
+    private final JLabel huntLabel = new JLabel("Track down and defeat your target (on the overworld map).");
+    private final JLabel leaveLabel = new JLabel("Exit the current PoI and return to the overworld map.");
+    private final JLabel noneLabel = new JLabel("No visible objective. Use in coordination with hidden parallel objectives to track when to progress");
+    private final JLabel patrolLabel = new JLabel("Get close to generated coordinates before starting your next objective");
+    private final JLabel rescueLabel = new JLabel("Reach and rescue the target");
+    private final JLabel siegeLabel = new JLabel("Travel to the target location and defeat enemies attacking it");
+    private final JLabel mapFlagLabel = new JLabel("Have a map flag set to a minimum value");
+    private final JLabel questFlagLabel = new JLabel("Have a global quest flag set to a minimum value");
+    private final JLabel travelLabel = new JLabel("Travel to the given destination.");
+    private final JLabel useLabel = new JLabel("Use the indicated item from your inventory.");
+    private JTabbedPane poiPane = new JTabbedPane();
+    private final QuestTagSelector poiSelector = new QuestTagSelector("Destination Tags", false,true);
+    private final QuestTagSelector enemySelector = new QuestTagSelector("Enemy Tags", true,false);
+    private final JTextField poiTokenInput = new JTextField(25);
+
+    private final JLabel poiTokenLabel = new JLabel();
+    private final JLabel poiTokenDescription = new JLabel(
+                 "At the bottom of many objectives involving a PoI, you will see a text field in the format of '$poi_#'." +
+                 "Enter that tag here to ignore the PoI tag selector of this stage and instead use the same PoI that was selected " +
+                 "for that stage as the target PoI for this one as well.");
+
+    private void hideAllControls(){
+        arenaLabel.setVisible(false);
+        clearLabel.setVisible(false);
+        deliveryLabel.setVisible(false);
+        defeatLabel.setVisible(false);
+        escortLabel.setVisible(false);
+        fetchLabel.setVisible(false);
+        findLabel.setVisible(false);
+        gatherLabel.setVisible(false);
+        giveLabel.setVisible(false);
+        huntLabel.setVisible(false);
+        leaveLabel.setVisible(false);
+        noneLabel.setVisible(false);
+        patrolLabel.setVisible(false);
+        rescueLabel.setVisible(false);
+        siegeLabel.setVisible(false);
+        mapFlagLabel.setVisible(false);
+        questFlagLabel.setVisible(false);
+        travelLabel.setVisible(false);
+        useLabel.setVisible(false);
+        deliveryItem.setVisible(false);
+        mapFlagGroup.setVisible(false);
+        flagValueGroup.setVisible(false);
+        anyPOI.setVisible(false);
+        here.setVisible(false);
+        mixedEnemies.setVisible(false);
+        enemySelector.setVisible(false);
+        count1Description.setVisible(false);
+        count2Description.setVisible(false);
+        count3Description.setVisible(false);
+        count1Spinner.setVisible(false);
+        count2Spinner.setVisible(false);
+        count3Spinner.setVisible(false);
+        poiPane.setVisible(false);
+        poiTokenLabel.setVisible(false);
+        nyi.setVisible(false);
+    }
+    private void switchPanels(){
+        hideAllControls();
+        if (objectiveType.getSelectedItem() == null){
+            return;
+        }
+        switch(objectiveType.getSelectedItem().toString()){
+            case "Arena":
+                arenaLabel.setVisible(true);
+                poiPane.setVisible(true);
+                anyPOI.setVisible(true);
+                here.setVisible(true);
+                poiTokenLabel.setVisible(true);
+                break;
+            case "Clear":
+                clearLabel.setVisible(true);
+                nyi.setVisible(true);
+                poiPane.setVisible(true);
+                count1Description.setText("Target candidate percentile");
+                count1Description.setVisible(true);
+                count1Spinner.setVisible(true);
+                count2Description.setText("Percent variance");
+                count2Description.setVisible(true);
+                count2Spinner.setVisible(true);
+                anyPOI.setVisible(true);
+                here.setVisible(true);
+                poiTokenLabel.setVisible(true);
+                break;
+            case "Defeat":
+                defeatLabel.setVisible(true);
+                mixedEnemies.setVisible(true);
+                count1Description.setText("Number to defeat");
+                count1Description.setVisible(true);
+                count1Spinner.setVisible(true);
+                count2Description.setText("Maximum losses");
+                count2Description.setVisible(true);
+                count2Spinner.setVisible(true);
+                enemySelector.setVisible(true);
+                break;
+            case "Delivery":
+                deliveryLabel.setVisible(true);
+                nyi.setVisible(true);
+                poiPane.setVisible(true);
+                anyPOI.setVisible(true);
+                here.setVisible(true);
+                deliveryItem.setVisible(true);
+                poiTokenLabel.setVisible(true);
+                break;
+            case "Escort":
+                escortLabel.setVisible(true);
+                nyi.setVisible(true);
+                poiPane.setVisible(true);
+                here.setVisible(true);
+                spriteNames.setVisible(true);
+                poiTokenLabel.setVisible(true);
+                break;
+            case "Fetch":
+                fetchLabel.setVisible(true);
+                nyi.setVisible(true);
+                poiPane.setVisible(true);
+                anyPOI.setVisible(true);
+                here.setVisible(true);
+                deliveryItem.setVisible(true);
+                enemySelector.setVisible(true);
+                poiTokenLabel.setVisible(true);
+                break;
+            case "Find":
+                findLabel.setVisible(true);
+                nyi.setVisible(true);
+                poiPane.setVisible(true);
+                anyPOI.setVisible(true);
+                poiTokenLabel.setVisible(true);
+                break;
+            case "Gather":
+                gatherLabel.setVisible(true);
+                gatherLabel.setVisible(true);
+                nyi.setVisible(true);
+                itemNames.setVisible(true);
+                break;
+            case "Give":
+                giveLabel.setVisible(true);
+                nyi.setVisible(true);
+                itemNames.setVisible(true);
+                poiPane.setVisible(true);
+                poiTokenLabel.setVisible(true);
+                here.setVisible(true);
+                break;
+            case "Hunt":
+                huntLabel.setVisible(true);
+                enemySelector.setVisible(true);
+                count1Description.setText("Lifespan (seconds to complete hunt before despawn)");
+                count1Description.setVisible(true);
+                count1Spinner.setVisible(true);
+                count1Spinner.setVisible(true);
+                break;
+            case "Leave":
+                leaveLabel.setVisible(true);
+                break;
+            case "None":
+                noneLabel.setVisible(true);
+                nyi.setVisible(true);
+                break;
+            case "Patrol":
+                patrolLabel.setVisible(true);
+                nyi.setVisible(true);
+                break;
+            case "Rescue":
+                rescueLabel.setVisible(true);
+                nyi.setVisible(true);
+                poiPane.setVisible(true);
+                anyPOI.setVisible(true);
+                poiTokenLabel.setVisible(true);
+                here.setVisible(true);
+                spriteNames.setVisible(true);
+                enemySelector.setVisible(true);
+                break;
+            case "Siege":
+                siegeLabel.setVisible(true);
+                nyi.setVisible(true);
+                poiPane.setVisible(true);
+                poiTokenLabel.setVisible(true);
+                anyPOI.setVisible(true);
+                here.setVisible(true);
+                enemySelector.setVisible(true);
+                mixedEnemies.setVisible(true);
+                break;
+            case "MapFlag":
+                mapFlagLabel.setVisible(true);
+                poiPane.setVisible(true);
+                here.setVisible(true);
+                anyPOI.setVisible(true);
+                mapFlagGroup.setVisible(true);
+                flagValueGroup.setVisible(true);
+                break;
+            case "QuestFlag":
+                nyi.setVisible(true);
+                questFlagLabel.setVisible(true);
+                mapFlagGroup.setVisible(true);
+                flagValueGroup.setVisible(true);
+                break;
+            case "Travel":
+                travelLabel.setVisible(true);
+                poiPane.setVisible(true);
+                poiTokenLabel.setVisible(true);
+                poiTokenInput.setVisible(true);
+                anyPOI.setVisible(true);
+                here.setVisible(true);
+                count1Description.setText("Target % of possible distances");
+                count1Description.setVisible(true);
+                count1Spinner.setVisible(true);
+                count2Description.setText("Plus or minus %");
+                count2Description.setVisible(true);
+                count2Spinner.setVisible(true);
+                break;
+            case "Use":
+                useLabel.setVisible(true);
+                nyi.setVisible(true);
+                itemNames.setVisible(true);
+                poiPane.setVisible(true);
+                anyPOI.setVisible(true);
+                here.setVisible(true);
+                poiTokenLabel.setVisible(true);
+                here.setVisible(true);
+                break;
+        }
+    }
+
+    private void changeObjective(){
+        if (objectiveType.getSelectedItem() != null)
+            currentData.objective = AdventureQuestController.ObjectiveTypes.valueOf(objectiveType.getSelectedItem().toString());
+        switchPanels();
+    }
+
+    private JPanel getObjectiveTab(){
+        objectiveType = new JComboBox<>(AdventureQuestController.ObjectiveTypes.values());
+        objectiveType.addActionListener( e -> changeObjective());
+
+        JPanel objectiveTab = new JPanel();
+        JScrollPane scrollPane = new JScrollPane();
+        objectiveTab.add(scrollPane);
+        FormPanel center=new FormPanel();
+        center.add(objectiveType);
+        scrollPane.add(center);
+
+        mapFlagGroup = new Box(BoxLayout.Y_AXIS);
+        mapFlagGroup.add(new JLabel("Map flag to check"));
+        mapFlagGroup.add(mapFlag);
+
+        flagValueGroup = new Box(BoxLayout.Y_AXIS);
+        flagValueGroup.add(new JLabel("Flag value to check"));
+        flagValueGroup.add(flagSpinner);
+
+        JPanel poiSelectorPane = new JPanel();
+        poiSelectorPane.setLayout(new BorderLayout());
+        poiSelectorPane.add(poiSelector, BorderLayout.CENTER);
+        JPanel poiTokenPanel = new JPanel();
+
+        JPanel tokenPanel = new JPanel();
+        tokenPanel.add(new JLabel("Token to use:"));
+        tokenPanel.add(poiTokenInput);
+        tokenPanel.setBorder(new EmptyBorder(10, 10, 30, 10));
+
+        poiTokenPanel.add(poiTokenDescription);
+        poiTokenPanel.add(tokenPanel);
+        poiTokenPanel.add(here);
+
+        GroupLayout poiTokenLayout =  new GroupLayout(poiTokenPanel);
+
+
+        poiTokenLayout.setHorizontalGroup(
+            poiTokenLayout.createParallelGroup(GroupLayout.Alignment.LEADING)
+                            .addComponent(poiTokenDescription)
+                            .addComponent(tokenPanel,GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE,
+                                    GroupLayout.PREFERRED_SIZE)
+                            .addComponent(here));
+
+        poiTokenLayout.setVerticalGroup(
+                poiTokenLayout.createSequentialGroup()
+                        .addComponent(poiTokenDescription)
+                        .addComponent(tokenPanel,GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE,
+                                GroupLayout.PREFERRED_SIZE)
+                        .addComponent(here));
+
+        poiTokenPanel.setLayout(poiTokenLayout);
+
+        poiPane.add("Specific PoI", poiTokenPanel);
+        poiPane.add("Tag Selector", poiSelectorPane);
+        poiPane.setPreferredSize(new Dimension(0,200));
+
+
+        center.add(arenaLabel);
+        center.add(clearLabel);
+        center.add(defeatLabel);
+        center.add(deliveryLabel);
+        center.add(escortLabel);
+        center.add(fetchLabel);
+        center.add(findLabel);
+        center.add(gatherLabel);
+        center.add(giveLabel);
+        center.add(huntLabel);
+        center.add(leaveLabel);
+        center.add(noneLabel);
+        center.add(patrolLabel);
+        center.add(rescueLabel);
+        center.add(siegeLabel);
+        center.add(mapFlagLabel);
+        center.add(questFlagLabel);
+        center.add(travelLabel);
+        center.add(useLabel);
+        center.add(nyi);
+        center.add(deliveryItem);
+        center.add(mapFlagGroup);
+        center.add(flagValueGroup);
+        center.add(anyPOI);
+        center.add(mixedEnemies);
+        center.add(enemySelector);
+        center.add(count1Description);
+        center.add(count1Spinner);
+        center.add(count2Description);
+        center.add(count2Spinner);
+        center.add(count3Description);
+        center.add(count3Spinner);
+        center.add(poiPane);
+        center.add(poiTokenLabel);
+
+        switchPanels();
+
+        poiSelector.selectedItems.addListDataListener(new ListDataListener() {
+            @Override
+            public void intervalAdded(ListDataEvent e) {
+                rebuildPOIList();
+                rebuildEnemyList();
+            }
+
+            @Override
+            public void intervalRemoved(ListDataEvent e) {
+                rebuildPOIList();
+                rebuildEnemyList();
+            }
+
+            @Override
+            public void contentsChanged(ListDataEvent e) {
+                rebuildPOIList();
+                rebuildEnemyList();
+            }
+        });
+
+        return center;
+    }
+
+    private void rebuildPOIList(){
+        List<String> currentList = new ArrayList<>();
+
+        for(int i = 0; i< poiSelector.selectedItems.getSize(); i++){
+            currentList.add(poiSelector.selectedItems.getElementAt(i));
+        }
+        currentData.POITags = currentList;
+    }
+
+    private void rebuildEnemyList(){
+        List<String> currentList = new ArrayList<>();
+
+        for(int i = 0; i< enemySelector.selectedItems.getSize(); i++){
+            currentList.add(enemySelector.selectedItems.getElementAt(i));
+        }
+        currentData.enemyTags = currentList;
+    }
+
+    private JPanel getPrereqTab(){
+        JPanel prereqTab = new JPanel();
+        prereqTab.add(new JLabel("Insert Prereq data here"));
+
+        return prereqTab;
+    }
+
+    private void refresh() {
+
+        if(currentData==null)
+        {
+            return;
+        }
+        setEnabled(false);
+        updating=true;
+        objectiveType.setSelectedItem(currentData.objective);
+        if (objectiveType.getSelectedItem() != null)
+            currentData.objective = AdventureQuestController.ObjectiveTypes.valueOf(objectiveType.getSelectedItem().toString()); //Ensuring this gets initialized on new
+
+        name.setText(currentData.name);
+        description.setText(currentData.description);
+        deliveryItem.setText(currentData.deliveryItem);
+
+        if (currentData.enemyTags != null){
+            DefaultListModel<String> selectedEnemies = new DefaultListModel<>();
+            for (int i = 0; i < currentData.enemyTags.size(); i++) {
+                selectedEnemies.add(i, currentData.enemyTags.get(i));
+            }
+            enemySelector.load(selectedEnemies);
+        }
+        if (currentData.POITags != null){
+            DefaultListModel<String> selectedPOI = new DefaultListModel<>();
+            for (int i = 0; i < currentData.POITags.size(); i++) {
+                selectedPOI.add(i, currentData.POITags.get(i));
+            }
+            poiSelector.load(selectedPOI);
+        }
+
+        itemNames.setText(currentData.itemNames);
+        equipNames.setText(currentData.equipNames);
+        prologueEditor.loadData(currentData.prologue);
+        epilogueEditor.loadData(currentData.epilogue);
+
+
+        if (currentData.POITags != null){
+            DefaultListModel<String> selectedPOI = new DefaultListModel<>();
+            for (int i = 0; i < currentData.POITags.size(); i++) {
+                selectedPOI.add(i, currentData.POITags.get(i));
+            }
+            poiSelector.load(selectedPOI);
+        }
+        here.getModel().setSelected(currentData.here);
+        poiTokenInput.setText(currentData.POIToken);
+        poiTokenLabel.setText( "To reference this point of interest: $(poi_" + currentData.id + ")");
+
+        ArrayList<String> temp = new ArrayList<>();
+        for (AdventureQuestStage stage : currentQuestData.stages){
+            if (stage.equals(currentData))
+                continue;
+            temp.add(stage.name);
+        }
+        prerequisites.setOptions(temp);
+
+        count1Spinner.getModel().setValue(currentData.count1);
+        count2Spinner.getModel().setValue(currentData.count2);
+        count3Spinner.getModel().setValue(currentData.count3);
+
+        updating=false;
+        setEnabled(true);
+    }
+    public void updateStage()
+    {
+        if(currentData==null||updating)
+            return;
+
+        currentData.name=name.getText();
+        currentData.description= description.getText();
+        currentData.prologue = prologueEditor.getDialogData();
+        currentData.epilogue = epilogueEditor.getDialogData();
+        currentData.deliveryItem = deliveryItem.getText();
+        currentData.itemNames = itemNames.getList()==null?new ArrayList<>():Arrays.asList(itemNames.getList());
+        currentData.equipNames = equipNames.getList()==null?new ArrayList<>():Arrays.asList(equipNames.getList());
+        currentData.anyPOI = anyPOI.getModel().isSelected();
+        currentData.mapFlag = mapFlag.getText();
+        currentData.mapFlagValue = Integer.parseInt(flagSpinner.getModel().getValue().toString());
+        currentData.count1 = Integer.parseInt(count1Spinner.getModel().getValue().toString());
+        currentData.count2 = Integer.parseInt(count2Spinner.getModel().getValue().toString());
+        currentData.count3 = Integer.parseInt(count3Spinner.getModel().getValue().toString());
+        currentData.mixedEnemies = mixedEnemies.getModel().isSelected();
+        currentData.here = here.getModel().isSelected();
+        currentData.POIToken = poiTokenInput.getText();
+
+        rebuildPOIList();
+        rebuildEnemyList();
+        emitChanged();
+    }
+    public void setCurrentStage(AdventureQuestStage stageData, AdventureQuestData data) {
+        if (stageData == null)
+            stageData = new AdventureQuestStage();
+        if (data == null)
+            data = new AdventureQuestData();
+        currentData =stageData;
+        currentQuestData=data;
+        setVisible(true);
+        refresh();
+    }
+
+    public void addChangeListener(ChangeListener listener) {
+        listenerList.add(ChangeListener.class, listener);
+    }
+    protected void emitChanged() {
+        ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
+        if (listeners != null && listeners.length > 0) {
+            ChangeEvent evt = new ChangeEvent(this);
+            for (ChangeListener listener : listeners) {
+                listener.stateChanged(evt);
+            }
+        }
+    }
+
+    private void addListeners(){
+        deliveryItem.getDocument().addDocumentListener(new DocumentChangeListener(QuestStageEdit.this::updateStage));
+        mapFlag.getDocument().addDocumentListener(new DocumentChangeListener(QuestStageEdit.this::updateStage));
+        flagSpinner.getModel().addChangeListener(q -> QuestStageEdit.this.updateStage());
+        count1Spinner.getModel().addChangeListener(q -> QuestStageEdit.this.updateStage());
+        count2Spinner.getModel().addChangeListener(q -> QuestStageEdit.this.updateStage());
+        count3Spinner.getModel().addChangeListener(q -> QuestStageEdit.this.updateStage());
+        mixedEnemies.getModel().addChangeListener(q -> QuestStageEdit.this.updateStage());
+        here.getModel().addChangeListener(q -> QuestStageEdit.this.updateStage());
+        anyPOI.getModel().addChangeListener(q -> QuestStageEdit.this.updateStage());
+        deliveryItem.getDocument().addDocumentListener(new DocumentChangeListener(QuestStageEdit.this::updateStage));
+        mapFlag.getDocument().addDocumentListener(new DocumentChangeListener(QuestStageEdit.this::updateStage));
+        prologueEditor.addChangeListener(q -> QuestStageEdit.this.updateStage());
+        epilogueEditor.addChangeListener(q -> QuestStageEdit.this.updateStage());
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/QuestStageEditor.java

@@ -0,0 +1,139 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.AdventureQuestData;
+import forge.adventure.data.AdventureQuestStage;
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.*;
+import java.awt.event.ActionListener;
+
+/**
+ * Editor class to edit configuration, maybe moved or removed
+ */
+public class QuestStageEditor extends JComponent{
+    DefaultListModel<AdventureQuestStage> model = new DefaultListModel<>();
+    JList<AdventureQuestStage> list = new JList<>(model);
+    JScrollPane scroll;
+    JToolBar toolBar = new JToolBar("toolbar");
+    QuestStageEdit edit=new QuestStageEdit();
+
+    AdventureQuestData currentData;
+
+    public class QuestStageRenderer extends DefaultListCellRenderer {
+        @Override
+        public Component getListCellRendererComponent(
+                JList list, Object value, int index,
+                boolean isSelected, boolean cellHasFocus) {
+            JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+            if(!(value instanceof AdventureQuestStage))
+                return label;
+            AdventureQuestStage stageData=(AdventureQuestStage) value;
+            label.setText(stageData.name);
+            //label.setIcon(new ImageIcon(Config.instance().getFilePath(stageData.sourcePath))); //Type icon eventually?
+            return label;
+        }
+    }
+    public void addButton(String name, ActionListener action)
+    {
+        JButton newButton=new JButton(name);
+        newButton.addActionListener(action);
+        toolBar.add(newButton);
+
+    }
+
+    public QuestStageEditor()
+    {
+        list.setCellRenderer(new QuestStageRenderer());
+        list.addListSelectionListener(e -> QuestStageEditor.this.updateEdit());
+        addButton("Add Quest Stage", e -> QuestStageEditor.this.addStage());
+        addButton("Remove Selected", e -> QuestStageEditor.this.remove());
+        toolBar.setFloatable(false);
+        setLayout(new BorderLayout());
+        scroll = new JScrollPane(list);
+        add(scroll, BorderLayout.WEST);
+        JPanel editPanel = new JPanel();
+        editPanel.setLayout(new BorderLayout());
+        add(toolBar, BorderLayout.NORTH);
+        editPanel.add(edit,BorderLayout.CENTER);
+        add(editPanel);
+        edit.addChangeListener(e -> emitChanged());
+    }
+
+    protected void emitChanged() {
+        ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
+        if (listeners != null && listeners.length > 0) {
+            ChangeEvent evt = new ChangeEvent(this);
+            for (ChangeListener listener : listeners) {
+                listener.stateChanged(evt);
+            }
+        }
+
+    }
+
+    private void updateEdit() {
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        edit.setCurrentStage(model.get(selected),currentData);
+    }
+
+    void addStage()
+    {
+        AdventureQuestStage data=new AdventureQuestStage();
+        data.name = "New Stage";
+        model.add(model.size(),data);
+        edit.setVisible(true);
+        scroll.setVisible(true);
+        int id = 0;
+        for (int i = 0; i < model.size(); i++)
+        {
+            if (model.get(i).id >= id)
+                id = model.get(i).id +1;
+        }
+        data.id = id;
+        if (model.size() == 1){
+            list.setSelectedIndex(0);
+        }
+        emitChanged();
+    }
+    void remove()
+    {
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        model.remove(selected);
+        edit.setVisible(false);
+        scroll.setVisible(list.getModel().getSize() > 0);
+        emitChanged();
+    }
+    public void setStages(AdventureQuestData data) {
+
+        currentData=data;
+        model.clear();
+        if(data==null||data.stages==null || data.stages.length == 0)
+        {
+            edit.setVisible(false);
+            return;
+        }
+        for (int i=0;i<data.stages.length;i++) {
+            model.add(i,data.stages[i]);
+        }
+        if (model.size() > 0) {
+            list.setSelectedIndex(0);
+        }
+    }
+
+    public AdventureQuestStage[] getStages() {
+
+        AdventureQuestStage[] stages= new AdventureQuestStage[model.getSize()];
+        for(int i=0;i<model.getSize();i++)
+        {
+            stages[i]=model.get(i);
+        }
+        return stages;
+    }
+    public void addChangeListener(ChangeListener listener) {
+        listenerList.add(ChangeListener.class, listener);
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/QuestTagSelector.java

@@ -0,0 +1,107 @@
+package forge.adventure.editor;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class QuestTagSelector extends JComponent  {
+    DefaultListModel<String> allItems = new DefaultListModel<>();
+    DefaultListModel<String> selectedItems = new DefaultListModel<>();
+    JList<String> unselectedList;
+    JList<String> selectedList;
+
+    boolean useEnemyTags = false;
+    boolean usePOITags = false;
+
+    public QuestTagSelector(String title, boolean useEnemyTags, boolean usePOITags)
+    {
+        if (useEnemyTags){
+            this.useEnemyTags = true;
+        } else if (usePOITags) {
+            this.usePOITags = true;
+        }
+        else{
+            return;
+        }
+
+        unselectedList = new JList<>(allItems);
+        selectedList = new JList<>(selectedItems);
+//        unselectedList.setCellRenderer(new PointOfInterestEditor.PointOfInterestRenderer()); // Replace with use count of tag?
+//        selectedList.setCellRenderer(new PointOfInterestEditor.PointOfInterestRenderer());
+
+        JButton addButton=new JButton("add");
+        JButton removeButton=new JButton("remove");
+        addButton.addActionListener( e -> QuestTagSelector.this.addTag());
+        removeButton.addActionListener( e -> QuestTagSelector.this.removeTag());
+
+        BorderLayout layout=new BorderLayout();
+        setLayout(layout);
+        if (title.length() > 0)
+            add(new JLabel(title),BorderLayout.PAGE_START);
+        add(new JScrollPane(unselectedList), BorderLayout.LINE_START);
+        add(new JScrollPane(selectedList), BorderLayout.LINE_END);
+
+        JPanel buttonPanel = new JPanel();
+        GridLayout buttonLayout = new GridLayout(2,0);
+        buttonPanel.setLayout(buttonLayout);
+        buttonPanel.add(addButton);
+        buttonPanel.add(removeButton);
+        add(buttonPanel);
+    }
+
+    public void addTag(){
+        if (unselectedList.isSelectionEmpty()){
+            return;
+        }
+        for (String toAdd : unselectedList.getSelectedValuesList())
+        {
+            if (selectedItems.contains(toAdd)) continue;
+            selectedItems.addElement(toAdd);
+        }
+        refresh();
+    }
+
+    public void removeTag(){
+        if (selectedList.isSelectionEmpty()){
+            return;
+        }
+        for (String toRemove : selectedList.getSelectedValuesList())
+        {
+            selectedItems.removeElement(toRemove);
+        }
+        refresh();
+    }
+
+    public void load(DefaultListModel<String> selectedNames)
+    {
+        allItems.clear();
+        selectedItems.clear();
+
+        if (useEnemyTags){
+            allItems =  QuestController.getInstance().getEnemyTags();
+        }
+        else if (usePOITags) {
+            allItems = QuestController.getInstance().getPOITags();
+        }
+        unselectedList.setModel(allItems);
+        for (int i=0;i<allItems.size();i++){
+            if (selectedNames.contains(allItems.get(i))){
+                selectedItems.addElement(allItems.get(i));
+            }
+        }
+    }
+
+    private boolean updating=false;
+
+    private void refresh() {
+        setEnabled(allItems!=null);
+        if(allItems==null)
+        {
+            return;
+        }
+        updating=true;
+
+        //unselectedList = new JList<>(allItems);
+        //selectedList = new JList<>(selectedItems);
+        updating=false;
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/RewardEdit.java

@@ -7,18 +7,15 @@ import forge.game.keyword.Keyword;
 import javax.swing.*;
 import javax.swing.event.ChangeEvent;
 import javax.swing.event.ChangeListener;
-import java.awt.*;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
 import java.util.Arrays;
 
 /**
  * Editor class to edit configuration, maybe moved or removed
  */
-public class RewardEdit extends JComponent {
+public class RewardEdit extends FormPanel {
     RewardData currentData;
 
-    JComboBox typeField =new JComboBox(new String[] { "card", "gold", "life", "deckCard", "item"});
+    JComboBox typeField =new JComboBox(new String[] { "card", "gold", "life", "deckCard", "item","shards"});
     JSpinner probability = new JSpinner(new SpinnerNumberModel(0f, 0, 1, 0.1f));
     JSpinner count = new JSpinner(new SpinnerNumberModel(0, 0, 1000, 1));
     JSpinner addMaxCount = new JSpinner(new SpinnerNumberModel(0, 0, 1000, 1));
@@ -38,122 +35,41 @@ public class RewardEdit extends JComponent {
 
     public RewardEdit()
     {
-        setLayout(new GridLayout(16,2));
 
-        add(new JLabel("Type:")); add(typeField);
-        add(new JLabel("probability:")); add(probability);
-        add(new JLabel("count:")); add(count);
-        add(new JLabel("addMaxCount:")); add(addMaxCount);
-        add(new JLabel("cardName:")); add(cardName);
-        add(new JLabel("itemName:")); add(itemName);
-        add(new JLabel("editions:")); add(editions);
-        add(new JLabel("colors:")); add(colors);
-        add(new JLabel("rarity:")); add(rarity);
-        add(new JLabel("subTypes:")); add(subTypes);
-        add(new JLabel("cardTypes:")); add(cardTypes);
-        add(new JLabel("superTypes:")); add(superTypes);
-        add(new JLabel("manaCosts:")); add(manaCosts);
-        add(new JLabel("keyWords:")); add(keyWords);
-        add(new JLabel("colorType:")); add(colorType);
-        add(new JLabel("cardText:")); add(cardText);
+        add("Type:",typeField);
+        add("probability:",probability);
+        add("count:",count);
+        add("addMaxCount:",addMaxCount);
+        add("cardName:",cardName);
+        add("itemName:",itemName);
+        add("editions:",editions);
+        add("colors:",colors);
+        add("rarity:",rarity);
+        add("subTypes:",subTypes);
+        add("cardTypes:",cardTypes);
+        add("superTypes:",superTypes);
+        add("manaCosts:",manaCosts);
+        add("keyWords:",keyWords);
+        add("colorType:",colorType);
+        add("cardText:",cardText);
 
 
-        typeField.addActionListener((new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                RewardEdit.this.updateReward();
-            }
-        }));
-        probability.addChangeListener(new ChangeListener() {
-            @Override
-            public void stateChanged(ChangeEvent e) {
-                RewardEdit.this.updateReward();
-            }
-        });
-        count.addChangeListener(new ChangeListener() {
-            @Override
-            public void stateChanged(ChangeEvent e) {
-                RewardEdit.this.updateReward();
-            }
-        });
-        addMaxCount.addChangeListener(new ChangeListener() {
-            @Override
-            public void stateChanged(ChangeEvent e) {
-                RewardEdit.this.updateReward();
-            }
-        });
-        cardName.getDocument().addDocumentListener(new DocumentChangeListener(new Runnable() {
-            @Override
-            public void run() {
-                RewardEdit.this.updateReward();
-            }
-        }));
-        itemName.getDocument().addDocumentListener(new DocumentChangeListener(new Runnable() {
-            @Override
-            public void run() {
-                RewardEdit.this.updateReward();
-            }
-        }));
-        editions.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(new Runnable() {
-            @Override
-            public void run() {
-                RewardEdit.this.updateReward();
-            }
-        }));
-        colors.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(new Runnable() {
-            @Override
-            public void run() {
-                RewardEdit.this.updateReward();
-            }
-        }));
-        rarity.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(new Runnable() {
-            @Override
-            public void run() {
-                RewardEdit.this.updateReward();
-            }
-        }));
-        subTypes.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(new Runnable() {
-            @Override
-            public void run() {
-                RewardEdit.this.updateReward();
-            }
-        }));
-        cardTypes.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(new Runnable() {
-            @Override
-            public void run() {
-                RewardEdit.this.updateReward();
-            }
-        }));
-        superTypes.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(new Runnable() {
-            @Override
-            public void run() {
-                RewardEdit.this.updateReward();
-            }
-        }));
-        manaCosts.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(new Runnable() {
-            @Override
-            public void run() {
-                RewardEdit.this.updateReward();
-            }
-        }));
-        keyWords.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(new Runnable() {
-            @Override
-            public void run() {
-                RewardEdit.this.updateReward();
-            }
-        }));
-        colorType.addActionListener((new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                RewardEdit.this.updateReward();
-            }
-        }));
-        cardText.getDocument().addDocumentListener(new DocumentChangeListener(new Runnable() {
-            @Override
-            public void run() {
-                RewardEdit.this.updateReward();
-            }
-        }));
+        typeField.addActionListener((e -> RewardEdit.this.updateReward()));
+        probability.addChangeListener(e -> RewardEdit.this.updateReward());
+        count.addChangeListener(e -> RewardEdit.this.updateReward());
+        addMaxCount.addChangeListener(e -> RewardEdit.this.updateReward());
+        cardName.getDocument().addDocumentListener(new DocumentChangeListener(() -> RewardEdit.this.updateReward()));
+        itemName.getDocument().addDocumentListener(new DocumentChangeListener(() -> RewardEdit.this.updateReward()));
+        editions.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> RewardEdit.this.updateReward()));
+        colors.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> RewardEdit.this.updateReward()));
+        rarity.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> RewardEdit.this.updateReward()));
+        subTypes.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> RewardEdit.this.updateReward()));
+        cardTypes.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> RewardEdit.this.updateReward()));
+        superTypes.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> RewardEdit.this.updateReward()));
+        manaCosts.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> RewardEdit.this.updateReward()));
+        keyWords.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> RewardEdit.this.updateReward()));
+        colorType.addActionListener((e -> RewardEdit.this.updateReward()));
+        cardText.getDocument().addDocumentListener(new DocumentChangeListener(() -> RewardEdit.this.updateReward()));
 
     }
 
@@ -167,7 +83,7 @@ public class RewardEdit extends JComponent {
         currentData.count= (int) count.getValue();
         currentData.addMaxCount= (int) addMaxCount.getValue();
         currentData.cardName = cardName.getText().isEmpty()?null:cardName.getText();
-        currentData.itemName = itemName.getText().isEmpty()?null:itemName.getText();
+        currentData.itemNames = itemName.getText().isEmpty()?null:itemName.getText().split(",");
         currentData.editions = editions.getList();
         currentData.colors = colors.getList();
         currentData.rarity = rarity.getList();

forge-adventure/src/main/java/forge/adventure/editor/RewardsEditor.java

@@ -5,10 +5,7 @@ import forge.adventure.data.RewardData;
 import javax.swing.*;
 import javax.swing.event.ChangeEvent;
 import javax.swing.event.ChangeListener;
-import javax.swing.event.ListSelectionEvent;
-import javax.swing.event.ListSelectionListener;
 import java.awt.*;
-import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 
 /**
@@ -19,7 +16,7 @@ public class RewardsEditor extends JComponent{
     JList<RewardData> list = new JList<>(model);
     JToolBar toolBar = new JToolBar("toolbar");
     RewardEdit edit=new RewardEdit();
-
+    boolean updating;
 
 
     public class RewardDataRenderer extends DefaultListCellRenderer {
@@ -59,30 +56,10 @@ public class RewardsEditor extends JComponent{
     {
 
         list.setCellRenderer(new RewardDataRenderer());
-        list.addListSelectionListener(new ListSelectionListener() {
-            @Override
-            public void valueChanged(ListSelectionEvent e) {
-                RewardsEditor.this.updateEdit();
-            }
-        });
-        addButton("add", new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                RewardsEditor.this.addReward();
-            }
-        });
-        addButton("remove", new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                RewardsEditor.this.remove();
-            }
-        });
-        addButton("copy", new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                RewardsEditor.this.copy();
-            }
-        });
+        list.addListSelectionListener(e -> RewardsEditor.this.updateEdit());
+        addButton("add", e -> RewardsEditor.this.addReward());
+        addButton("remove", e -> RewardsEditor.this.remove());
+        addButton("copy", e -> RewardsEditor.this.copy());
         BorderLayout layout=new BorderLayout();
         setLayout(layout);
         add(list, BorderLayout.LINE_START);
@@ -90,14 +67,11 @@ public class RewardsEditor extends JComponent{
         add(edit,BorderLayout.CENTER);
 
 
-        edit.addChangeListener(new ChangeListener() {
-            @Override
-            public void stateChanged(ChangeEvent e) {
-                emitChanged();
-            }
-        });
+        edit.addChangeListener(e -> emitChanged());
     }
     protected void emitChanged() {
+        if (updating)
+            return;
         ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
         if (listeners != null && listeners.length > 0) {
             ChangeEvent evt = new ChangeEvent(this);
@@ -154,6 +128,12 @@ public class RewardsEditor extends JComponent{
         }
         return rewards;
     }
+
+    public void clear(){
+        updating = true;
+        model.clear();
+        updating = false;
+    }
     public void addChangeListener(ChangeListener listener) {
         listenerList.add(ChangeListener.class, listener);
     }

forge-adventure/src/main/java/forge/adventure/editor/StructureEditor.java

@@ -0,0 +1,222 @@
+package forge.adventure.editor;
+
+import com.badlogic.gdx.graphics.Color;
+import forge.adventure.data.BiomeData;
+import forge.adventure.data.BiomeStructureData;
+import forge.adventure.util.Config;
+import forge.adventure.world.BiomeStructure;
+import forge.adventure.world.ColorMap;
+
+import javax.imageio.ImageIO;
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.*;
+import java.awt.event.ActionListener;
+import java.awt.geom.AffineTransform;
+import java.awt.image.AffineTransformOp;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * Editor class to edit configuration, maybe moved or removed
+ */
+public class StructureEditor extends JComponent{
+    DefaultListModel<BiomeStructureData> model = new DefaultListModel<>();
+    JList<BiomeStructureData> list = new JList<>(model);
+    JToolBar toolBar = new JToolBar("toolbar");
+    BiomeStructureEdit edit=new BiomeStructureEdit();
+
+    BiomeData currentData;
+
+    public class StructureDataRenderer extends DefaultListCellRenderer {
+        @Override
+        public Component getListCellRendererComponent(
+                JList list, Object value, int index,
+                boolean isSelected, boolean cellHasFocus) {
+            JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+            if(!(value instanceof BiomeStructureData))
+                return label;
+            BiomeStructureData structureData=(BiomeStructureData) value;
+            label.setText("Structure");
+            label.setIcon(new ImageIcon(Config.instance().getFilePath(structureData.sourcePath)));
+            return label;
+        }
+    }
+    public void addButton(String name, ActionListener action)
+    {
+        JButton newButton=new JButton(name);
+        newButton.addActionListener(action);
+        toolBar.add(newButton);
+
+    }
+
+    public StructureEditor()
+    {
+
+        list.setCellRenderer(new StructureDataRenderer());
+        list.addListSelectionListener(e -> StructureEditor.this.updateEdit());
+        addButton("add", e -> StructureEditor.this.addStructure());
+        addButton("remove", e -> StructureEditor.this.remove());
+        addButton("copy", e -> StructureEditor.this.copy());
+        addButton("test", e -> StructureEditor.this.test());
+        BorderLayout layout=new BorderLayout();
+        setLayout(layout);
+        add(list, BorderLayout.WEST);
+        add(toolBar, BorderLayout.NORTH);
+        add(edit,BorderLayout.CENTER);
+
+
+        edit.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                emitChanged();
+            }
+        });
+    }
+    protected void emitChanged() {
+        ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
+        if (listeners != null && listeners.length > 0) {
+            ChangeEvent evt = new ChangeEvent(this);
+            for (ChangeListener listener : listeners) {
+                listener.stateChanged(evt);
+            }
+        }
+    }
+    private void test() {
+        if (list.isSelectionEmpty())
+            return;
+        long start = System.currentTimeMillis();
+        BiomeStructureData data = model.get(list.getSelectedIndex());
+
+        try
+        {
+
+        BiomeStructure struct = new BiomeStructure(data, System.currentTimeMillis(),
+                (int) (currentData.width * EditorMainWindow.worldEditor.width.intValue() ),
+                (int) (currentData.width * EditorMainWindow.worldEditor.height.intValue()));
+
+            BufferedImage sourceImage= null;
+            try {
+                sourceImage = ImageIO.read(new File(struct.sourceImagePath()));
+            ColorMap sourceColorMap=new ColorMap(sourceImage.getWidth(),sourceImage.getHeight());
+            for(int y=0;y<sourceColorMap.getHeight();y++)
+                for(int x=0;x<sourceColorMap.getWidth();x++)
+                {
+                    Color c =new Color();
+                    Color.argb8888ToColor(c,sourceImage.getRGB(x,y));
+                    sourceColorMap.setColor(x,y,c);
+                }
+
+
+            BufferedImage  maskImage=   ImageIO.read(new File(struct.maskImagePath()));
+            ColorMap maskColorMap=new ColorMap(maskImage.getWidth(),maskImage.getHeight());
+            for(int y=0;y<maskColorMap.getHeight();y++)
+                for(int x=0;x<maskColorMap.getWidth();x++)
+                {
+                    Color c =new Color();
+                    Color.argb8888ToColor(c,maskImage.getRGB(x,y));
+                    maskColorMap.setColor(x,y,c);
+                }
+
+            struct.initialize(sourceColorMap,maskColorMap);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        float calcTime=(System.currentTimeMillis() - start)/1000f;
+
+        JLabel label = new JLabel();
+        ColorMap colorMap=struct.image;
+        BufferedImage image = new BufferedImage(colorMap.getWidth(),colorMap.getHeight(),BufferedImage.TYPE_INT_ARGB);
+
+            for(int y=0;y<colorMap.getHeight();y++)
+                for(int x=0;x<colorMap.getWidth();x++)
+                    image.setRGB(x,y,Color.argb8888(colorMap.getColor(x,y)));
+
+        if (image.getWidth() < 640 | image.getHeight() < 640) {
+            if (image.getHeight() > image.getWidth()) {
+                BufferedImage nimage = new BufferedImage(640, 640 * (image.getWidth() / image.getHeight()), BufferedImage.TYPE_INT_ARGB);
+                AffineTransform at = new AffineTransform();
+                at.scale(640 / image.getHeight(), 640 / image.getHeight());
+                AffineTransformOp scaleOp = new AffineTransformOp(at, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
+                image = scaleOp.filter(image, nimage);
+            } else {
+                BufferedImage nimage = new BufferedImage(640 * (image.getHeight() / image.getWidth()), 640, BufferedImage.TYPE_INT_ARGB);
+                AffineTransform at = new AffineTransform();
+                at.scale(640 / image.getWidth(), 640 / image.getWidth());
+                AffineTransformOp scaleOp = new AffineTransformOp(at, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
+                image = scaleOp.filter(image, nimage);
+            }
+
+        }
+        label.setIcon(new ImageIcon(image));
+        label.setSize(640, 640);
+
+
+
+        JOptionPane.showMessageDialog(this, label,"Calculating took "+ calcTime+" seconds",JOptionPane.PLAIN_MESSAGE);
+        }
+        catch (Exception e)
+        {
+            JOptionPane.showMessageDialog(this, "WaveFunctionCollapse was not successful","can not calculate function "+e.getMessage(),JOptionPane.ERROR_MESSAGE);
+        }
+
+    }
+    private void copy() {
+
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        BiomeStructureData data=new BiomeStructureData(model.get(selected));
+        model.add(model.size(),data);
+    }
+
+    private void updateEdit() {
+
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        edit.setCurrentStructure(model.get(selected),currentData);
+    }
+
+    void addStructure()
+    {
+        BiomeStructureData data=new BiomeStructureData();
+        model.add(model.size(),data);
+    }
+    void remove()
+    {
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        model.remove(selected);
+    }
+    public void setStructures(BiomeData data) {
+
+        currentData=data;
+        model.clear();
+        if(data==null||data.structures==null)
+        {
+            edit.setCurrentStructure(null,null);
+            return;
+        }
+        for (int i=0;i<data.structures.length;i++) {
+            model.add(i,data.structures[i]);
+        }
+        list.setSelectedIndex(0);
+    }
+
+    public BiomeStructureData[] getBiomeStructureData() {
+
+        BiomeStructureData[] rewards= new BiomeStructureData[model.getSize()];
+        for(int i=0;i<model.getSize();i++)
+        {
+            rewards[i]=model.get(i);
+        }
+        return rewards;
+    }
+    public void addChangeListener(ChangeListener listener) {
+        listenerList.add(ChangeListener.class, listener);
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/SwingAtlas.java

@@ -19,13 +19,15 @@ import static java.awt.Image.SCALE_FAST;
  */
 public class SwingAtlas {
 
+    int imageSize=32;
     HashMap<String, ArrayList<ImageIcon>> images=new  HashMap<>();
     public HashMap<String, ArrayList<ImageIcon>> getImages()
     {
         return images;
     }
-    public  SwingAtlas(FileHandle path)
+    public  SwingAtlas(FileHandle path,int imageSize)
     {
+        this.imageSize=imageSize;
         if(!path.exists()||!path.toString().endsWith(".atlas"))
             return;
         TextureAtlas.TextureAtlasData data=new TextureAtlas.TextureAtlasData(path,path.parent(),false);
@@ -37,20 +39,41 @@ public class SwingAtlas {
                  images.put(name,new ArrayList<>());
              }
             ArrayList<ImageIcon> imageList=images.get(name);
-            try {
+            try
+            {
                 imageList.add(spriteToImage(region));
-            } catch (IOException e) {
+            }
+            catch (IOException e)
+            {
                 e.printStackTrace();
             }
         }
     }
-
-    private ImageIcon spriteToImage(TextureAtlas.TextureAtlasData.Region sprite) throws IOException {
-        BufferedImage img = ImageIO.read(sprite.page.textureFile.file());
-        return new ImageIcon(img.getSubimage(sprite.left,sprite.top, sprite.width, sprite.height).getScaledInstance(32,32,SCALE_FAST));
+    public  SwingAtlas(FileHandle path)
+    {
+        this(path,32);
     }
 
+    private ImageIcon spriteToImage(TextureAtlas.TextureAtlasData.Region sprite) throws IOException {
+        try
+        {
+            BufferedImage img = ImageIO.read(sprite.page.textureFile.file());
+            if(sprite.width== sprite.height)
+                return new ImageIcon(img.getSubimage(sprite.left,sprite.top, sprite.width, sprite.height).getScaledInstance(imageSize,imageSize,SCALE_FAST));
+            if(sprite.width>sprite.height)
+                return new ImageIcon(img.getSubimage(sprite.left,sprite.top, sprite.width, sprite.height).getScaledInstance(imageSize, (int) (imageSize*(sprite.height/(float)sprite.width)),SCALE_FAST));
+            return new ImageIcon(img.getSubimage(sprite.left,sprite.top, sprite.width, sprite.height).getScaledInstance((int) (imageSize*(sprite.width/(float)sprite.height)),imageSize,SCALE_FAST));
+
+        }
+        catch (IOException e)
+        {
+            return null;
+        }
+}
+
     public ImageIcon get(String name) {
+        if(images.get(name).size()==0)
+            return null;
         return images.get(name).get(0);
     }
 

forge-adventure/src/main/java/forge/adventure/editor/SwingAtlasPreview.java

@@ -6,6 +6,7 @@ import org.apache.commons.lang3.tuple.Pair;
 import javax.swing.*;
 import java.awt.event.ActionEvent;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -13,12 +14,17 @@ import java.util.Map;
  * Editor class to edit configuration, maybe moved or removed
  */
 public class SwingAtlasPreview extends Box {
+    int imageSize=32;
     private String sprite="";
+    private String spriteName="";
     Timer timer;
-    public SwingAtlasPreview() {
+    public SwingAtlasPreview()
+    {
+        this(64,200);
+    }
+    public SwingAtlasPreview(int imageSize,int timeDelay) {
         super(BoxLayout.Y_AXIS);
-
-         timer = new Timer(200, new AbstractAction() {
+         timer = new Timer(timeDelay, new AbstractAction() {
             @Override
             public void actionPerformed(ActionEvent e) {
                 counter++;
@@ -27,26 +33,62 @@ public class SwingAtlasPreview extends Box {
                 }
             }
         });
+        this.imageSize=imageSize;
+    }
+    static Map<String,Map<Integer,SwingAtlas>> cache=new HashMap<>();
+    public SwingAtlasPreview(int size) {
+        this();
+        imageSize=size;
     }
     int counter=0;
     List<Pair<JLabel,ArrayList<ImageIcon>>> labels=new ArrayList<>();
     public void setSpritePath(String sprite) {
 
-        if(this.sprite==null||this.sprite.equals(sprite))
+        setSpritePath(sprite,null);
+    }
+    public void setSpritePath(String sprite,String name) {
+        if(this.sprite==null||sprite==null||(this.sprite.equals(sprite)&&(spriteName != null && spriteName.equals(name))))
             return;
         removeAll();
         counter=0;
         labels.clear();
         this.sprite=sprite;
-        SwingAtlas atlas=new SwingAtlas(Config.instance().getFile(sprite));
+        this.spriteName=name;
+        SwingAtlas atlas;
+        if(!cache.containsKey(sprite))
+        {
+            cache.put(sprite,new HashMap<>() );
+        }
+        if(!cache.get(sprite).containsKey(imageSize))
+        {
+            cache.get(sprite).put(imageSize,new SwingAtlas(Config.instance().getFile(sprite),imageSize) );
+        }
+        atlas=cache.get(sprite).get(imageSize);
+        int maxCount=0;
         for(Map.Entry<String, ArrayList<ImageIcon>> element:atlas.getImages().entrySet())
         {
-            JLabel image=new JLabel(element.getValue().get(0));
-            add(new JLabel(element.getKey()));
-            add(image);
-            labels.add(Pair.of(image, element.getValue()));
+            if(name==null||element.getKey().equals(name))
+            {
+                JLabel image=new JLabel(element.getValue().get(0));
+                if(maxCount<element.getValue().size())
+                    maxCount=element.getValue().size();
+                add(new JLabel(element.getKey()));
+                add(image);
+                labels.add(Pair.of(image, element.getValue()));
+            }
         }
-        timer.restart();
-        repaint();
+        if(maxCount<=1)
+        {
+            timer.stop();
+        }
+        else
+        {
+            timer.restart();
+        }
+//        doLayout(); //These lines cause images to bleed on to other tabs and don't appear to be needed
+//        revalidate();
+//        update(getGraphics());
+//        repaint();
+
     }
 }

forge-adventure/src/main/java/forge/adventure/editor/TerrainsEditor.java

@@ -0,0 +1,132 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.BiomeData;
+import forge.adventure.data.BiomeTerrainData;
+
+import javax.swing.*;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.*;
+import java.awt.event.ActionListener;
+
+/**
+ * Editor class to edit configuration, maybe moved or removed
+ */
+public class TerrainsEditor extends JComponent{
+    DefaultListModel<BiomeTerrainData> model = new DefaultListModel<>();
+    JList<BiomeTerrainData> list = new JList<>(model);
+    JToolBar toolBar = new JToolBar("toolbar");
+    BiomeTerrainEdit edit=new BiomeTerrainEdit();
+
+    BiomeData currentData;
+
+    public class TerrainDataRenderer extends DefaultListCellRenderer {
+        @Override
+        public Component getListCellRendererComponent(
+                JList list, Object value, int index,
+                boolean isSelected, boolean cellHasFocus) {
+            JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+            if(!(value instanceof BiomeTerrainData))
+                return label;
+            BiomeTerrainData terrainData=(BiomeTerrainData) value;
+            StringBuilder builder=new StringBuilder();
+            builder.append("Terrain");
+            builder.append(" ");
+            builder.append(terrainData.spriteName);
+            label.setText(builder.toString());
+            return label;
+        }
+    }
+    public void addButton(String name, ActionListener action)
+    {
+        JButton newButton=new JButton(name);
+        newButton.addActionListener(action);
+        toolBar.add(newButton);
+
+    }
+
+    public TerrainsEditor()
+    {
+
+        list.setCellRenderer(new TerrainDataRenderer());
+        list.addListSelectionListener(e -> TerrainsEditor.this.updateEdit());
+        addButton("add", e -> TerrainsEditor.this.addTerrain());
+        addButton("remove", e -> TerrainsEditor.this.remove());
+        addButton("copy", e -> TerrainsEditor.this.copy());
+        BorderLayout layout=new BorderLayout();
+        setLayout(layout);
+        add(list, BorderLayout.LINE_START);
+        add(toolBar, BorderLayout.PAGE_START);
+        add(edit,BorderLayout.CENTER);
+
+
+        edit.addChangeListener(new ChangeListener() {
+            @Override
+            public void stateChanged(ChangeEvent e) {
+                emitChanged();
+            }
+        });
+    }
+    protected void emitChanged() {
+        ChangeListener[] listeners = listenerList.getListeners(ChangeListener.class);
+        if (listeners != null && listeners.length > 0) {
+            ChangeEvent evt = new ChangeEvent(this);
+            for (ChangeListener listener : listeners) {
+                listener.stateChanged(evt);
+            }
+        }
+    }
+    private void copy() {
+
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        BiomeTerrainData data=new BiomeTerrainData(model.get(selected));
+        model.add(model.size(),data);
+    }
+
+    private void updateEdit() {
+
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        edit.setCurrentTerrain(model.get(selected),currentData);
+    }
+
+    void addTerrain()
+    {
+        BiomeTerrainData data=new BiomeTerrainData();
+        model.add(model.size(),data);
+    }
+    void remove()
+    {
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        model.remove(selected);
+    }
+    public void setTerrains(BiomeData data) {
+
+        currentData=data;
+        model.clear();
+        if(data==null||data.terrain==null)
+            return;
+        for (int i=0;i<data.terrain.length;i++) {
+            model.add(i,data.terrain[i]);
+        }
+        list.setSelectedIndex(0);
+    }
+
+    public BiomeTerrainData[] getBiomeTerrainData() {
+
+        BiomeTerrainData[] rewards= new BiomeTerrainData[model.getSize()];
+        for(int i=0;i<model.getSize();i++)
+        {
+            rewards[i]=model.get(i);
+        }
+        return rewards;
+    }
+    public void addChangeListener(ChangeListener listener) {
+        listenerList.add(ChangeListener.class, listener);
+    }
+}

forge-adventure/src/main/java/forge/adventure/editor/TextListEdit.java

@@ -1,12 +1,8 @@
 package forge.adventure.editor;
 
-import forge.adventure.util.Config;
-
 import javax.swing.*;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.io.File;
-import java.io.IOException;
+import java.awt.*;
+import java.util.List;
 
 /**
  * Editor class to edit configuration, maybe moved or removed
@@ -18,15 +14,11 @@ public class TextListEdit extends Box {
     public TextListEdit(String[] possibleElements) {
         super(BoxLayout.X_AXIS);
 
-        findButton.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                TextListEdit.this.find();
-            }
-        });
+        findButton.addActionListener(e -> TextListEdit.this.find());
 
         add(edit);
-        //add(findButton);
+        edit.setPreferredSize(new Dimension(400,edit.getPreferredSize().height));
+        add(findButton);
         elements= new JComboBox(possibleElements);
         add(elements);
 
@@ -42,23 +34,41 @@ public class TextListEdit extends Box {
     }
 
     private void find() {
-        JFileChooser fc = new JFileChooser();
-        fc.setCurrentDirectory(new File(Config.instance().getFilePath("")));
-        fc.setMultiSelectionEnabled(false);
-        if (fc.showOpenDialog(this) ==
-                JFileChooser.APPROVE_OPTION) {
-            File selected = fc.getSelectedFile();
+        edit.setText((edit.getText().trim().length()>0?edit.getText() + ";": "")+elements.getSelectedItem().toString());
+        elements.remove(elements.getSelectedIndex());
+        elements.setSelectedIndex(0);
+//        JFileChooser fc = new JFileChooser();
+//        fc.setCurrentDirectory(new File(Config.instance().getFilePath("")));
+//        fc.setMultiSelectionEnabled(false);
+//        if (fc.showOpenDialog(this) ==
+//                JFileChooser.APPROVE_OPTION) {
+//            File selected = fc.getSelectedFile();
+//
+//            try {
+//                if (selected != null&&selected.getCanonicalPath().startsWith(new File(Config.instance().getFilePath("")).getCanonicalPath())) {
+//                    edit.setText(selected.getCanonicalPath().substring(new File(Config.instance().getFilePath("")).getCanonicalPath().length()+1));
+//                }
+//            } catch (IOException e) {
+//                e.printStackTrace();
+//            }
+//        }
+    }
 
-            try {
-                if (selected != null&&selected.getCanonicalPath().startsWith(new File(Config.instance().getFilePath("")).getCanonicalPath())) {
-                    edit.setText(selected.getCanonicalPath().substring(new File(Config.instance().getFilePath("")).getCanonicalPath().length()+1));
-                }
-            } catch (IOException e) {
-                e.printStackTrace();
-            }
+    public void setOptions(List<String> itemNames) {
+        if(itemNames==null)
+            elements.removeAllItems();
+        else {
+            for(String item: itemNames)
+                elements.addItem(item);
         }
     }
 
+    public void setText(List<String> itemNames) {
+        if(itemNames==null)
+            edit.setText("");
+        else
+            edit.setText(String.join(";",itemNames));
+    }
     public void setText(String[] itemName) {
         if(itemName==null)
             edit.setText("");
@@ -77,7 +87,7 @@ public class TextListEdit extends Box {
         {
             values.append(intValues[i]);
             if(intValues.length>i+2)
-                values.append(";");
+                values.append("\n");
         }
         edit.setText(values.toString());
     }
@@ -96,7 +106,7 @@ public class TextListEdit extends Box {
             String intName=stringList[i];
             try
             {
-                retList[i] = Integer.valueOf(intName);
+                retList[i] = Integer.parseInt(intName);
             }
             catch (NumberFormatException e)
             {

forge-adventure/src/main/java/forge/adventure/editor/WorldEditor.java

@@ -1,6 +1,235 @@
 package forge.adventure.editor;
 
-import java.awt.*;
+import com.badlogic.gdx.files.FileHandle;
+import com.badlogic.gdx.utils.Json;
+import com.badlogic.gdx.utils.JsonWriter;
+import forge.adventure.data.BiomeData;
+import forge.adventure.data.WorldData;
+import forge.adventure.util.Config;
+import forge.adventure.util.Paths;
 
-public class WorldEditor extends Component {
+import javax.swing.*;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import java.awt.*;
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+public class WorldEditor extends JComponent {
+
+    WorldData  currentData;
+
+
+    IntSpinner width= new IntSpinner( 0, 100000, 1);
+    IntSpinner height= new IntSpinner( 0, 100000, 1);
+    FloatSpinner playerStartPosX= new FloatSpinner( 0, 1, .1f);
+    FloatSpinner playerStartPosY= new FloatSpinner(0, 1, .1f);
+    FloatSpinner noiseZoomBiome= new FloatSpinner( 0, 1000f, 1f);
+    IntSpinner tileSize= new IntSpinner( 0, 100000, 1);
+
+    JTextField  biomesSprites       =   new JTextField();
+    FloatSpinner maxRoadDistance        =   new FloatSpinner( 0, 100000f, 1f);
+    TextListEdit biomesNames        =   new TextListEdit();
+
+    DefaultListModel<BiomeData> model = new DefaultListModel<>();
+    JList<BiomeData> list = new JList<>(model);
+    BiomeEdit edit=new BiomeEdit();
+    JTabbedPane tabs =new JTabbedPane();
+    static HashMap<String,SwingAtlas> atlas=new HashMap<>();
+
+    public class BiomeDataRenderer extends DefaultListCellRenderer {
+        @Override
+        public Component getListCellRendererComponent(
+                JList list, Object value, int index,
+                boolean isSelected, boolean cellHasFocus) {
+            JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
+            if(!(value instanceof BiomeData))
+                return label;
+            BiomeData biome=(BiomeData) value;
+            // Get the renderer component from parent class
+
+            label.setText(biome.name);
+            if(!atlas.containsKey(biome.tilesetAtlas))
+                atlas.put(biome.tilesetAtlas,new SwingAtlas(Config.instance().getFile(biome.tilesetAtlas)));
+
+            SwingAtlas poiAtlas = atlas.get(biome.tilesetAtlas);
+
+            if(poiAtlas.has(biome.tilesetName))
+                label.setIcon(poiAtlas.get(biome.tilesetName));
+            else
+            {
+                ImageIcon img=poiAtlas.getAny();
+                if(img!=null)
+                    label.setIcon(img);
+            }
+            return label;
+        }
+    }
+
+    /**
+     *
+     */
+    private void updateBiome() {
+
+        int selected=list.getSelectedIndex();
+        if(selected<0)
+            return;
+        edit.setCurrentBiome(model.get(selected));
+    }
+
+    public WorldEditor() {
+        list.setCellRenderer(new BiomeDataRenderer());
+        list.addListSelectionListener(new ListSelectionListener() {
+            @Override
+            public void valueChanged(ListSelectionEvent e) {
+                WorldEditor.this.updateBiome();
+            }
+        });
+        BorderLayout layout = new BorderLayout();
+        setLayout(layout);
+        add(tabs);
+        JSplitPane biomeData=new JSplitPane();
+        tabs.addTab("BiomeData", biomeData);
+
+
+        FormPanel worldPanel=new FormPanel();
+        worldPanel.add("width:",width);
+        worldPanel.add("height:",height);
+        worldPanel.add("playerStartPosX:",playerStartPosX);
+        worldPanel.add("playerStartPosY:",playerStartPosY);
+        worldPanel.add("noiseZoomBiome:",noiseZoomBiome);
+        worldPanel.add("tileSize:",tileSize);
+        worldPanel.add("biomesSprites:",biomesSprites);
+        worldPanel.add("maxRoadDistance:",maxRoadDistance);
+        worldPanel.add("biomesNames:",biomesNames);
+        tabs.addTab("WorldData", worldPanel);
+
+
+        JScrollPane pane = new JScrollPane(edit);
+        biomeData.setLeftComponent(list);    biomeData.setRightComponent(pane);
+
+        load();
+
+        JToolBar toolBar = new JToolBar("toolbar");
+        add(toolBar, BorderLayout.PAGE_START);
+        JButton newButton=new JButton("save");
+        newButton.addActionListener(e -> WorldEditor.this.save());
+        toolBar.add(newButton);
+
+         newButton=new JButton("save selected biome");
+        newButton.addActionListener(e -> WorldEditor.this.saveBiome());
+        toolBar.add(newButton);
+
+        newButton=new JButton("load");
+        newButton.addActionListener(e -> WorldEditor.this.load());
+        toolBar.add(newButton);
+
+        toolBar.addSeparator();
+
+        newButton=new JButton("test map");
+        newButton.addActionListener(e -> WorldEditor.this.test());
+        toolBar.add(newButton);
+
+
+        newButton=new JButton("edit effects");
+        newButton.addActionListener(e -> WorldEditor.this.startEffectEditor());
+        toolBar.add(newButton);
+    }
+
+    private void startEffectEditor() {
+
+    }
+
+    private void test() {
+
+        String javaHome = System.getProperty("java.home");
+        String javaBin = javaHome + File.separator + "bin" + File.separator + "java";
+        String classpath = System.getProperty("java.class.path");
+        String className = forge.adventure.Main.class.getName();
+
+        ArrayList<String> command = new ArrayList<>();
+        command.add(javaBin);
+        command.add("-cp");
+        command.add(classpath);
+        command.add(className);
+
+        command.add("testMap");
+
+        ProcessBuilder build=  new ProcessBuilder(command);
+        build .redirectInput(ProcessBuilder.Redirect.INHERIT)
+                .redirectOutput(ProcessBuilder.Redirect.INHERIT)
+                .redirectError(ProcessBuilder.Redirect.INHERIT);
+        try {
+           Process process=  build.start();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    void saveBiome()
+    {
+
+        edit.updateTerrain();
+        Json json = new Json(JsonWriter.OutputType.json);
+        FileHandle handle =  Config.instance().getFile(currentData.biomesNames[list.getSelectedIndex()]);
+        handle.writeString(json.prettyPrint(json.toJson(edit.currentData,  BiomeData.class)),false);
+
+    }
+    void save()
+    {
+        currentData.width=width.intValue();
+        currentData.height=height.intValue();
+        currentData.playerStartPosX=playerStartPosX.floatValue();
+        currentData.playerStartPosY=playerStartPosY.floatValue();
+        currentData.noiseZoomBiome=noiseZoomBiome.floatValue();
+        currentData.tileSize=tileSize.intValue();
+        currentData.biomesSprites=biomesSprites.getText();
+        currentData.maxRoadDistance=maxRoadDistance.floatValue();
+        currentData.biomesNames=  (biomesNames.getList());
+
+        Json json = new Json(JsonWriter.OutputType.json);
+        FileHandle handle = Config.instance().getFile(Paths.WORLD);
+        handle.writeString(json.prettyPrint(json.toJson(currentData,  WorldData.class)),false);
+
+    }
+    void load()
+    {
+
+
+
+        model.clear();
+        Json json = new Json();
+        FileHandle handle = Config.instance().getFile(Paths.WORLD);
+        if (handle.exists())
+        {
+              currentData=json.fromJson(WorldData.class, WorldData.class, handle);
+        }
+        update();
+    }
+
+    private void update() {
+        width.setValue(currentData.width);
+        height.setValue(currentData.height);
+        playerStartPosX.setValue(currentData.playerStartPosX);
+        playerStartPosY.setValue(currentData.playerStartPosY);
+        noiseZoomBiome.setValue(currentData.noiseZoomBiome);
+        tileSize.setValue(currentData.tileSize);
+        biomesSprites.setText(currentData.biomesSprites);
+        maxRoadDistance.setValue(currentData.maxRoadDistance);
+        biomesNames.setText(currentData.biomesNames);
+
+        for(String path:currentData.biomesNames)
+        {
+            Json json = new Json();
+            FileHandle handle = Config.instance().getFile(path);
+            if (handle.exists())
+            {
+                BiomeData data=json.fromJson(BiomeData.class, BiomeData.class, handle);
+                model.addElement(data);
+            }
+        }
+
+    }
 }

forge-ai/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <artifactId>forge</artifactId>
         <groupId>forge</groupId>
-        <version>1.6.50-SNAPSHOT</version>
+        <version>1.6.56</version>
     </parent>
 
     <artifactId>forge-ai</artifactId>

forge-ai/src/main/java/forge/ai/AIDeckStatistics.java

@@ -0,0 +1,121 @@
+package forge.ai;
+
+import forge.card.CardRules;
+import forge.card.CardType;
+import forge.deck.CardPool;
+import forge.deck.Deck;
+import forge.deck.DeckSection;
+import forge.game.card.Card;
+import forge.game.player.Player;
+import forge.item.PaperCard;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class AIDeckStatistics {
+
+    public float averageCMC = 0;
+    // TODO implement this. Use a numerically stable algorithm from
+    // https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Weighted_incremental_algorithm
+    public float stddevCMC = 0;
+    public int maxCost = 0;
+    public int maxColoredCost = 0;
+
+    // in WUBRGC order from ManaCost.getColorShardCounts()
+    public int[] maxPips = null;
+//    public int[] numSources = new int[6];
+    public int numLands = 0;
+    public AIDeckStatistics(float averageCMC, float stddevCMC, int maxCost, int maxColoredCost, int[] maxPips, int numLands) {
+        this.averageCMC = averageCMC;
+        this.stddevCMC = stddevCMC;
+        this.maxCost = maxCost;
+        this.maxColoredCost = maxColoredCost;
+        this.maxPips = maxPips;
+        this.numLands = numLands;
+    }
+
+    public static AIDeckStatistics fromCardList(List<CardRules> cards) {
+        int totalCMC = 0;
+        int totalCount = 0;
+        int numLands = 0;
+        int maxCost = 0;
+        int[] maxPips = new int[6];
+        int maxColoredCost = 0;
+        for (CardRules rules : cards) {
+            CardType type = rules.getType();
+            if (type.isLand()) {
+                numLands += 1;
+            } else {
+                int cost = rules.getManaCost().getCMC();
+                // TODO use alternate casting costs for this, free spells will usually be cast for free
+                maxCost = Math.max(maxCost, cost);
+                totalCMC += cost;
+                totalCount++;
+                int[] pips = rules.getManaCost().getColorShardCounts();
+                int colored_pips = 0;
+                for (int i = 0; i < pips.length; i++) {
+                    maxPips[i] = Math.max(maxPips[i], pips[i]);
+                    if (i < 5) {
+                        colored_pips += pips[i];
+                    }
+                }
+                maxColoredCost = Math.max(maxColoredCost, colored_pips);
+            }
+
+            // TODO implement the number of mana sources
+            // find the sources
+            // What about non-mana-ability mana sources?
+            // fetchlands, ramp spells, etc
+
+        }
+
+        return new AIDeckStatistics(totalCount == 0 ? 0 : totalCMC / (float)totalCount,
+                0, // TODO use https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
+                maxCost,
+                maxColoredCost,
+                maxPips,
+                numLands
+                );
+    }
+
+
+    public static AIDeckStatistics fromDeck(Deck deck) {
+        List<CardRules> rules_list = new ArrayList<>();
+        for (final Map.Entry<DeckSection, CardPool> deckEntry : deck) {
+            switch (deckEntry.getKey()) {
+                case Main:
+                case Commander:
+                    for (final Map.Entry<PaperCard, Integer> poolEntry : deckEntry.getValue()) {
+                        CardRules rules = poolEntry.getKey().getRules();
+                        rules_list.add(rules);
+                    }
+                    break;
+                default:
+                    break; //ignore other sections
+            }
+        }
+
+        return fromCardList(rules_list);
+    }
+
+    public static AIDeckStatistics fromPlayer(Player player) {
+        Deck deck = player.getRegisteredPlayer().getDeck();
+        if (deck.isEmpty()) {
+            // we're in a test or some weird match, search through the hand and library and build the decklist
+            List<CardRules> rules_list = new ArrayList<>();
+            for (Card c : player.getAllCards()) {
+                if (c.getPaperCard() == null) {
+                    continue;
+                }
+                rules_list.add(c.getRules());
+            }
+
+            return fromCardList(rules_list);
+        }
+
+        return fromDeck(deck);
+
+    }
+
+}

forge-ai/src/main/java/forge/ai/AiAttackController.java

@@ -18,9 +18,12 @@
 package forge.ai;
 
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 
-import forge.game.staticability.StaticAbilityMustAttack;
+import forge.game.staticability.StaticAbility;
+import forge.game.staticability.StaticAbilityAssignCombatDamageAsUnblocked;
 import org.apache.commons.lang3.tuple.Pair;
 
 import com.google.common.base.Predicate;
@@ -47,6 +50,7 @@ import forge.game.combat.GlobalAttackRestrictions;
 import forge.game.cost.Cost;
 import forge.game.keyword.Keyword;
 import forge.game.player.Player;
+import forge.game.player.PlayerCollection;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityPredicates;
 import forge.game.trigger.Trigger;
@@ -58,9 +62,6 @@ import forge.util.Expressions;
 import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 import forge.util.collect.FCollectionView;
-import forge.util.maps.LinkedHashMapToAmount;
-import forge.util.maps.MapToAmount;
-import forge.util.maps.MapToAmountUtil;
 
 
 /**
@@ -75,7 +76,7 @@ public class AiAttackController {
 
     // possible attackers and blockers
     private List<Card> attackers;
-    private final List<Card> blockers;
+    private List<Card> blockers;
 
     private List<Card> oppList; // holds human player creatures
     private List<Card> myList; // holds computer creatures
@@ -98,17 +99,15 @@ public class AiAttackController {
 
     public AiAttackController(final Player ai, boolean nextTurn) {
         this.ai = ai;
-        defendingOpponent = choosePreferredDefenderPlayer(ai);
-        this.oppList = getOpponentCreatures(defendingOpponent);
+        defendingOpponent = choosePreferredDefenderPlayer(ai, true);
         myList = ai.getCreaturesInPlay();
         this.nextTurn = nextTurn;
-        refreshAttackers(defendingOpponent);
-        this.blockers = getPossibleBlockers(oppList, this.attackers, this.nextTurn);
+        refreshCombatants(defendingOpponent);
     } // overloaded constructor to evaluate attackers that should attack next turn
 
     public AiAttackController(final Player ai, Card attacker) {
         this.ai = ai;
-        defendingOpponent = choosePreferredDefenderPlayer(ai);
+        defendingOpponent = choosePreferredDefenderPlayer(ai, true);
         this.oppList = getOpponentCreatures(defendingOpponent);
         myList = ai.getCreaturesInPlay();
         this.nextTurn = false;
@@ -119,13 +118,15 @@ public class AiAttackController {
         this.blockers = getPossibleBlockers(oppList, this.attackers, this.nextTurn);
     } // overloaded constructor to evaluate single specified attacker
 
-    private void refreshAttackers(GameEntity defender) {
+    private void refreshCombatants(GameEntity defender) {
+        this.oppList = getOpponentCreatures(defendingOpponent);
         this.attackers = new ArrayList<>();
         for (Card c : myList) {
             if (canAttackWrapper(c, defender)) {
                 attackers.add(c);
             }
         }
+        this.blockers = getPossibleBlockers(oppList, this.attackers, this.nextTurn);
     }
 
     public static List<Card> getOpponentCreatures(final Player defender) {
@@ -153,6 +154,7 @@ public class AiAttackController {
 
     public void removeBlocker(Card blocker) {
     	this.oppList.remove(blocker);
+        this.blockers.remove(blocker);
     }
 
     private boolean canAttackWrapper(final Card attacker, final GameEntity defender) {
@@ -168,13 +170,34 @@ public class AiAttackController {
      * No strategy to secure a second place instead, since Forge has no variant for that
      */
     public static Player choosePreferredDefenderPlayer(Player ai) {
+        return choosePreferredDefenderPlayer(ai, false);
+    }
+    public static Player choosePreferredDefenderPlayer(Player ai, boolean forCombatDmg) {
         Player defender = ai.getWeakestOpponent(); //Concentrate on opponent within easy kill range
 
-        // TODO connect with evaluateBoardPosition and only fall back to random when no player is the biggest threat by a fair margin
+        // TODO for multiplayer combat avoid players with cantLose or (if not playing infect) cantLoseForZeroOrLessLife and !canLoseLife
+
+        if (defender.getLife() > 8) {
+            // TODO connect with evaluateBoardPosition and only fall back to random when no player is the biggest threat by a fair margin
+
+            List<Player> opps = Lists.newArrayList(ai.getOpponents());
+            if (forCombatDmg) {
+                for (Player p : ai.getOpponents()) {
+                    if (p.isMonarch() && ai.canBecomeMonarch()) {
+                        // just increase the odds for now instead of being fully predictable
+                        // as it could lead to other too complex factors giving this reasoning negative impact
+                        opps.add(p);
+                    }
+                    if (p.hasInitiative()) {
+                        opps.add(p);
+                    }
+                }
+            }
 
-        if (defender.getLife() > 8) { //Otherwise choose a random opponent to ensure no ganging up on players
             // TODO should we cache the random for each turn? some functions like shouldPumpCard base their decisions on the assumption who will be attacked
-            return Aggregates.random(ai.getOpponents());
+
+            //Otherwise choose a random opponent to ensure no ganging up on players
+            return Aggregates.random(opps);
         }
         return defender;
     }
@@ -234,7 +257,7 @@ public class AiAttackController {
                         continue;
                     }
 
-                    if (sa.getApi() == ApiType.EachDamage && "TriggeredAttacker".equals(sa.getParam("DefinedPlayers"))) {
+                    if (sa.getApi() == ApiType.EachDamage && "TriggeredAttacker".equals(sa.getParam("Defined"))) {
                         List<Card> valid = CardLists.getValidCards(c.getController().getCreaturesInPlay(), sa.getParam("ValidCards"), c.getController(), c, sa);
                         // TODO: this assumes that 1 damage is dealt per creature. Improve this to check the parameter/X to determine
                         // how much damage is dealt by each of the creatures in the valid list.
@@ -356,7 +379,7 @@ public class AiAttackController {
             }
         });
 
-        final List<Card> notNeededAsBlockers = new CardCollection(attackers);
+        final CardCollection notNeededAsBlockers = new CardCollection(attackers);
 
         // don't hold back creatures that can't block any of the human creatures
         final List<Card> blockers = getPossibleBlockers(attackers, opponentsAttackers, true);
@@ -375,7 +398,7 @@ public class AiAttackController {
             int thresholdMod = 0;
             int lastAcceptableBaselineLife = 0;
             if (pilotsNonAggroDeck) {
-                lastAcceptableBaselineLife = ComputerUtil.predictNextCombatsRemainingLife(ai, playAggro, pilotsNonAggroDeck, 0, new CardCollection(notNeededAsBlockers));
+                lastAcceptableBaselineLife = ComputerUtil.predictNextCombatsRemainingLife(ai, playAggro, pilotsNonAggroDeck, 0, notNeededAsBlockers);
                 if (!ai.isCardInPlay("Laboratory Maniac")) {
                     // AI is getting milled out
                     thresholdMod += 3 - Math.min(ai.getCardsIn(ZoneType.Library).size(), 3);
@@ -394,7 +417,7 @@ public class AiAttackController {
                     continue;
                 }
                 notNeededAsBlockers.add(c);
-                int currentBaselineLife = ComputerUtil.predictNextCombatsRemainingLife(ai, playAggro, pilotsNonAggroDeck, 0, new CardCollection(notNeededAsBlockers));
+                int currentBaselineLife = ComputerUtil.predictNextCombatsRemainingLife(ai, playAggro, pilotsNonAggroDeck, 0, notNeededAsBlockers);
                 // AI doesn't know from what it will lose, so it might still keep an unnecessary blocker back sometimes
                 if (currentBaselineLife == Integer.MIN_VALUE) {
                     notNeededAsBlockers.remove(c);
@@ -538,7 +561,7 @@ public class AiAttackController {
 
         for (Card attacker : categorizedAttackers) {
             if (!CombatUtil.canBeBlocked(attacker, accountedBlockers, null)
-                    || attacker.hasKeyword("You may have CARDNAME assign its combat damage as though it weren't blocked.")) {
+                    || StaticAbilityAssignCombatDamageAsUnblocked.assignCombatDamageAsUnblocked(attacker)) {
                 unblockedAttackers.add(attacker);
             } else {
                 if (predictEvasion) {
@@ -572,8 +595,7 @@ public class AiAttackController {
             if (numExtraBlocks > 0) {
                 // TODO should be limited to how much getBlockCost the opp can pay
                 while (numExtraBlocks-- > 0 && !remainingAttackers.isEmpty()) {
-                    blockedAttackers.add(remainingAttackers.get(0));
-                    remainingAttackers.remove(0);
+                    blockedAttackers.add(remainingAttackers.remove(0));
                     maxBlockersAfterCrew--;
                 }
             }
@@ -581,8 +603,7 @@ public class AiAttackController {
             if (remainingAttackers.isEmpty()) {
                 break;
             }
-            blockedAttackers.add(remainingAttackers.get(0));
-            remainingAttackers.remove(0);
+            blockedAttackers.add(remainingAttackers.remove(0));
             maxBlockersAfterCrew--;
         }
         unblockedAttackers.addAll(remainingAttackers);
@@ -605,8 +626,8 @@ public class AiAttackController {
             final CardCollection unblockableCantPayFor = new CardCollection();
             final CardCollection unblockableWithoutCost = new CardCollection();
             // TODO also check poison
-            for (Card attacker : CardLists.getKeyword(unblockedAttackers, Keyword.TRAMPLE)) {
-                Cost tax = CombatUtil.getAttackCost(attacker.getGame(), attacker, defendingOpponent);
+            for (Card attacker : unblockedAttackers) {
+                Cost tax = CombatUtil.getAttackCost(ai.getGame(), attacker, defendingOpponent);
                 if (tax == null) {
                     unblockableWithoutCost.add(attacker);
                 } else {
@@ -620,19 +641,17 @@ public class AiAttackController {
                 }
             }
             int dmgUnblockableAfterPaying = ComputerUtilCombat.sumDamageIfUnblocked(unblockableWithPaying, defendingOpponent);
+            unblockedAttackers = unblockableWithoutCost;
             if (dmgUnblockableAfterPaying > trampleDamage) {
-                unblockedAttackers.removeAll(unblockableCantPayFor);
-                unblockedAttackers.removeAll(unblockableWithPaying);
+                myFreeMana -= unblockableAttackTax;
                 totalCombatDamage = dmgUnblockableAfterPaying;
                 // recalculate the trampler damage with the reduced mana available now
-                myFreeMana -= unblockableAttackTax;
                 trampleDamage = getDamageFromBlockingTramplers(blockedAttackers, remainingBlockers, myFreeMana).getLeft();
             } else {
-                unblockedAttackers = unblockableWithoutCost;
                 myFreeMana -= tramplerTaxPaid;
                 // find out if we can still pay for some left
                 for (Card attacker : unblockableWithPaying) {
-                    Cost tax = CombatUtil.getAttackCost(attacker.getGame(), attacker, defendingOpponent);
+                    Cost tax = CombatUtil.getAttackCost(ai.getGame(), attacker, defendingOpponent);
                     int taxCMC = tax.getCostMana().getMana().getCMC();
                     if (myFreeMana < unblockableAttackTax + taxCMC) {
                         continue;
@@ -664,7 +683,7 @@ public class AiAttackController {
         CardCollection remainingBlockers = new CardCollection(blockers);
         for (Card attacker : CardLists.getKeyword(blockedAttackers, Keyword.TRAMPLE)) {
             // TODO might sort by quotient of dmg/cost for best combination
-            Cost tax = CombatUtil.getAttackCost(attacker.getGame(), attacker, defendingOpponent);
+            Cost tax = CombatUtil.getAttackCost(ai.getGame(), attacker, defendingOpponent);
             int taxCMC = tax != null ? tax.getCostMana().getMana().getCMC() : 0;
             if (myFreeMana < currentAttackTax + taxCMC) {
                 continue;
@@ -716,12 +735,24 @@ public class AiAttackController {
      * @return a {@link forge.game.combat.Combat} object.
      */
     public final int declareAttackers(final Combat combat) {
+        // something prevents attacking, try another
+        if (this.attackers.isEmpty() && ai.getOpponents().size() > 1) {
+            final PlayerCollection opps = ai.getOpponents();
+            opps.remove(defendingOpponent);
+            defendingOpponent = Aggregates.random(opps);
+            refreshCombatants(defendingOpponent);
+        }
+
         final boolean bAssault = doAssault();
 
         // Determine who will be attacked
         GameEntity defender = chooseDefender(combat, bAssault);
+
+        // decided to attack another defender so related lists need to be updated
+        // (though usually rather try to avoid this situation for performance reasons)
         if (defender != defendingOpponent) {
-            refreshAttackers(defender);
+            defendingOpponent = defender instanceof Player ? (Player) defender : ((Card)defender).getController();
+            refreshCombatants(defender);
         }
         if (this.attackers.isEmpty()) {
             return aiAggression;
@@ -775,10 +806,7 @@ public class AiAttackController {
         if (!nextTurn) {
             for (final Card attacker : this.attackers) {
                 GameEntity mustAttackDef = null;
-                if (attacker.isGoaded()) {
-                    // TODO this might result into trying to attack the wrong player
-                    mustAttackDef = defender;
-                } else if (attacker.getSVar("MustAttack").equals("True")) {
+                if (attacker.getSVar("MustAttack").equals("True")) {
                     mustAttackDef = defender;
                 } else if (attacker.hasSVar("EndOfTurnLeavePlay")
                         && isEffectiveAttacker(ai, attacker, combat, defender)) {
@@ -787,24 +815,43 @@ public class AiAttackController {
                     //TODO: if there are other ways to tap this creature (like mana creature), then don't need to attack
                     mustAttackDef = defender;
                 } else {
-                    final List<GameEntity> attackRequirements = StaticAbilityMustAttack.entitiesMustAttack(attacker);
-                    if (attackRequirements.contains(attacker)) {
-                        // TODO add cost check here and switch defender if there's one without a cost
-                        // must attack anything
-                        mustAttackDef = defender;
-                        // next check if there's also a specific defender to attack, so don't count them
-                        attackRequirements.removeAll(new CardCollection(attacker));
-                    }
-                    final MapToAmount<GameEntity> amounts = new LinkedHashMapToAmount<>();
-                    amounts.addAll(attackRequirements);
-                    while (!amounts.isEmpty()) {
-                        // check defenders in order of maximum requirements
-                        GameEntity mustAttackDefMaybe = MapToAmountUtil.max(amounts).getKey();
+                    if (combat.getAttackConstraints().getRequirements().get(attacker) == null) continue;
+                    // check defenders in order of maximum requirements
+                    List<Pair<GameEntity, Integer>> reqs = combat.getAttackConstraints().getRequirements().get(attacker).getSortedRequirements();
+                    final GameEntity def = defender;
+                    Collections.sort(reqs, new Comparator<Pair<GameEntity, Integer>>() {
+                        @Override
+                        public int compare(Pair<GameEntity, Integer> r1, Pair<GameEntity, Integer> r2) {
+                            if (r1.getValue() == r2.getValue()) {
+                                // try to attack the designated defender
+                                if (r1.getKey().equals(def) && !r2.getKey().equals(def)) {
+                                    return -1;
+                                }
+                                if (r2.getKey().equals(def) && !r1.getKey().equals(def)) {
+                                    return 1;    
+                                }
+                                // otherwise PW
+                                if (r1.getKey() instanceof Card && r2.getKey() instanceof Player) {
+                                    return -1;
+                                }
+                                if (r2.getKey() instanceof Card && r1.getKey() instanceof Player) {
+                                    return 1;
+                                }
+                                // or weakest player
+                                if (r1.getKey() instanceof Player && r2.getKey() instanceof Player) {
+                                    return ((Player) r1.getKey()).getLife() - ((Player) r2.getKey()).getLife();
+                                }
+                            }
+                            return r2.getValue() - r1.getValue();
+                        }
+                    });
+                    for (Pair<GameEntity, Integer> e : reqs) {
+                        if (e.getRight() == 0) continue;
+                        GameEntity mustAttackDefMaybe = e.getLeft();
                         if (canAttackWrapper(attacker, mustAttackDefMaybe) && CombatUtil.getAttackCost(ai.getGame(), attacker, mustAttackDefMaybe) == null) {
                             mustAttackDef = mustAttackDefMaybe;
                             break;
                         }
-                        amounts.remove(mustAttackDefMaybe);
                     }
                 }
                 if (mustAttackDef != null) {
@@ -836,6 +883,7 @@ public class AiAttackController {
                 if (attackMax != -1 && combat.getAttackers().size() >= attackMax)
                     return aiAggression;
 
+                // TODO if lifeInDanger use chance to hold back some
                 if (canAttackWrapper(attacker, defender) && isEffectiveAttacker(ai, attacker, combat, defender)) {
                     combat.addAttacker(attacker, defender);
                 }
@@ -845,7 +893,7 @@ public class AiAttackController {
         }
 
         // Cards that are remembered to attack anyway (e.g. temporarily stolen creatures)
-        if (ai.getController() instanceof PlayerControllerAi) {
+        if (ai.getController().isAI()) {
             // Only do this if |ai| is actually an AI - as we could be trying to predict how the human will attack.
             for (Card attacker : this.attackers) {
                 if (AiCardMemory.isRememberedCard(ai, attacker, AiCardMemory.MemorySet.MANDATORY_ATTACKERS)) {
@@ -891,7 +939,7 @@ public class AiAttackController {
             aiAggression = 6;
             for (Card attacker : this.attackers) {
                 // reached max, breakup
-                if (attackMax != -1 && combat.getAttackers().size() >= attackMax)
+                if (combat.getAttackers().size() >= attackMax)
                     break;
                 if (canAttackWrapper(attacker, defender) && shouldAttack(attacker, this.blockers, combat, defender)) {
                     combat.addAttacker(attacker, defender);
@@ -926,8 +974,6 @@ public class AiAttackController {
         final List<Card> nextTurnAttackers = new ArrayList<>();
         int candidateCounterAttackDamage = 0;
 
-        final Player opp = defender instanceof Player ? (Player) defender : ((Card)defender).getController();
-        this.oppList = getOpponentCreatures(opp);
         // get the potential damage and strength of the AI forces
         final List<Card> candidateAttackers = new ArrayList<>();
         int candidateUnblockedDamage = 0;
@@ -936,7 +982,7 @@ public class AiAttackController {
             // turn, assume summoning sickness creatures will be able to
             if (ComputerUtilCombat.canAttackNextTurn(pCard) && pCard.getNetCombatDamage() > 0) {
                 candidateAttackers.add(pCard);
-                candidateUnblockedDamage += ComputerUtilCombat.damageIfUnblocked(pCard, opp, null, false);
+                candidateUnblockedDamage += ComputerUtilCombat.damageIfUnblocked(pCard, defendingOpponent, null, false);
                 computerForces++;
             }
         }
@@ -978,7 +1024,7 @@ public class AiAttackController {
         // find the potential damage ratio the AI can cause
         double humanLifeToDamageRatio = 1000000;
         if (candidateUnblockedDamage > 0) {
-            humanLifeToDamageRatio = (double) (opp.getLife() - ComputerUtil.possibleNonCombatDamage(ai, opp)) / candidateUnblockedDamage;
+            humanLifeToDamageRatio = (double) (defendingOpponent.getLife() - ComputerUtil.possibleNonCombatDamage(ai, defendingOpponent)) / candidateUnblockedDamage;
         }
 
         // determine if the ai outnumbers the player
@@ -1003,7 +1049,7 @@ public class AiAttackController {
         // get list of attackers ordered from low power to high
         CardLists.sortByPowerAsc(this.attackers);
         // get player life total
-        int humanLife = opp.getLife();
+        int humanLife = defendingOpponent.getLife();
         // get the list of attackers up to the first blocked one
         final List<Card> attritionalAttackers = new ArrayList<>();
         for (int x = 0; x < (this.attackers.size() - humanForces); x++) {
@@ -1053,7 +1099,7 @@ public class AiAttackController {
                 }
             }
             if (isUnblockableCreature) {
-                unblockableDamage += ComputerUtilCombat.damageIfUnblocked(attacker, opp, combat, false);
+                unblockableDamage += ComputerUtilCombat.damageIfUnblocked(attacker, defendingOpponent, combat, false);
             }
         }
         for (final Card attacker : nextTurnAttackers) {
@@ -1067,13 +1113,13 @@ public class AiAttackController {
                 }
             }
             if (isUnblockableCreature) {
-                nextUnblockableDamage += ComputerUtilCombat.damageIfUnblocked(attacker, opp, null, false);
+                nextUnblockableDamage += ComputerUtilCombat.damageIfUnblocked(attacker, defendingOpponent, null, false);
             }
         }
-        if (unblockableDamage > 0 && !opp.cantLoseForZeroOrLessLife() && opp.canLoseLife()) {
-            turnsUntilDeathByUnblockable = 1 + (opp.getLife() - unblockableDamage) / nextUnblockableDamage;
+        if (unblockableDamage > 0 && !defendingOpponent.cantLoseForZeroOrLessLife() && defendingOpponent.canLoseLife()) {
+            turnsUntilDeathByUnblockable = 1 + (defendingOpponent.getLife() - unblockableDamage) / nextUnblockableDamage;
         }
-        if (opp.canLoseLife()) {
+        if (defendingOpponent.canLoseLife()) {
             doUnblockableAttack = true;
         }
         // *****************
@@ -1130,8 +1176,8 @@ public class AiAttackController {
         if ( LOG_AI_ATTACKS )
             System.out.println("attackersLeft = " + attackersLeft);
 
-        FCollection<GameEntity> possibleDefenders = new FCollection<>(opp);
-        possibleDefenders.addAll(opp.getPlaneswalkersInPlay());
+        FCollection<GameEntity> possibleDefenders = new FCollection<>(defendingOpponent);
+        possibleDefenders.addAll(defendingOpponent.getPlaneswalkersInPlay());
 
         while (!attackersLeft.isEmpty()) {
             CardCollection attackersAssigned = new CardCollection();
@@ -1180,7 +1226,7 @@ public class AiAttackController {
             if (pwDefending.isEmpty()) {
                 // TODO for now only looks at same player as we'd have to check the others from start too
                 //defender = new PlayerCollection(Iterables.filter(possibleDefenders, Player.class)).min(PlayerPredicates.compareByLife());
-                defender = opp;
+                defender = defendingOpponent;
             } else {
                 final Card pwNearUlti = ComputerUtilCard.getBestPlaneswalkerToDamage(pwDefending);
                 defender = pwNearUlti != null ? pwNearUlti : ComputerUtilCard.getBestPlaneswalkerAI(pwDefending);
@@ -1413,16 +1459,30 @@ public class AiAttackController {
             // if card has a Exert Trigger which would target,
             // but there are no creatures it can target, no need to exert with it
             boolean missTarget = false;
-            for (Trigger t : c.getTriggers()) {
-                if (!TriggerType.Exerted.equals(t.getMode())) {
+            for (StaticAbility st : c.getStaticAbilities()) {
+                if (!"OptionalAttackCost".equals(st.getParam("Mode"))) {
                     continue;
                 }
-                SpellAbility sa = t.ensureAbility();
+                SpellAbility sa = st.getPayingTrigSA();
                 if (sa == null) {
-                    continue;
+                    // not the delayed variant
+                    for (Trigger t : c.getTriggers()) {
+                        if (!TriggerType.Exerted.equals(t.getMode())) {
+                            continue;
+                        }
+                        sa = t.ensureAbility();
+                        if (c.getController().isAI()) {
+                            PlayerControllerAi aic = ((PlayerControllerAi) c.getController().getController());
+                            if (!aic.getAi().doTrigger(sa, false)) {
+                                missTarget = true;
+                                break;
+                            }
+                        }
+                    }
+                    break;
                 }
                 if (sa.usesTargeting()) {
-                    sa.setActivatingPlayer(c.getController());
+                    sa.setActivatingPlayer(c.getController(), true);
                     List<Card> validTargets = CardUtil.getValidCardsToTarget(sa.getTargetRestrictions(), sa);
                     if (validTargets.isEmpty()) {
                         missTarget = true;

forge-ai/src/main/java/forge/ai/AiBlockController.java

@@ -42,7 +42,9 @@ import forge.game.cost.Cost;
 import forge.game.keyword.Keyword;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
+import forge.game.staticability.StaticAbilityAssignCombatDamageAsUnblocked;
 import forge.game.staticability.StaticAbilityCantAttackBlock;
+import forge.game.staticability.StaticAbilityMustBlock;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
 import forge.game.zone.ZoneType;
@@ -132,9 +134,10 @@ public class AiBlockController {
         final CardCollection sortedAttackers = new CardCollection();
         CardCollection firstAttacker = new CardCollection();
         final FCollectionView<GameEntity> defenders = combat.getDefenders();
+        final List<Card> attackingCmd = ComputerUtilCombat.getLifeThreateningCommanders(ai, combat);
 
         // If I don't have any planeswalkers then sorting doesn't really matter
-        if (defenders.size() == 1) {
+        if (defenders.size() == 1 || !attackingCmd.isEmpty()) {
             final CardCollection attackers = combat.getAttackersOf(defenders.get(0));
             // Begin with the attackers that pose the biggest threat
             ComputerUtilCard.sortByEvaluateCreature(attackers);
@@ -145,7 +148,14 @@ public class AiBlockController {
                 public int compare(final Card o1, final Card o2) {
                     if (o1.hasSVar("MustBeBlocked") && !o2.hasSVar("MustBeBlocked")) {
                         return -1;
-                    } else if (!o1.hasSVar("MustBeBlocked") && o2.hasSVar("MustBeBlocked")) {
+                    }
+                    if (!o1.hasSVar("MustBeBlocked") && o2.hasSVar("MustBeBlocked")) {
+                        return 1;
+                    }
+                    if (attackingCmd.contains(o1) && !attackingCmd.contains(o2)) {
+                        return -1;
+                    }
+                    if (!attackingCmd.contains(o1) && attackingCmd.contains(o2)) {
                         return 1;
                     }
                     return 0;
@@ -165,14 +175,13 @@ public class AiBlockController {
                 sortedAttackers.addAll(attackers);
             } else if (defender instanceof Player && defender.equals(ai)) {
                 firstAttacker = combat.getAttackersOf(defender);
+                CardLists.sortByPowerDesc(firstAttacker);
             }
         }
 
         if (ComputerUtilCombat.lifeInDanger(ai, combat)) {
             // add creatures attacking the Player to the front of the list
-            for (final Card c : firstAttacker) {
-                sortedAttackers.add(0, c);
-            }
+            sortedAttackers.addAll(0, firstAttacker);
         } else {
             // add creatures attacking the Player to the back of the list
             sortedAttackers.addAll(firstAttacker);
@@ -204,7 +213,7 @@ public class AiBlockController {
                     }
                     blocker = ComputerUtilCard.getWorstCreatureAI(killingBlockers);
                 // 2.Blockers that won't get destroyed
-                } else if (!attacker.hasKeyword("You may have CARDNAME assign its combat damage as though it weren't blocked.")
+                } else if (!StaticAbilityAssignCombatDamageAsUnblocked.assignCombatDamageAsUnblocked(attacker)
                     && !ComputerUtilCombat.attackerHasThreateningAfflict(attacker, ai)) {
                     blocker = ComputerUtilCard.getWorstCreatureAI(safeBlockers);
                     // check whether it's better to block a creature without trample to absorb more damage
@@ -215,7 +224,7 @@ public class AiBlockController {
                                     || other.hasKeyword(Keyword.TRAMPLE)
                                     || ComputerUtilCombat.attackerHasThreateningAfflict(other, ai)
                                     || ComputerUtilCombat.canDestroyBlocker(ai, blocker, other, combat, false)
-                                    || other.hasKeyword("You may have CARDNAME assign its combat damage as though it weren't blocked.")) {
+                                    || StaticAbilityAssignCombatDamageAsUnblocked.assignCombatDamageAsUnblocked(other)) {
                                 continue;
                             }
 
@@ -343,7 +352,7 @@ public class AiBlockController {
                             if (ab.getApi() == ApiType.Pump && "Self".equals(ab.getParam("Defined"))) {
                                 String rawP = ab.getParam("NumAtt");
                                 String rawT = ab.getParam("NumDef");
-                                if ("+X".equals(rawP) && "+X".equals(rawT) && "TriggerCount$NumBlockers".equals(card.getSVar("X"))) {
+                                if ("+X".equals(rawP) && "+X".equals(rawT) && card.getSVar("X").startsWith("Count$Valid Creature.blockingTriggeredAttacker")) {
                                     return true;
                                 }
                                 // TODO: maybe also predict calculated bonus above certain threshold?
@@ -632,7 +641,7 @@ public class AiBlockController {
                 final Card blocker = ComputerUtilCard.getWorstCreatureAI(killingBlockers);
                 boolean doTrade = false;
 
-                if (ComputerUtilCombat.lifeInDanger(ai, combat)) {
+                if (lifeInDanger && ComputerUtilCombat.lifeInDanger(ai, combat)) {
                     // Always trade when life in danger
                     doTrade = true;
                 } else {
@@ -646,7 +655,7 @@ public class AiBlockController {
                 }
             }
         }
-        attackersLeft = new ArrayList<>(currentAttackers);
+        attackersLeft = currentAttackers;
     }
 
     // Chump Blocks (should only be made if life is in danger)
@@ -655,20 +664,24 @@ public class AiBlockController {
 
         makeChumpBlocks(combat, currentAttackers);
 
-        if (ComputerUtilCombat.lifeInDanger(ai, combat)) {
+        if (lifeInDanger) {
             makeMultiChumpBlocks(combat);
         }
     }
 
     private void makeChumpBlocks(final Combat combat, List<Card> attackers) {
-        if (attackers.isEmpty() || !ComputerUtilCombat.lifeInDanger(ai, combat)) {
+        if (!ComputerUtilCombat.lifeInDanger(ai, combat)) {
+            lifeInDanger = false;
+            return;
+        }
+        if (attackers.isEmpty()) {
             return;
         }
 
         Card attacker = attackers.get(0);
 
         if (CombatUtil.getMinNumBlockersForAttacker(attacker, combat.getDefenderPlayerByAttacker(attacker)) > 1
-            || attacker.hasKeyword("You may have CARDNAME assign its combat damage as though it weren't blocked.")
+            || StaticAbilityAssignCombatDamageAsUnblocked.assignCombatDamageAsUnblocked(attacker)
             || ComputerUtilCombat.attackerHasThreateningAfflict(attacker, ai)) {
             attackers.remove(0);
             makeChumpBlocks(combat, attackers);
@@ -689,7 +702,7 @@ public class AiBlockController {
                         }
                         if (other.getNetCombatDamage() >= damageAbsorbed
                                 && !other.hasKeyword(Keyword.TRAMPLE)
-                                && !other.hasKeyword("You may have CARDNAME assign its combat damage as though it weren't blocked.")
+                                && !StaticAbilityAssignCombatDamageAsUnblocked.assignCombatDamageAsUnblocked(other)
                                 && !ComputerUtilCombat.attackerHasThreateningAfflict(other, ai)
                                 && CombatUtil.canBlock(other, blocker, combat)) {
                             combat.addBlocker(other, blocker);
@@ -756,7 +769,7 @@ public class AiBlockController {
 
         for (final Card attacker : tramplingAttackers) {
             if (CombatUtil.getMinNumBlockersForAttacker(attacker, combat.getDefenderPlayerByAttacker(attacker)) > combat.getBlockers(attacker).size()
-                    || attacker.hasKeyword("You may have CARDNAME assign its combat damage as though it weren't blocked.")
+                    || StaticAbilityAssignCombatDamageAsUnblocked.assignCombatDamageAsUnblocked(attacker)
                     || attacker.hasKeyword("CARDNAME can't be blocked unless all creatures defending player controls block it.")) {
                 continue;
             }
@@ -847,9 +860,8 @@ public class AiBlockController {
     }
 
     private void makeChumpBlocksToSavePW(Combat combat) {
-        if (ai.getLife() <= ai.getStartingLife() / 5 || ComputerUtilCombat.lifeInDanger(ai, combat)) {
-            // most likely not worth trying to protect planeswalkers when at threateningly low life or in
-            // dangerous combat which threatens lethal or severe damage to face
+        if (lifeInDanger) {
+            // most likely not worth trying to protect planeswalkers when at threateningly low life
             return;
         }
 
@@ -945,6 +957,40 @@ public class AiBlockController {
         }
     }
 
+    private void makeRequiredBlocks(Combat combat) {
+        // assign blockers that have to block
+        final CardCollection chumpBlockers = new CardCollection();
+        // if an attacker with lure attacks - all that can block
+        for (final Card blocker : blockersLeft) {
+            if (CombatUtil.mustBlockAnAttacker(blocker, combat, null) ||
+                    StaticAbilityMustBlock.blocksEachCombatIfAble(blocker)) {
+                chumpBlockers.add(blocker);
+            }
+        }
+        if (!chumpBlockers.isEmpty()) {
+            for (final Card attacker : attackers) {
+                List<Card> blockers = getPossibleBlockers(combat, attacker, chumpBlockers, false);
+                for (final Card blocker : blockers) {
+                    if (CombatUtil.canBlock(attacker, blocker, combat) && blockersLeft.contains(blocker)
+                            && (CombatUtil.mustBlockAnAttacker(blocker, combat, null)
+                                    || StaticAbilityMustBlock.blocksEachCombatIfAble(blocker))) {
+                        combat.addBlocker(attacker, blocker);
+                        if (!blocker.getMustBlockCards().isEmpty()) {
+                            int mustBlockAmt = blocker.getMustBlockCards().size();
+                            final CardCollectionView blockedSoFar = combat.getAttackersBlockedBy(blocker);
+                            boolean canBlockAnother = CombatUtil.canBlockMoreCreatures(blocker, blockedSoFar);
+                            if (!canBlockAnother || mustBlockAmt == blockedSoFar.size()) {
+                                blockersLeft.remove(blocker);
+                            }
+                        } else {
+                            blockersLeft.remove(blocker);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     private void clearBlockers(final Combat combat, final List<Card> possibleBlockers) {
         for (final Card blocker : CardLists.filterControlledBy(combat.getAllBlockers(), ai)) {
             // don't touch other player's blockers
@@ -1008,9 +1054,6 @@ public class AiBlockController {
 
         clearBlockers(combat, possibleBlockers);
 
-        List<Card> blockers;
-        List<Card> chumpBlockers;
-
         diff = (ai.getLife() * 2) - 5; // This is the minimal gain for an unnecessary trade
         if (ai.getController().isAI() && diff > 0 && ((PlayerControllerAi) ai.getController()).getAi().getBooleanProperty(AiProps.PLAY_AGGRO)) {
             diff = 0;
@@ -1018,7 +1061,7 @@ public class AiBlockController {
 
         // remove all attackers that can't be blocked anyway
         for (final Card a : attackers) {
-            if (!CombatUtil.canBeBlocked(a, ai)) {
+            if (!CombatUtil.canBeBlocked(a, null, ai)) { // pass null to skip redundant checks for performance
                 attackersLeft.remove(a);
             }
         }
@@ -1047,11 +1090,10 @@ public class AiBlockController {
             makeTradeBlocks(combat); // choose necessary trade blocks
 
             // if life is still in danger
-            if (lifeInDanger && ComputerUtilCombat.lifeInDanger(ai, combat)) {
+            if (lifeInDanger) {
                 makeChumpBlocks(combat); // choose necessary chump blocks
-            } else {
-                lifeInDanger = false;
             }
+
             // Reinforce blockers blocking attackers with trample if life is still in danger
             if (lifeInDanger && ComputerUtilCombat.lifeInDanger(ai, combat)) {
                 reinforceBlockersAgainstTrample(combat);
@@ -1065,25 +1107,23 @@ public class AiBlockController {
             }
 
             // TODO could be made more accurate if this would be inside each blocker choosing loop instead
-            lifeInDanger |= removeUnpayableBlocks(combat);
+            lifeInDanger |= removeUnpayableBlocks(combat) && ComputerUtilCombat.lifeInDanger(ai, combat);
 
             // == 2. If the AI life would still be in danger make a safer approach ==
-            if (lifeInDanger && ComputerUtilCombat.lifeInDanger(ai, combat)) {
+            if (lifeInDanger) {
                 clearBlockers(combat, possibleBlockers); // reset every block assignment
                 makeTradeBlocks(combat); // choose necessary trade blocks
                 makeGoodBlocks(combat);
                 // choose necessary chump blocks if life is still in danger
-                if (ComputerUtilCombat.lifeInDanger(ai, combat)) {
-                    makeChumpBlocks(combat);
-                } else {
-                    lifeInDanger = false;
-                }
+                makeChumpBlocks(combat);
+
                 // Reinforce blockers blocking attackers with trample if life is still in danger
                 if (lifeInDanger && ComputerUtilCombat.lifeInDanger(ai, combat)) {
                     reinforceBlockersAgainstTrample(combat);
                 } else {
                     lifeInDanger = false;
                 }
+
                 makeGangBlocks(combat);
                 reinforceBlockersToKill(combat);
             }
@@ -1092,51 +1132,31 @@ public class AiBlockController {
             if (lifeInDanger && ComputerUtilCombat.lifeInSeriousDanger(ai, combat)) {
                 clearBlockers(combat, possibleBlockers);
                 makeChumpBlocks(combat);
-                if (ComputerUtilCombat.lifeInDanger(ai, combat)) {
+
+                if (lifeInDanger && ComputerUtilCombat.lifeInDanger(ai, combat)) {
                     makeTradeBlocks(combat);
+                } else {
+                    lifeInDanger = false;
                 }
 
-                if (!ComputerUtilCombat.lifeInDanger(ai, combat)) {
-                    makeGoodBlocks(combat);
-                } else {
+                if (lifeInDanger && ComputerUtilCombat.lifeInDanger(ai, combat)) {
                     reinforceBlockersAgainstTrample(combat);
+                } else {
+                    lifeInDanger = false;
                 }
+
+                if (!lifeInDanger) {
+                    makeGoodBlocks(combat);
+                }
+
                 makeGangBlocks(combat);
                 reinforceBlockersToKill(combat);
             }
         }
 
-        // assign blockers that have to block
-        chumpBlockers = CardLists.getKeyword(blockersLeft, "CARDNAME blocks each combat if able.");
-        // if an attacker with lure attacks - all that can block
-        for (final Card blocker : blockersLeft) {
-            if (CombatUtil.mustBlockAnAttacker(blocker, combat, null)) {
-                chumpBlockers.add(blocker);
-            }
-        }
-        if (!chumpBlockers.isEmpty()) {
-            CardLists.shuffle(attackers);
-            for (final Card attacker : attackers) {
-                blockers = getPossibleBlockers(combat, attacker, chumpBlockers, false);
-                for (final Card blocker : blockers) {
-                    if (CombatUtil.canBlock(attacker, blocker, combat) && blockersLeft.contains(blocker)
-                            && (CombatUtil.mustBlockAnAttacker(blocker, combat, null)
-                                    || blocker.hasKeyword("CARDNAME blocks each combat if able."))) {
-                        combat.addBlocker(attacker, blocker);
-                        if (!blocker.getMustBlockCards().isEmpty()) {
-                            int mustBlockAmt = blocker.getMustBlockCards().size();
-                            final CardCollectionView blockedSoFar = combat.getAttackersBlockedBy(blocker);
-                            boolean canBlockAnother = CombatUtil.canBlockMoreCreatures(blocker, blockedSoFar);
-                            if (!canBlockAnother || mustBlockAmt == blockedSoFar.size()) {
-                                blockersLeft.remove(blocker);
-                            }
-                        } else {
-                            blockersLeft.remove(blocker);
-                        }
-                    }
-                }
-            }
-        }
+        // block requirements
+        // TODO because this isn't done earlier, sometimes a good block will enforce a restriction that prevents another for the requirement
+        makeRequiredBlocks(combat);
 
         // check to see if it's possible to defend a Planeswalker under attack with a chump block,
         // unless life is low enough to be more worried about saving preserving the life total
@@ -1186,8 +1206,7 @@ public class AiBlockController {
      * Orders a blocker that put onto the battlefield blocking. Depends heavily
      * on the implementation of orderBlockers().
      */
-    public static CardCollection orderBlocker(final Card attacker, final Card blocker,
-            final CardCollection oldBlockers) {
+    public static CardCollection orderBlocker(final Card attacker, final Card blocker, final CardCollection oldBlockers) {
         // add blocker to existing ordering
         // sort by evaluate, then insert it appropriately
         // relies on current implementation of orderBlockers()
@@ -1318,7 +1337,7 @@ public class AiBlockController {
         }
 
         int evalBlk;
-        if (blocker.isFaceDown() && blocker.getView().canFaceDownBeShownTo(ai.getView(), false) && blocker.getState(CardStateName.Original).getType().isCreature()) {
+        if (blocker.isFaceDown() && blocker.getView().canFaceDownBeShownTo(ai.getView()) && blocker.getState(CardStateName.Original).getType().isCreature()) {
             // if the blocker is a face-down creature (e.g. cast via Morph, Manifest), evaluate it
             // in relation to the original state, not to the Morph state
             evalBlk = ComputerUtilCard.evaluateCreature(Card.fromPaperCard(blocker.getPaperCard(), ai), false, true);

forge-ai/src/main/java/forge/ai/AiController.java

@@ -6,12 +6,12 @@
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
@@ -27,6 +27,7 @@ import forge.ai.ability.ExploreAi;
 import forge.ai.ability.LearnAi;
 import forge.ai.simulation.SpellAbilityPicker;
 import forge.card.CardStateName;
+import forge.card.CardType;
 import forge.card.MagicColor;
 import forge.card.mana.ManaCost;
 import forge.deck.Deck;
@@ -53,6 +54,7 @@ import forge.game.replacement.ReplacementLayer;
 import forge.game.replacement.ReplacementType;
 import forge.game.spellability.*;
 import forge.game.staticability.StaticAbility;
+import forge.game.staticability.StaticAbilityDisableTriggers;
 import forge.game.staticability.StaticAbilityMustTarget;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
@@ -73,7 +75,7 @@ import java.util.*;
  * <p>
  * AiController class.
  * </p>
- * 
+ *
  * @author Forge
  * @version $Id$
  */
@@ -88,6 +90,13 @@ public class AiController {
     private SpellAbilityPicker simPicker;
     private int lastAttackAggression;
 
+    public AiController(final Player computerPlayer, final Game game0) {
+        player = computerPlayer;
+        game = game0;
+        memory = new AiCardMemory();
+        simPicker = new SpellAbilityPicker(game, player);
+    }
+
     public boolean canCheatShuffle() {
         return cheatShuffle;
     }
@@ -99,6 +108,7 @@ public class AiController {
     public boolean usesSimulation() {
         return this.useSimulation;
     }
+
     public void setUseSimulation(boolean value) {
         this.useSimulation = value;
     }
@@ -141,17 +151,10 @@ public class AiController {
         return predictedCombatNextTurn;
     }
 
-    public AiController(final Player computerPlayer, final Game game0) {
-        player = computerPlayer;
-        game = game0;
-        memory = new AiCardMemory();
-        simPicker = new SpellAbilityPicker(game, player);
-    }
-
     private List<SpellAbility> getPossibleETBCounters() {
         CardCollection all = new CardCollection(player.getCardsIn(ZoneType.Hand));
         CardCollectionView ccvPlayerLibrary = player.getCardsIn(ZoneType.Library);
-        
+
         all.addAll(player.getCardsIn(ZoneType.Exile));
         all.addAll(player.getCardsIn(ZoneType.Graveyard));
         if (!ccvPlayerLibrary.isEmpty()) {
@@ -164,7 +167,7 @@ public class AiController {
         for (final Card c : all) {
             for (final SpellAbility sa : c.getNonManaAbilities()) {
                 if (sa instanceof SpellPermanent) {
-                    sa.setActivatingPlayer(player);
+                    sa.setActivatingPlayer(player, true);
                     if (checkETBEffects(c, sa, ApiType.Counter)) {
                         spellAbilities.add(sa);
                     }
@@ -173,7 +176,7 @@ public class AiController {
         }
         return spellAbilities;
     }
-    
+
     // look for cards on the battlefield that should prevent the AI from using that spellability
     private boolean checkCurseEffects(final SpellAbility sa) {
         CardCollectionView ccvGameBattlefield = CardLists.filter(game.getCardsIn(ZoneType.Battlefield), CardPredicates.hasSVar("AICurseEffect"));
@@ -192,7 +195,7 @@ public class AiController {
                 } else if ("ChaliceOfTheVoid".equals(curse) && sa.isSpell() && CardFactoryUtil.isCounterable(host)
                         && host.getCMC() == c.getCounters(CounterEnumType.CHARGE)) {
                     return true;
-                }  else if ("BazaarOfWonders".equals(curse) && sa.isSpell() && CardFactoryUtil.isCounterable(host)) {
+                } else if ("BazaarOfWonders".equals(curse) && sa.isSpell() && CardFactoryUtil.isCounterable(host)) {
                     String hostName = host.getName();
                     for (Card card : ccvGameBattlefield) {
                         if (!card.isToken() && card.sharesNameWith(host)) {
@@ -209,10 +212,15 @@ public class AiController {
     }
 
     public boolean checkETBEffects(final Card card, final SpellAbility sa, final ApiType api) {
-        final Player activatingPlayer = sa.getActivatingPlayer();
-
         // for xPaid stuff
         card.setCastSA(sa);
+        boolean result = checkETBEffectsPreparedCard(card, sa, api);
+        card.setCastSA(null);
+        return result;
+    }
+
+    private boolean checkETBEffectsPreparedCard(final Card card, final SpellAbility sa, final ApiType api) {
+        final Player activator = sa.getActivatingPlayer();
 
         // Replacement effects
         for (final ReplacementEffect re : card.getReplacementEffects()) {
@@ -230,7 +238,7 @@ public class AiController {
                 if (!validCard.contains("Self")) {
                     continue;
                 }
-                if (validCard.contains("notkicked")) {
+                if (validCard.contains("!kicked")) {
                     if (sa.isKicked()) {
                         continue;
                     }
@@ -251,7 +259,7 @@ public class AiController {
             SpellAbility exSA = re.getOverridingAbility();
 
             if (exSA != null) {
-                exSA = exSA.copy(activatingPlayer);
+                exSA = exSA.copy(activator);
 
                 // ETBReplacement uses overriding abilities.
                 // These checks only work if the Executing SpellAbility is an Ability_Sub.
@@ -261,11 +269,6 @@ public class AiController {
             }
         }
 
-        if (card.isCreature()
-                && game.getStaticEffects().getGlobalRuleChange(GlobalRuleChange.noCreatureETBTriggers)) {
-            return api == null;
-        }
-
         boolean rightapi = false;
 
         // Trigger play improvements
@@ -280,12 +283,18 @@ public class AiController {
                 continue;
             }
 
+            final Map<AbilityKey, Object> runParams = AbilityKey.mapFromCard(tr.getHostCard());
+            runParams.put(AbilityKey.Destination, ZoneType.Battlefield.name());
+            if (StaticAbilityDisableTriggers.disabled(game, tr, runParams)) {
+                return api == null;
+            }
+
             if (tr.hasParam("ValidCard")) {
                 String validCard = tr.getParam("ValidCard");
                 if (!validCard.contains("Self")) {
                     continue;
                 }
-                if (validCard.contains("notkicked")) {
+                if (validCard.contains("!kicked")) {
                     if (sa.isKicked()) {
                         continue;
                     }
@@ -294,7 +303,7 @@ public class AiController {
                         String s = validCard.split("kicked ")[1];
                         if ("1".equals(s) && !sa.isOptionalCostPaid(OptionalCost.Kicker1)) continue;
                         if ("2".equals(s) && !sa.isOptionalCostPaid(OptionalCost.Kicker2)) continue;
-                    } else if (!sa.isKicked()) { 
+                    } else if (!sa.isKicked()) {
                         continue;
                     }
                 }
@@ -309,17 +318,15 @@ public class AiController {
                 continue;
             }
 
-            SpellAbility exSA = tr.ensureAbility().copy(activatingPlayer);
+            SpellAbility exSA = tr.ensureAbility().copy(activator);
 
             if (api != null) {
                 if (exSA.getApi() != api) {
                     continue;
                 }
                 rightapi = true;
-                if (!(exSA instanceof AbilitySub)) {
-                    if (!ComputerUtilCost.canPayCost(exSA, player, true)) {
-                        return false;
-                    }
+                if (!(exSA instanceof AbilitySub) && !ComputerUtilCost.canPayCost(exSA, player, true)) {
+                    return false;
                 }
             }
 
@@ -341,13 +348,38 @@ public class AiController {
             if (exSA instanceof AbilitySub && !doTrigger(exSA, false)) {
                 // AI would not run this trigger if given the chance
                 if (api == null && card.isCreature() && !ComputerUtilAbility.isFullyTargetable(exSA) &&
-                        (ComputerUtil.aiLifeInDanger(activatingPlayer, true, 0) || "BadETB".equals(tr.getParam("AILogic")))) {
+                        (ComputerUtil.aiLifeInDanger(activator, true, 0) || "BadETB".equals(tr.getParam("AILogic")))) {
                     // trigger will not run due to lack of targets and we 1. desperately need a creature or 2. are happy about that
                     continue;
                 }
                 return false;
             }
         }
+
+        for (final Trigger tr : card.getTriggers()) {
+            if (!card.hasStartOfKeyword("Saga") && !card.hasStartOfKeyword("Read ahead")) {
+                break;
+            }
+
+            if (tr.getMode() != TriggerType.CounterAdded) {
+                continue;
+            }
+
+            SpellAbility exSA = tr.ensureAbility().copy(activator);
+
+            if (api != null && exSA.getApi() == api) {
+                rightapi = true;
+            }
+
+            if (exSA instanceof AbilitySub && !doTrigger(exSA, false)) {
+                // AI would not run this chapter if given the chance
+                // TODO eventually we'll want to consider playing it anyway, especially if Read ahead would still allow an immediate benefit
+                return false;
+            }
+
+            break;
+        }
+
         if (api != null && !rightapi) {
             return false;
         }
@@ -369,7 +401,7 @@ public class AiController {
     }
 
     private CardCollection filterLandsToPlay(CardCollection landList) {
-        final CardCollection hand = new CardCollection(player.getCardsIn(ZoneType.Hand));
+        final CardCollectionView hand = player.getCardsIn(ZoneType.Hand);
         CardCollection nonLandList = CardLists.filter(hand, Predicates.not(CardPredicates.Presets.LANDS));
         if (landList.size() == 1 && nonLandList.size() < 3) {
             CardCollectionView cardsInPlay = player.getCardsIn(ZoneType.Battlefield);
@@ -445,7 +477,7 @@ public class AiController {
         CardCollection nonLandsInHand = CardLists.filter(player.getCardsIn(ZoneType.Hand), Predicates.not(CardPredicates.Presets.LANDS));
 
         // Some considerations for Momir/MoJhoSto
-        boolean hasMomir = player.getZone(ZoneType.Command).contains(CardPredicates.nameEquals("Momir Vig, Simic Visionary Avatar"));
+        boolean hasMomir = player.isCardInCommand("Momir Vig, Simic Visionary Avatar");
         if (hasMomir && nonLandsInHand.isEmpty()) {
             // Only do this if we have an all-basic land hand, which covers both stock Momir and MoJhoSto modes
             // and also a custom Vanguard setup with a customized basic land deck and Momir as the avatar.
@@ -498,7 +530,7 @@ public class AiController {
                     if (reSA == null || !ApiType.Tap.equals(reSA.getApi())) {
                         continue;
                     }
-                    reSA.setActivatingPlayer(reSA.getHostCard().getController());
+                    reSA.setActivatingPlayer(reSA.getHostCard().getController(), true);
                     if (reSA.metConditions()) {
                         foundTapped = true;
                         break;
@@ -569,7 +601,7 @@ public class AiController {
                 landList = CardLists.filter(landList, Predicates.not(CardPredicates.Presets.BASIC_LANDS));
             }
         }
-        return landList.get(0);
+        return ComputerUtilCard.getBestLandToPlayAI(landList);
     }
 
     // if return true, go to next phase
@@ -582,7 +614,7 @@ public class AiController {
 
         for (final SpellAbility sa : ComputerUtilAbility.getOriginalAndAltCostAbilities(possibleCounters, player)) {
             SpellAbility currentSA = sa;
-            sa.setActivatingPlayer(player);
+            sa.setActivatingPlayer(player, true);
             // check everything necessary
 
             AiPlayDecision opinion = canPlayAndPayFor(currentSA);
@@ -595,7 +627,7 @@ public class AiController {
                 } else {
                     // Compare bestSA with this SA
                     final int restrictionLevel = ComputerUtil.counterSpellRestriction(player, currentSA);
-    
+
                     if (restrictionLevel > bestRestriction) {
                         bestRestriction = restrictionLevel;
                         bestSA = currentSA;
@@ -612,20 +644,20 @@ public class AiController {
     public SpellAbility predictSpellToCastInMain2(ApiType exceptSA) {
         return predictSpellToCastInMain2(exceptSA, true);
     }
+
     private SpellAbility predictSpellToCastInMain2(ApiType exceptSA, boolean handOnly) {
         if (!getBooleanProperty(AiProps.PREDICT_SPELLS_FOR_MAIN2)) {
             return null;
         }
 
         final CardCollectionView cards = handOnly ? player.getCardsIn(ZoneType.Hand) :
-            ComputerUtilAbility.getAvailableCards(game, player);
+                ComputerUtilAbility.getAvailableCards(game, player);
 
         List<SpellAbility> all = ComputerUtilAbility.getSpellAbilities(cards, player);
 
         try {
             Collections.sort(all, saComparator); // put best spells first
-        }
-        catch (IllegalArgumentException ex) {
+        } catch (IllegalArgumentException ex) {
             System.err.println(ex.getMessage());
             String assertex = ComparatorUtil.verifyTransitivity(saComparator, all);
             Sentry.captureMessage(ex.getMessage() + "\nAssertionError [verifyTransitivity]: " + assertex);
@@ -633,11 +665,11 @@ public class AiController {
 
         for (final SpellAbility sa : ComputerUtilAbility.getOriginalAndAltCostAbilities(all, player)) {
             ApiType saApi = sa.getApi();
-            
+
             if (saApi == ApiType.Counter || saApi == exceptSA) {
                 continue;
             }
-            sa.setActivatingPlayer(player);
+            sa.setActivatingPlayer(player, true);
             // TODO: this currently only works as a limited prediction of permanent spells.
             // Ideally this should cast canPlaySa to determine that the AI is truly able/willing to cast a spell,
             // but that is currently difficult to implement due to various side effects leading to stack overflow.
@@ -652,12 +684,15 @@ public class AiController {
     public boolean reserveManaSourcesForNextSpell(SpellAbility sa, SpellAbility exceptForSa) {
         return reserveManaSources(sa, null, false, true, exceptForSa);
     }
+
     public boolean reserveManaSources(SpellAbility sa) {
         return reserveManaSources(sa, PhaseType.MAIN2, false, false, null);
     }
+
     public boolean reserveManaSources(SpellAbility sa, PhaseType phaseType, boolean enemy) {
         return reserveManaSources(sa, phaseType, enemy, true, null);
     }
+
     public boolean reserveManaSources(SpellAbility sa, PhaseType phaseType, boolean enemy, boolean forNextSpell, SpellAbility exceptForThisSa) {
         ManaCostBeingPaid cost = ComputerUtilMana.calculateManaCost(sa, true, 0);
         CardCollection manaSources = ComputerUtilMana.getManaSourcesToPayCost(cost, sa, player);
@@ -703,15 +738,34 @@ public class AiController {
         return false;
     }
 
-    // This is for playing spells regularly (no Cascade/Ripple etc.)
     private AiPlayDecision canPlayAndPayFor(final SpellAbility sa) {
         if (!sa.canPlay()) {
             return AiPlayDecision.CantPlaySa;
         }
 
+        final Card host = sa.getHostCard();
+
+        // state needs to be switched here so API checks evaluate the right face
+        CardStateName currentState = sa.getCardState() != null && host.getCurrentStateName() != sa.getCardStateName() && !host.isInPlay() ? host.getCurrentStateName() : null;
+        if (currentState != null) {
+            host.setState(sa.getCardStateName(), false);
+        }
+
+        AiPlayDecision decision = canPlayAndPayForFace(sa);
+
+        if (currentState != null) {
+            host.setState(currentState, false);
+        }
+
+        return decision;
+    }
+    
+    // This is for playing spells regularly (no Cascade/Ripple etc.)
+    private AiPlayDecision canPlayAndPayForFace(final SpellAbility sa) {
+        final Card host = sa.getHostCard();
+
         // Check a predefined condition
         if (sa.hasParam("AICheckSVar")) {
-            final Card host = sa.getHostCard();
             final String svarToCheck = sa.getParam("AICheckSVar");
             String comparator = "GE";
             int compareTo = 1;
@@ -734,7 +788,7 @@ public class AiController {
         }
 
         int oldCMC = -1;
-        boolean xCost = sa.costHasX() || sa.getHostCard().hasStartOfKeyword("Strive");
+        boolean xCost = sa.costHasX() || host.hasStartOfKeyword("Strive");
         if (!xCost) {
             if (!ComputerUtilCost.canPayCost(sa, player, sa.isTrigger())) {
                 // for most costs, it's OK to check if they can be paid early in order to avoid running a heavy API check
@@ -742,34 +796,24 @@ public class AiController {
                 return AiPlayDecision.CantAfford;
             }
             // TODO check for Reduce too, e.g. Battlefield Thaumaturge could make it castable
-            if (sa.usesTargeting()) {
+            if (!sa.getAllTargetChoices().isEmpty()) {
                 oldCMC = CostAdjustment.adjust(sa.getPayCosts(), sa).getTotalMana().getCMC();
             }
         }
 
-        // state needs to be switched here so API checks evaluate the right face
-        CardStateName currentState = sa.getCardState() != null && sa.getHostCard().getCurrentStateName() != sa.getCardStateName() && !sa.getHostCard().isInPlay() ? sa.getHostCard().getCurrentStateName() : null;
-        if (currentState != null) {
-            sa.getHostCard().setState(sa.getCardStateName(), false);
-        }
-
         AiPlayDecision canPlay = canPlaySa(sa); // this is the "heaviest" check, which also sets up targets, defines X, etc.
 
-        if (currentState != null) {
-            sa.getHostCard().setState(currentState, false);
-        }
-
         if (canPlay != AiPlayDecision.WillPlay) {
             return canPlay;
         }
 
         // Account for possible Ward after the spell is fully targeted
         // TODO: ideally, this should be done while targeting, so that a different target can be preferred if the best
-        // one is warded and can't be paid for.
-        if (sa.usesTargeting()) {
+        // one is warded and can't be paid for. (currently it will be stuck with the target until it could pay)
+        if (sa.usesTargeting() && (!sa.isSpell() || CardFactoryUtil.isCounterable(host))) {
             for (Card tgt : sa.getTargets().getTargetCards()) {
                 // TODO some older cards don't use the keyword, so check for trigger instead
-                if (tgt.hasKeyword(Keyword.WARD) && tgt.isInPlay() && tgt.getController().isOpponentOf(sa.getHostCard().getController())) {
+                if (tgt.hasKeyword(Keyword.WARD) && tgt.isInPlay() && tgt.getController().isOpponentOf(host.getController())) {
                     int amount = 0;
                     Cost wardCost = ComputerUtilCard.getTotalWardCost(tgt);
                     if (wardCost.hasManaCost()) {
@@ -778,15 +822,10 @@ public class AiController {
                             return AiPlayDecision.CantAfford;
                         }
                     }
-                    if (wardCost.hasSpecificCostType(CostPayLife.class)) {
-                        int lifeToPay = wardCost.getCostPartByType(CostPayLife.class).convertAmount();
-                        if (lifeToPay > player.getLife() || (lifeToPay == player.getLife() && !player.cantLoseForZeroOrLessLife())) {
-                            return AiPlayDecision.CantAfford;
-                        }
-                    }
-                    if (wardCost.hasSpecificCostType(CostDiscard.class)
-                            && wardCost.getCostPartByType(CostDiscard.class).convertAmount() > player.getCardsIn(ZoneType.Hand).size()) {
-                        return AiPlayDecision.CantAfford;
+                    SpellAbilityAi topAI = new SpellAbilityAi() {
+                    };
+                    if (!topAI.willPayCosts(player, sa, wardCost, host)) {
+                        return AiPlayDecision.CostNotAcceptable;
                     }
                 }
             }
@@ -812,9 +851,6 @@ public class AiController {
     }
 
     public AiPlayDecision canPlaySa(SpellAbility sa) {
-        final Card card = sa.getHostCard();
-        final boolean isRightTiming = sa.canCastTiming(player);
-
         if (!checkAiSpecificRestrictions(sa)) {
             return AiPlayDecision.CantPlayAi;
         }
@@ -822,6 +858,12 @@ public class AiController {
             return canPlaySa(((WrappedAbility) sa).getWrappedAbility());
         }
 
+        if (!sa.canCastTiming(player)) {
+            return AiPlayDecision.AnotherTime;
+        }
+
+        final Card card = sa.getHostCard();
+
         // Trying to play a card that has Buyback without a Buyback cost, look for possible additional considerations
         if (getBooleanProperty(AiProps.TRY_TO_PRESERVE_BUYBACK_SPELLS)) {
             if (card.hasKeyword(Keyword.BUYBACK) && !sa.isBuyBackAbility() && !canPlaySpellWithoutBuyback(card, sa)) {
@@ -888,14 +930,15 @@ public class AiController {
             spellHost.setLastKnownZone(game.getStackZone()); // need to add to stack to make check Restrictions respect stack cmc
             spellHost.setCastFrom(card.getZone());
         }
+        // TODO maybe other location for this?
+        if (!sa.isLegalAfterStack()) {
+            return AiPlayDecision.AnotherTime;
+        }
         if (!sa.checkRestrictions(spellHost, player)) {
             return AiPlayDecision.AnotherTime;
         }
         if (sa instanceof SpellPermanent) {
-            if (!isRightTiming) {
-                return AiPlayDecision.AnotherTime;
-            }
-            return canPlayFromEffectAI((SpellPermanent)sa, false, true);
+            return canPlayFromEffectAI((SpellPermanent) sa, false, true);
         }
         if (sa.usesTargeting()) {
             if (!sa.isTargetNumberValid() && sa.getTargetRestrictions().getNumCandidates(sa, true) == 0) {
@@ -906,18 +949,13 @@ public class AiController {
             }
         }
         if (sa instanceof Spell) {
-            if (ComputerUtil.getDamageForPlaying(player, sa) >= player.getLife() 
-                    && !player.cantLoseForZeroOrLessLife() && player.canLoseLife()) {
+            if (!player.cantLoseForZeroOrLessLife() && player.canLoseLife() &&
+                    ComputerUtil.getDamageForPlaying(player, sa) >= player.getLife()) {
                 return AiPlayDecision.CurseEffects;
             }
-            if (!isRightTiming) {
-                return AiPlayDecision.AnotherTime;
-            }
             return canPlaySpellBasic(card, sa);
         }
-        if (!isRightTiming) {
-            return AiPlayDecision.AnotherTime;
-        }
+
         return AiPlayDecision.WillPlay;
     }
 
@@ -931,21 +969,16 @@ public class AiController {
     }
 
     private boolean canPlaySpellWithoutBuyback(Card card, SpellAbility sa) {
-        boolean wasteBuybackAllowed = false;
-
-        // About to lose game : allow
-        if (ComputerUtil.aiLifeInDanger(player, true, 0)) {
-            wasteBuybackAllowed = true;
-        }
-
         int copies = CardLists.count(player.getCardsIn(ZoneType.Hand), CardPredicates.nameEquals(card.getName()));
         // Have two copies : allow
         if (copies >= 2) {
-            wasteBuybackAllowed = true;
+            return true;
         }
 
-        int neededMana = 0;
-        boolean dangerousRecurringCost = false;
+        // About to lose game : allow
+        if (ComputerUtil.aiLifeInDanger(player, true, 0)) {
+            return true;
+        }
 
         Cost costWithBuyback = sa.getPayCosts().copy();
         for (OptionalCostValue opt : GameActionUtil.getOptionalCostValues(sa)) {
@@ -953,22 +986,19 @@ public class AiController {
                 costWithBuyback.add(opt.getCost());
             }
         }
-        CostAdjustment.adjust(costWithBuyback, sa);
-        if (costWithBuyback.getCostMana() != null) {
-            neededMana = costWithBuyback.getCostMana().getMana().getCMC();
-        }
+        costWithBuyback = CostAdjustment.adjust(costWithBuyback, sa);
         if (costWithBuyback.hasSpecificCostType(CostPayLife.class)
                 || costWithBuyback.hasSpecificCostType(CostDiscard.class)
                 || costWithBuyback.hasSpecificCostType(CostSacrifice.class)) {
-            dangerousRecurringCost = true;
+            // won't be able to afford buyback any time soon
+            // if Buyback cost includes sacrifice, life, discard
+            return true;
         }
 
-        // won't be able to afford buyback any time soon
-        // if Buyback cost includes sacrifice, life, discard
-        if (dangerousRecurringCost) {
-            wasteBuybackAllowed = true;
+        int neededMana = 0;
+        if (costWithBuyback.getCostMana() != null) {
+            neededMana = costWithBuyback.getCostMana().getMana().getCMC();
         }
-
         // Memory Crystal-like effects need special handling
         for (Card c : game.getCardsIn(ZoneType.Battlefield)) {
             for (StaticAbility s : c.getStaticAbilities()) {
@@ -984,10 +1014,10 @@ public class AiController {
 
         int hasMana = ComputerUtilMana.getAvailableManaEstimate(player, false);
         if (hasMana < neededMana - 1) {
-            wasteBuybackAllowed = true;
+            return true;
         }
 
-        return wasteBuybackAllowed;
+        return false;
     }
 
     // not sure "playing biggest spell" matters?
@@ -1038,7 +1068,7 @@ public class AiController {
             } else if (a1 > 0 && b1 == 0 && ApiType.Mana != b.getApi()) {
                 return 1;
             }
-            
+
             if (a.getHostCard() != null && a.getHostCard().hasSVar("FreeSpellAI")) {
                 return -1;
             } else if (b.getHostCard() != null && b.getHostCard().hasSVar("FreeSpellAI")) {
@@ -1049,11 +1079,9 @@ public class AiController {
                 // Cheaper Spectacle costs should be preferred
                 // FIXME: Any better way to identify that these are the same ability, one with Spectacle and one not?
                 // (looks like it's not a full-fledged alternative cost as such, and is not processed with other alt costs)
-                if (a.isSpectacle() && !b.isSpectacle()
-                        && a.getPayCosts().getTotalMana().getCMC() < b.getPayCosts().getTotalMana().getCMC()) {
+                if (a.isSpectacle() && !b.isSpectacle() && a1 < b1) {
                     return 1;
-                } else if (b.isSpectacle() && !a.isSpectacle()
-                        && b.getPayCosts().getTotalMana().getCMC() < a.getPayCosts().getTotalMana().getCMC()) {
+                } else if (b.isSpectacle() && !a.isSpectacle() && b1 < a1) {
                     return 1;
                 }
             }
@@ -1063,7 +1091,7 @@ public class AiController {
 
             return b1 - a1;
         }
-        
+
         private int getSpellAbilityPriority(SpellAbility sa) {
             int p = 0;
             Card source = sa.getHostCard();
@@ -1082,6 +1110,9 @@ public class AiController {
                 if (source.hasSVar("AIPriorityModifier")) {
                     p += Integer.parseInt(source.getSVar("AIPriorityModifier"));
                 }
+                if (ComputerUtilCard.isCardRemAIDeck(sa.getOriginalHost() != null ? sa.getOriginalHost() : source)) {
+                    p -= 10;
+                }
                 // don't play equipments before having any creatures
                 if (source.isEquipment() && noCreatures) {
                     p -= 9;
@@ -1193,7 +1224,9 @@ public class AiController {
                         }
                     }
                     for (Card c : inHand) {
-                        if (c.hasSVar("DoNotDiscardIfAble") || c.hasSVar("IsReanimatorCard")) { continue; }
+                        if (c.hasSVar("DoNotDiscardIfAble") || c.hasSVar("IsReanimatorCard")) {
+                            continue;
+                        }
                         if (c.isCreature() && !ComputerUtilMana.hasEnoughManaSourcesToCast(c.getSpellPermanent(), player)) {
                             discards.add(c);
                         }
@@ -1232,8 +1265,7 @@ public class AiController {
                 discardList.add(prefCard);
                 validCards.remove(prefCard);
                 count++;
-            }
-            else {
+            } else {
                 break;
             }
         }
@@ -1248,16 +1280,15 @@ public class AiController {
             final int numLandsInPlay = CardLists.count(player.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.LANDS_PRODUCING_MANA);
             final CardCollection landsInHand = CardLists.filter(validCards, CardPredicates.Presets.LANDS);
             final int numLandsInHand = landsInHand.size();
-    
+
             // Discard a land
-            boolean canDiscardLands = numLandsInHand > 3  || (numLandsInHand > 2 && numLandsInPlay > 0)
-            || (numLandsInHand > 1 && numLandsInPlay > 2) || (numLandsInHand > 0 && numLandsInPlay > 5);
-    
+            boolean canDiscardLands = numLandsInHand > 3 || (numLandsInHand > 2 && numLandsInPlay > 0)
+                    || (numLandsInHand > 1 && numLandsInPlay > 2) || (numLandsInHand > 0 && numLandsInPlay > 5);
+
             if (canDiscardLands) {
                 discardList.add(landsInHand.get(0));
                 validCards.remove(landsInHand.get(0));
-            }
-            else { // Discard other stuff
+            } else { // Discard other stuff
                 CardLists.sortByCmcDesc(validCards);
                 int numLandsAvailable = numLandsInPlay;
                 if (numLandsInHand > 0) {
@@ -1321,7 +1352,7 @@ public class AiController {
         return discardList;
     }
 
-    public boolean confirmAction(SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+    public boolean confirmAction(SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {
         if (mode == PlayerActionConfirmMode.AlternativeDamageAssignment) {
             return true;
         }
@@ -1334,7 +1365,7 @@ public class AiController {
                     mode);
             throw new IllegalArgumentException(exMsg);
         }
-        return SpellApiToAi.Converter.get(api).confirmAction(player, sa, mode, message);
+        return SpellApiToAi.Converter.get(api).confirmAction(player, sa, mode, message, params);
     }
 
     public boolean confirmBidAction(SpellAbility sa, PlayerActionConfirmMode mode, String message, int bid, Player winner) {
@@ -1346,7 +1377,7 @@ public class AiController {
                 return false;
             default:
                 return false;
-        } 
+        }
         return false;
     }
 
@@ -1404,8 +1435,8 @@ public class AiController {
                 if (!checkETBEffects(card, spell, null)) {
                     return AiPlayDecision.BadEtbEffects;
                 }
-                if (damage + ComputerUtil.getDamageFromETB(player, card) >= player.getLife()
-                        && !player.cantLoseForZeroOrLessLife() && player.canLoseLife()) {
+                if (!player.cantLoseForZeroOrLessLife() && player.canLoseLife()
+                        && damage + ComputerUtil.getDamageFromETB(player, card) >= player.getLife()) {
                     return AiPlayDecision.BadEtbEffects;
                 }
             }
@@ -1448,7 +1479,9 @@ public class AiController {
     }
 
     private List<SpellAbility> singleSpellAbilityList(SpellAbility sa) {
-        if (sa == null) { return null; }
+        if (sa == null) {
+            return null;
+        }
 
         final List<SpellAbility> abilities = Lists.newArrayList();
         abilities.add(sa);
@@ -1469,55 +1502,52 @@ public class AiController {
             return singleSpellAbilityList(simPicker.chooseSpellAbilityToPlay(null));
         }
 
-        CardCollection landsWannaPlay = ComputerUtilAbility.getAvailableLandsToPlay(game, player);
         CardCollection playBeforeLand = CardLists.filter(
-            player.getCardsIn(ZoneType.Hand), CardPredicates.hasSVar("PlayBeforeLandDrop")
+                player.getCardsIn(ZoneType.Hand), CardPredicates.hasSVar("PlayBeforeLandDrop")
         );
-
         if (!playBeforeLand.isEmpty()) {
             SpellAbility wantToPlayBeforeLand = chooseSpellAbilityToPlayFromList(
-                ComputerUtilAbility.getSpellAbilities(playBeforeLand, player), false
+                    ComputerUtilAbility.getSpellAbilities(playBeforeLand, player), false
             );
             if (wantToPlayBeforeLand != null) {
                 return singleSpellAbilityList(wantToPlayBeforeLand);
             }
         }
 
+        CardCollection landsWannaPlay = ComputerUtilAbility.getAvailableLandsToPlay(game, player);
         if (landsWannaPlay != null) {
             landsWannaPlay = filterLandsToPlay(landsWannaPlay);
             Log.debug("Computer " + game.getPhaseHandler().getPhase().nameForUi);
             if (landsWannaPlay != null && !landsWannaPlay.isEmpty()) {
                 // TODO search for other land it might want to play?
                 Card land = chooseBestLandToPlay(landsWannaPlay);
-                if (ComputerUtil.getDamageFromETB(player, land) < player.getLife() || !player.canLoseLife() 
-                        || player.cantLoseForZeroOrLessLife() ) {
-                    if (!game.getPhaseHandler().is(PhaseType.MAIN1) || !isSafeToHoldLandDropForMain2(land)) {
-                        final List<SpellAbility> abilities = Lists.newArrayList();
+                if ((!player.canLoseLife() || player.cantLoseForZeroOrLessLife() || ComputerUtil.getDamageFromETB(player, land) < player.getLife())
+                        && (!game.getPhaseHandler().is(PhaseType.MAIN1) || !isSafeToHoldLandDropForMain2(land))) {
+                    final List<SpellAbility> abilities = Lists.newArrayList();
 
-                        // TODO extend this logic to evaluate MDFC with both sides land
-                        // this can only happen if its a MDFC land
-                        if (!land.isLand()) {
-                            land.setState(CardStateName.Modal, true);
-                            land.setBackSide(true);
-                        }
+                    // TODO extend this logic to evaluate MDFC with both sides land
+                    // this can only happen if its a MDFC land
+                    if (!land.isLand()) {
+                        land.setState(CardStateName.Modal, true);
+                        land.setBackSide(true);
+                    }
 
-                        LandAbility la = new LandAbility(land, player, null);
+                    LandAbility la = new LandAbility(land, player, null);
+                    la.setCardState(land.getCurrentState());
+                    if (la.canPlay()) {
+                        abilities.add(la);
+                    }
+
+                    // add mayPlay option
+                    for (CardPlayOption o : land.mayPlay(player)) {
+                        la = new LandAbility(land, player, o.getAbility());
                         la.setCardState(land.getCurrentState());
                         if (la.canPlay()) {
                             abilities.add(la);
                         }
-
-                        // add mayPlay option
-                        for (CardPlayOption o : land.mayPlay(player)) {
-                            la = new LandAbility(land, player, o.getAbility());
-                            la.setCardState(land.getCurrentState());
-                            if (la.canPlay()) {
-                                abilities.add(la);
-                            }
-                        }
-                        if (!abilities.isEmpty()) {
-                            return abilities;
-                        }
+                    }
+                    if (!abilities.isEmpty()) {
+                        return abilities;
                     }
                 }
             }
@@ -1527,7 +1557,7 @@ public class AiController {
     }
 
     private boolean isSafeToHoldLandDropForMain2(Card landToPlay) {
-        boolean hasMomir = player.getZone(ZoneType.Command).contains(CardPredicates.nameEquals("Momir Vig, Simic Visionary Avatar"));
+        boolean hasMomir = player.isCardInCommand("Momir Vig, Simic Visionary Avatar");
         if (hasMomir) {
             // Don't do this in Momir variants since it messes with the AI decision making for the avatar.
             return false;
@@ -1610,6 +1640,13 @@ public class AiController {
                 }
                 for (String sv : card.getSVars().keySet()) {
                     String varValue = card.getSVar(sv);
+                    if (varValue.equals("Count$Domain")) {
+                        for (String type : landToPlay.getType().getLandTypes()) {
+                            if (CardType.isABasicLandType(type) && CardLists.getType(otb, type).isEmpty()) {
+                                return true;
+                            }
+                        }
+                    }
                     if (varValue.startsWith("Count$Valid") || sv.equals("BuffedBy")) {
                         if (varValue.contains("Land") || varValue.contains("Plains") || varValue.contains("Forest")
                                 || varValue.contains("Mountain") || varValue.contains("Island") || varValue.contains("Swamp")
@@ -1635,11 +1672,14 @@ public class AiController {
             return false;
         }
 
+        // TODO needed to pay propaganda
+
         return true;
     }
 
     private final SpellAbility getSpellAbilityToPlay() {
-        final CardCollection cards = ComputerUtilAbility.getAvailableCards(game, player);
+        CardCollection cards = ComputerUtilAbility.getAvailableCards(game, player);
+        cards = ComputerUtilCard.dedupeCards(cards);
         List<SpellAbility> saList = Lists.newArrayList();
 
         SpellAbility top = null;
@@ -1665,7 +1705,7 @@ public class AiController {
         if (!game.getStack().isEmpty()) {
             SpellAbility counter = chooseCounterSpell(getPlayableCounters(cards));
             if (counter != null) return counter;
-    
+
             SpellAbility counterETB = chooseSpellAbilityToPlayFromList(getPossibleETBCounters(), false);
             if (counterETB != null)
                 return counterETB;
@@ -1677,8 +1717,9 @@ public class AiController {
 
         Iterables.removeIf(saList, new Predicate<SpellAbility>() {
             @Override
-            public boolean apply(final SpellAbility spellAbility) {
-                return spellAbility instanceof LandAbility;
+            public boolean apply(final SpellAbility spellAbility) { //don't include removedAI cards if somehow the AI can play the ability or gain control of unsupported card
+                // TODO allow when experimental profile?
+                return spellAbility instanceof LandAbility || (spellAbility.getHostCard() != null && ComputerUtilCard.isCardRemAIDeck(spellAbility.getHostCard()));
             }
         });
 
@@ -1697,8 +1738,7 @@ public class AiController {
 
         try {
             Collections.sort(all, saComparator); // put best spells first
-        }
-        catch (IllegalArgumentException ex) {
+        } catch (IllegalArgumentException ex) {
             System.err.println(ex.getMessage());
             String assertex = ComparatorUtil.verifyTransitivity(saComparator, all);
             Sentry.captureMessage(ex.getMessage() + "\nAssertionError [verifyTransitivity]: " + assertex);
@@ -1719,7 +1759,7 @@ public class AiController {
                 }
             }
 
-            sa.setActivatingPlayer(player);
+            sa.setActivatingPlayer(player, true);
             SpellAbility root = sa.getRootAbility();
 
             if (root.isSpell() || root.isTrigger() || root.isReplacementAbility()) {
@@ -1747,7 +1787,7 @@ public class AiController {
     public CardCollection chooseCardsToDelve(int genericCost, CardCollection grave) {
         CardCollection toExile = new CardCollection();
         int numToExile = Math.min(grave.size(), genericCost);
-        
+
         for (int i = 0; i < numToExile; i++) {
             Card chosen = null;
             for (final Card c : grave) { // Exile noncreatures first in
@@ -1772,10 +1812,10 @@ public class AiController {
         }
         return toExile;
     }
-    
+
     public boolean doTrigger(SpellAbility spell, boolean mandatory) {
         if (spell instanceof WrappedAbility)
-            return doTrigger(((WrappedAbility)spell).getWrappedAbility(), mandatory);
+            return doTrigger(((WrappedAbility) spell).getWrappedAbility(), mandatory);
         if (spell.getApi() != null)
             return SpellApiToAi.Converter.get(spell.getApi()).doTriggerAI(player, spell, mandatory);
         if (spell.getPayCosts() == Cost.Zero && !spell.usesTargeting()) {
@@ -1784,7 +1824,7 @@ public class AiController {
         }
         return false;
     }
-    
+
     /**
      * Ai should run.
      *
@@ -1839,12 +1879,11 @@ public class AiController {
         } else if (effect.hasParam("AICheckDredge")) {
             return player.getCardsIn(ZoneType.Library).size() > 8 || player.isCardInPlay("Laboratory Maniac");
         } else return sa != null && doTrigger(sa, false);
-
     }
 
     public List<SpellAbility> chooseSaToActivateFromOpeningHand(List<SpellAbility> usableFromOpeningHand) {
         // AI would play everything. But limits to one copy of (Leyline of Singularity) and (Gemstone Caverns)
-        
+
         List<SpellAbility> result = Lists.newArrayList();
         for (SpellAbility sa : usableFromOpeningHand) {
             // Is there a better way for the AI to decide this?
@@ -1852,7 +1891,7 @@ public class AiController {
                 result.add(sa);
             }
         }
-        
+
         boolean hasLeyline1 = false;
         SpellAbility saGemstones = null;
 
@@ -1878,7 +1917,7 @@ public class AiController {
             result.remove(saGemstones);
             result.add(saGemstones);
         }
-        
+
         return result;
     }
 
@@ -1922,11 +1961,11 @@ public class AiController {
         } else if ("LowestLoseLife".equals(logic)) {
             return MyRandom.getRandom().nextInt(Math.min(player.getLife() / 3, player.getWeakestOpponent().getLife())) + 1;
         } else if ("HighestLoseLife".equals(logic)) {
-            return Math.min(player.getLife() -1,MyRandom.getRandom().nextInt(Math.max(player.getLife() / 3, player.getWeakestOpponent().getLife())) + 1);
+            return Math.min(player.getLife() - 1, MyRandom.getRandom().nextInt(Math.max(player.getLife() / 3, player.getWeakestOpponent().getLife())) + 1);
         } else if ("HighestGetCounter".equals(logic)) {
             return MyRandom.getRandom().nextInt(3);
-        } else if (source.hasSVar("EnergyToPay")) {
-            return AbilityUtils.calculateAmount(source, source.getSVar("EnergyToPay"), sa);
+        } else if (sa.hasSVar("EnergyToPay")) {
+            return AbilityUtils.calculateAmount(source, sa.getSVar("EnergyToPay"), sa);
         } else if ("Vermin".equals(logic)) {
             return MyRandom.getRandom().nextInt(Math.max(player.getLife() - 5, 0));
         } else if ("SweepCreatures".equals(logic)) {
@@ -1941,6 +1980,21 @@ public class AiController {
         return max;
     }
 
+    public int chooseNumber(SpellAbility sa, String title, List<Integer> options, Player relatedPlayer) {
+        switch (sa.getApi()) {
+            case SetLife: // Reverse the Sands
+                if (relatedPlayer.equals(sa.getHostCard().getController())) {
+                    return Collections.max(options);
+                } else if (relatedPlayer.isOpponentOf(sa.getHostCard().getController())) {
+                    return Collections.min(options);
+                } else {
+                    return options.get(0);
+                }
+            default:
+                return options.get(0);
+        }
+    }
+
     public boolean confirmPayment(CostPart costPart) {
         throw new UnsupportedOperationException("AI is not supposed to reach this code at the moment");
     }
@@ -2053,14 +2107,13 @@ public class AiController {
 
     // this is where the computer cheats
     // changes AllZone.getComputerPlayer().getZone(Zone.Library)
-    
+
     /**
      * <p>
      * smoothComputerManaCurve.
      * </p>
-     * 
-     * @param in
-     *            an array of {@link forge.game.card.Card} objects.
+     *
+     * @param in an array of {@link forge.game.card.Card} objects.
      * @return an array of {@link forge.game.card.Card} objects.
      */
     public CardCollectionView cheatShuffle(CardCollectionView in) {
@@ -2088,7 +2141,7 @@ public class AiController {
             library.add(8, land.get(2));
             library.add(9, land.get(3));
             library.add(10, land.get(4));
-    
+
             library.add(12, land.get(5));
             library.add(15, land.get(6));
         } catch (final IndexOutOfBoundsException e) {
@@ -2106,22 +2159,6 @@ public class AiController {
         return library;
     } // smoothComputerManaCurve()
 
-    public int chooseNumber(SpellAbility sa, String title, List<Integer> options, Player relatedPlayer) {
-        switch(sa.getApi())
-        {
-            case SetLife: // Reverse the Sands
-                if (relatedPlayer.equals(sa.getHostCard().getController())) {
-                    return Collections.max(options);
-                } else if (relatedPlayer.isOpponentOf(sa.getHostCard().getController())) {
-                    return Collections.min(options);
-                } else {
-                    return options.get(0);
-                }
-            default:
-                return 0;
-        }
-    }
-
     public boolean chooseDirection(SpellAbility sa) {
         if (sa == null || sa.getApi() == null) {
             throw new UnsupportedOperationException();
@@ -2176,7 +2213,7 @@ public class AiController {
     }
 
     public Card chooseCardToHiddenOriginChangeZone(ZoneType destination, List<ZoneType> origin, SpellAbility sa,
-            CardCollection fetchList, Player player2, Player decider) {
+                                                   CardCollection fetchList, Player player2, Player decider) {
         if (useSimulation) {
             return simPicker.chooseCardToHiddenOriginChangeZone(destination, origin, sa, fetchList, player2, decider);
         }

forge-ai/src/main/java/forge/ai/AiCostDecision.java

@@ -2,10 +2,12 @@ package forge.ai;
 
 import static forge.ai.ComputerUtilCard.getBestCreatureAI;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
+import forge.card.MagicColor;
 import forge.game.cost.*;
 import org.apache.commons.lang3.ObjectUtils;
 
@@ -33,16 +35,11 @@ import forge.util.TextUtil;
 import forge.util.collect.FCollectionView;
 
 public class AiCostDecision extends CostDecisionMakerBase {
-    private final SpellAbility ability;
-    private final Card source;
-
     private final CardCollection discarded;
     private final CardCollection tapped;
 
     public AiCostDecision(Player ai0, SpellAbility sa, final boolean effect) {
-        super(ai0, effect);
-        ability = sa;
-        source = ability.getHostCard();
+        super(ai0, effect, sa, sa.getHostCard());
 
         discarded = new CardCollection();
         tapped = new CardCollection();
@@ -55,6 +52,14 @@ public class AiCostDecision extends CostDecisionMakerBase {
         return PaymentDecision.number(c);
     }
 
+    @Override
+    public PaymentDecision visit(CostChooseColor cost) {
+        int c = cost.getAbilityAmount(ability);
+        List<String> choices = player.getController().chooseColors("Color", ability, c, c,
+                new ArrayList<>(MagicColor.Constant.ONLY_COLORS));
+        return PaymentDecision.colors(choices);
+    }
+
     @Override
     public PaymentDecision visit(CostChooseCreatureType cost) {
         String choice = player.getController().chooseSomeType("Creature", ability, CardType.getAllCreatureTypes(),
@@ -163,11 +168,11 @@ public class AiCostDecision extends CostDecisionMakerBase {
         if (cost.getFrom().equals(ZoneType.Library)) {
             return PaymentDecision.card(player.getCardsIn(ZoneType.Library, c));
         }
-        else if (cost.sameZone) {
+        else if (cost.zoneRestriction == 0) {
             // TODO Determine exile from same zone for AI
             return null;
         } else {
-            CardCollectionView chosen = ComputerUtil.chooseExileFrom(player, cost.getFrom(), cost.getType(), source, ability.getTargetCard(), c, ability);
+            CardCollectionView chosen = ComputerUtil.chooseExileFrom(player, cost, source, c, ability);
             return null == chosen ? null : PaymentDecision.card(chosen);
         }
     }
@@ -228,6 +233,13 @@ public class AiCostDecision extends CostDecisionMakerBase {
         return res.isEmpty() ? null : PaymentDecision.card(res);
     }
 
+    @Override
+    public PaymentDecision visit(final CostEnlist cost) {
+        CardCollection choices = CostEnlist.getCardsForEnlisting(player);
+        CardLists.sortByPowerDesc(choices);
+        return choices.isEmpty() ? null : PaymentDecision.card(choices.getFirst());
+    }
+
     @Override
     public PaymentDecision visit(CostFlipCoin cost) {
         int c = cost.getAbilityAmount(ability);
@@ -248,7 +260,8 @@ public class AiCostDecision extends CostDecisionMakerBase {
 
         int c = cost.getAbilityAmount(ability);
 
-        final CardCollection typeList = CardLists.getValidCards(player.getGame().getCardsIn(ZoneType.Battlefield), cost.getType().split(";"), player, source, ability);
+        CardCollection typeList = CardLists.getValidCards(player.getGame().getCardsIn(ZoneType.Battlefield), cost.getType().split(";"), player, source, ability);
+        typeList = CardLists.filter(typeList, crd -> crd.canBeControlledBy(player));
 
         if (typeList.size() < c) {
             return null;
@@ -322,9 +335,9 @@ public class AiCostDecision extends CostDecisionMakerBase {
         CardCollectionView list;
 
         if (cost.isSameZone()) {
-            list = new CardCollection(game.getCardsIn(cost.getFrom()));
+            list = game.getCardsIn(cost.getFrom());
         } else {
-            list = new CardCollection(player.getCardsIn(cost.getFrom()));
+            list = player.getCardsIn(cost.getFrom());
         }
 
         int c = cost.getAbilityAmount(ability);
@@ -438,7 +451,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
 
         final AiController aic = ((PlayerControllerAi)player.getController()).getAi();
         CardCollectionView list = aic.chooseSacrificeType(cost.getType(), ability, isEffect(), c, null);
-        return PaymentDecision.card(list);
+        return list == null ? null : PaymentDecision.card(list);
     }
 
     @Override
@@ -775,6 +788,11 @@ public class AiCostDecision extends CostDecisionMakerBase {
         return PaymentDecision.number(0);
     }
 
+    @Override
+    public PaymentDecision visit(CostPayShards cost) {
+        return PaymentDecision.number(0);
+    }
+
     @Override
     public PaymentDecision visit(CostUnattach cost) {
         final Card cardToUnattach = cost.findCardToUnattach(source, player, ability);

forge-ai/src/main/java/forge/ai/ComputerUtil.java

@@ -33,6 +33,7 @@ import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Multimap;
 
+import forge.ai.AiCardMemory.MemorySet;
 import forge.ai.ability.ChooseGenericEffectAi;
 import forge.ai.ability.ProtectAi;
 import forge.ai.ability.TokenAi;
@@ -65,6 +66,7 @@ import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.Cost;
 import forge.game.cost.CostDiscard;
+import forge.game.cost.CostExile;
 import forge.game.cost.CostPart;
 import forge.game.cost.CostPayment;
 import forge.game.cost.CostPutCounter;
@@ -127,14 +129,14 @@ public class ComputerUtil {
 
         if (!sa.isCopied()) {
             sa.resetPaidHash();
+            sa.setPaidLife(0);
         }
 
         sa = GameActionUtil.addExtraKeywordCost(sa);
 
-        if (sa.getApi() == ApiType.Charm && !sa.isWrapper()) {
-            if (!CharmEffect.makeChoices(sa)) {
-                return false;
-            }
+        if (sa.getApi() == ApiType.Charm && !CharmEffect.makeChoices(sa)) {
+            // 603.3c If no mode is chosen, the ability is removed from the stack.
+            return false;
         }
         if (chooseTargets != null) {
             chooseTargets.run();
@@ -230,7 +232,7 @@ public class ComputerUtil {
 
         // Then base on Targeting Restriction
         final String[] validTgts = tgt.getValidTgts();
-        if ((validTgts.length != 1) || !validTgts[0].equals("Card")) {
+        if (validTgts.length != 1 || !validTgts[0].equals("Card")) {
             restrict += 10;
         }
 
@@ -245,11 +247,18 @@ public class ComputerUtil {
 
     // this is used for AI's counterspells
     public static final boolean playStack(SpellAbility sa, final Player ai, final Game game) {
-        sa.setActivatingPlayer(ai);
+        sa.setActivatingPlayer(ai, true);
         if (!ComputerUtilCost.canPayCost(sa, ai, false))
             return false;
 
         final Card source = sa.getHostCard();
+
+        Zone fromZone = game.getZoneOf(source);
+        int zonePosition = 0;
+        if (fromZone != null) {
+            zonePosition = fromZone.getCards().indexOf(source);
+        }
+
         if (sa.isSpell() && !source.isCopiedSpell()) {
             sa.setHostCard(game.getAction().moveToStack(source, sa));
         }
@@ -257,11 +266,18 @@ public class ComputerUtil {
         sa = GameActionUtil.addExtraKeywordCost(sa);
 
         final Cost cost = sa.getPayCosts();
+        final CostPayment pay = new CostPayment(cost, sa);
+
+        // do this after card got added to stack
+        if (!sa.checkRestrictions(ai)) {
+            GameActionUtil.rollbackAbility(sa, fromZone, zonePosition, pay, source);
+            return false;
+        }
+
         if (cost == null) {
             ComputerUtilMana.payManaCost(ai, sa, false);
             game.getStack().add(sa);
         } else {
-            final CostPayment pay = new CostPayment(cost, sa);
             if (pay.payComputerCosts(new AiCostDecision(ai, sa, false))) {
                 game.getStack().add(sa);
             }
@@ -271,7 +287,7 @@ public class ComputerUtil {
 
     public static final void playSpellAbilityForFree(final Player ai, final SpellAbility sa) {
         final Game game = ai.getGame();
-        sa.setActivatingPlayer(ai);
+        sa.setActivatingPlayer(ai, true);
 
         final Card source = sa.getHostCard();
         if (sa.isSpell() && !source.isCopiedSpell()) {
@@ -283,7 +299,7 @@ public class ComputerUtil {
 
     public static final boolean playSpellAbilityWithoutPayingManaCost(final Player ai, final SpellAbility sa, final Game game) {
         SpellAbility newSA = sa.copyWithNoManaCost();
-        newSA.setActivatingPlayer(ai);
+        newSA.setActivatingPlayer(ai, true);
 
         if (!CostPayment.canPayAdditionalCosts(newSA.getPayCosts(), newSA) || !ComputerUtilMana.canPayManaCost(newSA, ai, 0, false)) {
             return false;
@@ -292,47 +308,60 @@ public class ComputerUtil {
         newSA = GameActionUtil.addExtraKeywordCost(newSA);
 
         final Card source = newSA.getHostCard();
+
+        Zone fromZone = game.getZoneOf(source);
+        int zonePosition = 0;
+        if (fromZone != null) {
+            zonePosition = fromZone.getCards().indexOf(source);
+        }
+
         if (newSA.isSpell() && !source.isCopiedSpell()) {
             newSA.setHostCard(game.getAction().moveToStack(source, newSA));
 
-            if (newSA.getApi() == ApiType.Charm && !newSA.isWrapper()) {
-                if (!CharmEffect.makeChoices(newSA)) {
-                    return false;
-                }
+            if (newSA.getApi() == ApiType.Charm && !CharmEffect.makeChoices(newSA)) {
+                // 603.3c If no mode is chosen, the ability is removed from the stack.
+                return false;
             }
         }
 
         final CostPayment pay = new CostPayment(newSA.getPayCosts(), newSA);
+
+        // do this after card got added to stack
+        if (!sa.checkRestrictions(ai)) {
+            GameActionUtil.rollbackAbility(sa, fromZone, zonePosition, pay, source);
+            return false;
+        }
+        
         pay.payComputerCosts(new AiCostDecision(ai, newSA, false));
 
         game.getStack().add(newSA);
         return true;
     }
 
-    public static final void playNoStack(final Player ai, SpellAbility sa, final Game game, final boolean effect) {
-        sa.setActivatingPlayer(ai);
+    public static final boolean playNoStack(final Player ai, SpellAbility sa, final Game game, final boolean effect) {
+        sa.setActivatingPlayer(ai, true);
         // TODO: We should really restrict what doesn't use the Stack
-        if (ComputerUtilCost.canPayCost(sa, ai, effect)) {
-            final Card source = sa.getHostCard();
-            if (sa.isSpell() && !source.isCopiedSpell()) {
-                sa.setHostCard(game.getAction().moveToStack(source, sa));
-            }
-
-            sa = GameActionUtil.addExtraKeywordCost(sa);
-
-            final Cost cost = sa.getPayCosts();
-            if (cost == null) {
-                ComputerUtilMana.payManaCost(ai, sa, effect);
-            } else {
-                final CostPayment pay = new CostPayment(cost, sa);
-                pay.payComputerCosts(new AiCostDecision(ai, sa, effect));
-            }
-
-            AbilityUtils.resolve(sa);
-
-            // destroys creatures if they have lethal damage, etc..
-            //game.getAction().checkStateEffects();
+        if (!ComputerUtilCost.canPayCost(sa, ai, effect)) {
+            return false;
         }
+
+        final Card source = sa.getHostCard();
+        if (sa.isSpell() && !source.isCopiedSpell()) {
+            sa.setHostCard(game.getAction().moveToStack(source, sa));
+        }
+
+        sa = GameActionUtil.addExtraKeywordCost(sa);
+
+        final Cost cost = sa.getPayCosts();
+        if (cost == null) {
+            ComputerUtilMana.payManaCost(ai, sa, effect);
+        } else {
+            final CostPayment pay = new CostPayment(cost, sa);
+            pay.payComputerCosts(new AiCostDecision(ai, sa, effect));
+        }
+
+        AbilityUtils.resolve(sa);
+        return true;
     }
 
     public static Card getCardPreference(final Player ai, final Card activate, final String pref, final CardCollection typeList) {
@@ -426,14 +455,27 @@ public class ComputerUtil {
             }
 
             // try everything when about to die
-            if (game.getPhaseHandler().getPhase().equals(PhaseType.COMBAT_DECLARE_BLOCKERS)
-                    && ComputerUtilCombat.lifeInSeriousDanger(ai, game.getCombat())) {
-                final CardCollection nonCreatures = CardLists.getNotType(typeList, "Creature");
-                if (!nonCreatures.isEmpty()) {
-                    return ComputerUtilCard.getWorstAI(nonCreatures);
-                } else if (!typeList.isEmpty()) {
-                    // TODO make sure survival is possible in case the creature blocks a trampler
-                    return ComputerUtilCard.getWorstAI(typeList);
+            if (game.getPhaseHandler().getPhase().equals(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
+                // in some rare situations the call to lifeInDanger could lead us back here, this will prevent an overflow
+                boolean preventReturn = sa != null && sa.isManaAbility();
+                if (preventReturn) {
+                    AiCardMemory.rememberCard(ai, sa.getHostCard(), MemorySet.HELD_MANA_SOURCES_FOR_NEXT_SPELL);
+                }
+
+                boolean danger = ComputerUtilCombat.lifeInSeriousDanger(ai, game.getCombat());
+
+                if (preventReturn) {
+                    AiCardMemory.forgetCard(ai, sa.getHostCard(), MemorySet.HELD_MANA_SOURCES_FOR_NEXT_SPELL);
+                }
+
+                if (danger) {
+                    final CardCollection nonCreatures = CardLists.getNotType(typeList, "Creature");
+                    if (!nonCreatures.isEmpty()) {
+                        return ComputerUtilCard.getWorstAI(nonCreatures);
+                    } else if (!typeList.isEmpty()) {
+                        // TODO make sure survival is possible in case the creature blocks a trampler
+                        return ComputerUtilCard.getWorstAI(typeList);
+                    }
                 }
             }
         }
@@ -586,7 +628,7 @@ public class ComputerUtil {
         int count = 0;
 
         while (count < amount) {
-            Card prefCard = getCardPreference(ai, source, "SacCost", typeList);
+            Card prefCard = getCardPreference(ai, source, "SacCost", typeList, ability);
             if (prefCard == null) {
                 prefCard = ComputerUtilCard.getWorstAI(typeList);
             }
@@ -600,9 +642,14 @@ public class ComputerUtil {
         return sacList;
     }
 
-    public static CardCollection chooseExileFrom(final Player ai, final ZoneType zone, final String type, final Card activate,
-            final Card target, final int amount, SpellAbility sa) {
-        CardCollection typeList = CardLists.getValidCards(ai.getCardsIn(zone), type.split(";"), activate.getController(), activate, sa);
+    public static CardCollection chooseExileFrom(final Player ai, CostExile cost, final Card activate, final int amount, SpellAbility sa) {
+        CardCollection typeList;
+        if (cost.zoneRestriction != 1) {
+            typeList = new CardCollection(ai.getGame().getCardsIn(cost.from));
+        } else {
+            typeList = new CardCollection(ai.getCardsIn(cost.from));
+        }
+        typeList = CardLists.getValidCards(typeList, cost.getType().split(";"), activate.getController(), activate, sa);
 
         // don't exile the card we're pumping
         typeList = ComputerUtilCost.paymentChoicesWithoutTargets(typeList, sa, ai);
@@ -817,17 +864,18 @@ public class ComputerUtil {
 
                     String logic = source.getParamOrDefault("AILogic", "");
                     if (logic.startsWith("SacForDamage")) {
-                        if (c.getNetPower() <= 0) {
+                        final int damageAmt = logic.contains("cmc") ? c.getManaCost().getCMC() : c.getNetPower();
+                        if (damageAmt <= 0) {
                             return false;
-                        } else if (c.getNetPower() >= ai.getOpponentsSmallestLifeTotal()) {
+                        } else if (damageAmt >= ai.getOpponentsSmallestLifeTotal()) {
                             return true;
                         } else if (logic.endsWith(".GiantX2") && c.getType().hasCreatureType("Giant")
-                                && c.getNetPower() * 2 >= ai.getOpponentsSmallestLifeTotal()) {
+                                && damageAmt * 2 >= ai.getOpponentsSmallestLifeTotal()) {
                             return true; // TODO: generalize this for any type and actually make the AI prefer giants?
                         }
                     }
 
-                    if ("DesecrationDemon".equals(source.getParam("AILogic"))) {
+                    if ("DesecrationDemon".equals(logic)) {
                         sacThreshold = SpecialCardAi.DesecrationDemon.getSacThreshold();
                     } else if (considerSacThreshold != -1) {
                         sacThreshold = considerSacThreshold;
@@ -931,7 +979,7 @@ public class ComputerUtil {
                     if (!sa.isActivatedAbility() || sa.getApi() != ApiType.Regenerate) {
                         continue; // Not a Regenerate ability
                     }
-                    sa.setActivatingPlayer(controller);
+                    sa.setActivatingPlayer(controller, true);
                     if (!(sa.canPlay() && ComputerUtilCost.canPayCost(sa, controller, false))) {
                         continue; // Can't play ability
                     }
@@ -1026,6 +1074,15 @@ public class ComputerUtil {
             }
         }
 
+        // cast Backup creatures in main 1 to pump attackers
+        if (cardState.hasKeyword(Keyword.BACKUP)) {
+            for (Card potentialAtkr: ai.getCreaturesInPlay()) {
+                if (ComputerUtilCard.doesCreatureAttackAI(ai, potentialAtkr)) {
+                    return true;
+                }
+            }
+        }
+
         // try not to cast Raid creatures in main 1 if an attack is likely
         if ("Count$AttackersDeclared".equals(card.getSVar("RaidTest")) && !cardState.hasKeyword(Keyword.HASTE)) {
             for (Card potentialAtkr: ai.getCreaturesInPlay()) {
@@ -1039,6 +1096,10 @@ public class ComputerUtil {
             return true;
         }
 
+        if (cardState.hasKeyword(Keyword.EXALTED) || cardState.hasKeyword(Keyword.EXTORT)) {
+            return true;
+        }
+
         if (cardState.hasKeyword(Keyword.RIOT) && ChooseGenericEffectAi.preferHasteForRiot(sa, ai)) {
             // Planning to choose Haste for Riot, so do this in Main 1
             return true;
@@ -1046,6 +1107,7 @@ public class ComputerUtil {
 
         // if we have non-persistent mana in our pool, would be good to try to use it and not waste it
         if (ai.getManaPool().willManaBeLostAtEndOfPhase()) {
+            // TODO should check if some will be kept and skip those
             boolean canUseToPayCost = false;
             for (byte color : ManaAtom.MANATYPES) {
                 // tries to reuse any amount of colorless if cost only has generic
@@ -1065,10 +1127,6 @@ public class ComputerUtil {
             return true;
         }
 
-        if (cardState.hasKeyword(Keyword.EXALTED) || cardState.hasKeyword(Keyword.EXTORT)) {
-            return true;
-        }
-
         //cast equipments in Main1 when there are creatures to equip and no other unequipped equipment
         if (card.isEquipment()) {
             boolean playNow = false;
@@ -1077,7 +1135,7 @@ public class ComputerUtil {
                     playNow = false;
                     break;
                 }
-                if (!playNow && c.isCreature() && ComputerUtilCombat.canAttackNextTurn(c) && c.canBeAttached(card)) {
+                if (!playNow && c.isCreature() && ComputerUtilCombat.canAttackNextTurn(c) && c.canBeAttached(card, null)) {
                     playNow = true;
                 }
             }
@@ -1153,7 +1211,7 @@ public class ComputerUtil {
                     creatures2.add(creatures.get(i));
                 }
             }
-            if (((creatures2.size() + CardUtil.getThisTurnCast("Creature.YouCtrl", vengevines.get(0), null).size()) > 1)
+            if (((creatures2.size() + CardUtil.getThisTurnCast("Creature.YouCtrl", vengevines.get(0), null, ai).size()) > 1)
                     && card.isCreature() && card.getManaCost().getCMC() <= 3) {
                 return true;
             }
@@ -1227,12 +1285,12 @@ public class ComputerUtil {
         final Game game = sa.getActivatingPlayer().getGame();
         final PhaseHandler ph = game.getPhaseHandler();
 
-        return (sa.getHostCard().isCreature()
+        return sa.getHostCard().isCreature()
                 && sa.getPayCosts().hasTapCost()
                 && (ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)
                         && !ph.getNextTurn().equals(sa.getActivatingPlayer()))
                 && !sa.getHostCard().hasSVar("EndOfTurnLeavePlay")
-                && !sa.hasParam("ActivationPhases"));
+                && !sa.hasParam("ActivationPhases");
     }
 
     //returns true if it's better to wait until blockers are declared).
@@ -1506,7 +1564,7 @@ public class ComputerUtil {
                 if (sa.getApi() != ApiType.DealDamage) {
                     continue;
                 }
-                sa.setActivatingPlayer(ai);
+                sa.setActivatingPlayer(ai, true);
                 final String numDam = sa.getParam("NumDmg");
                 int dmg = AbilityUtils.calculateAmount(sa.getHostCard(), numDam, sa);
                 if (dmg <= damage) {
@@ -1698,6 +1756,10 @@ public class ComputerUtil {
                         continue;
                     }
 
+                    if (c.getCounters(CounterEnumType.SHIELD) > 0) {
+                        continue;
+                    }
+
                     // already regenerated
                     if (c.getShieldCount() > 0) {
                         continue;
@@ -1756,8 +1818,7 @@ public class ComputerUtil {
                 && (saviourApi == ApiType.ChangeZone || saviourApi == ApiType.Pump || saviourApi == ApiType.PumpAll
                 || saviourApi == ApiType.Protection || saviourApi == ApiType.PutCounter || saviourApi == ApiType.PutCounterAll
                 || saviourApi == null)) {
-            final int dmg = -AbilityUtils.calculateAmount(source,
-                    topStack.getParam("NumDef"), topStack);
+            final int dmg = -AbilityUtils.calculateAmount(source, topStack.getParam("NumDef"), topStack);
             for (final Object o : objects) {
                 if (o instanceof Card) {
                     final Card c = (Card) o;
@@ -1813,6 +1874,10 @@ public class ComputerUtil {
                         continue;
                     }
 
+                    if (c.getCounters(CounterEnumType.SHIELD) > 0) {
+                        continue;
+                    }
+
                     // already regenerated
                     if (c.getShieldCount() > 0) {
                         continue;
@@ -2030,7 +2095,7 @@ public class ComputerUtil {
             return finalHandSize;
         }
 
-        CardCollectionView library = ai.getZone(ZoneType.Library).getCards();
+        CardCollectionView library = ai.getCardsIn(ZoneType.Library);
         int landsInDeck = CardLists.count(library, CardPredicates.isType("Land"));
 
         // no land deck, can't do anything better
@@ -2258,23 +2323,31 @@ public class ComputerUtil {
         if (goodChoices.isEmpty()) {
             goodChoices = validCards;
         }
-        final CardCollection dChoices = new CardCollection();
-        if (sa.hasParam("DiscardValid")) {
-            final String validString = sa.getParam("DiscardValid");
-            if (validString.contains("Creature") && !validString.contains("nonCreature")) {
-                final Card c = ComputerUtilCard.getBestCreatureAI(goodChoices);
-                if (c != null) {
-                    dChoices.add(c);
+
+        if (min == 1 && max == 1) {
+            if (sa.hasParam("DiscardValid")) {
+                final String validString = sa.getParam("DiscardValid");
+                if (validString.contains("Creature") && !validString.contains("nonCreature")) {
+                    final Card c = ComputerUtilCard.getBestCreatureAI(goodChoices);
+                    if (c != null) {
+                        return new CardCollection(c);
+                    }
                 }
             }
         }
 
+        // not enough good choices, need to fill the rest
+        int minDiff = min - goodChoices.size();
+        if (minDiff > 0) {
+            goodChoices.addAll(Aggregates.random(CardLists.filter(validCards, Predicates.not(Predicates.in(goodChoices))), minDiff));
+            return goodChoices;
+        }
+
         Collections.sort(goodChoices, CardLists.TextLenComparator);
 
         CardLists.sortByCmcDesc(goodChoices);
-        dChoices.add(goodChoices.get(0));
 
-        return Aggregates.random(goodChoices, min, new CardCollection());
+        return goodChoices.subList(0, max);
     }
 
     public static CardCollection getCardsToDiscardFromFriend(Player aiChooser, Player p, SpellAbility sa, CardCollection validCards, int min, int max) {
@@ -2286,7 +2359,9 @@ public class ComputerUtil {
         return getCardsToDiscardFromOpponent(aiChooser, p, sa, validCards, min, max);
     }
 
-    public static String chooseSomeType(Player ai, String kindOfType, String logic, Collection<String> validTypes, List<String> invalidTypes) {
+    public static String chooseSomeType(Player ai, String kindOfType, SpellAbility sa, Collection<String> validTypes, List<String> invalidTypes) {
+        final String logic = sa.getParam("AILogic");
+
         if (invalidTypes == null) {
             invalidTypes = ImmutableList.of();
         }
@@ -2313,6 +2388,23 @@ public class ComputerUtil {
                     }
                 }
             }
+            else {
+                // Are we picking a type to reduce costs for that type?
+                boolean reducingCost = false;
+                for (StaticAbility s : sa.getHostCard().getStaticAbilities()) {
+                    if ("ReduceCost".equals(s.getParam("Mode")) && "Card.ChosenType".equals(s.getParam("ValidCard"))) {
+                        reducingCost = true;
+                        break;
+                    }
+                }
+
+                if (reducingCost) {
+                    List<String> valid = Lists.newArrayList(validTypes);
+                    valid.removeAll(invalidTypes);
+                    valid.remove("Land"); // Lands don't have costs to reduce
+                    chosen = ComputerUtilCard.getMostProminentCardType(ai.getAllCards(), valid);
+                }
+            }
             if (StringUtils.isEmpty(chosen)) {
                 chosen = validTypes.isEmpty() ? "Creature" : Aggregates.random(validTypes);
             }
@@ -2328,15 +2420,16 @@ public class ComputerUtil {
                     chosen = ComputerUtilCard.getMostProminentType(ai.getCardsIn(ZoneType.Battlefield), valid);
                 }
                 else if (logic.equals("MostProminentOppControls")) {
-                    CardCollection list = CardLists.filterControlledBy(game.getCardsIn(ZoneType.Battlefield), ai.getOpponents());
+                    CardCollection list = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
                     chosen = ComputerUtilCard.getMostProminentType(list, valid);
                     if (!CardType.isACreatureType(chosen) || invalidTypes.contains(chosen)) {
                         list = CardLists.filterControlledBy(game.getCardsInGame(), ai.getOpponents());
                         chosen = ComputerUtilCard.getMostProminentType(list, valid);
                     }
                 }
-                else if (logic.equals("MostProminentInComputerDeck")) {
-                    chosen = ComputerUtilCard.getMostProminentType(ai.getAllCards(), valid);
+                else if (logic.startsWith("MostProminentInComputerDeck")) {
+                    boolean includeTokens = !logic.endsWith("NonToken");
+                    chosen = ComputerUtilCard.getMostProminentType(ai.getAllCards(), valid, includeTokens);
                 }
                 else if (logic.equals("MostProminentInComputerGraveyard")) {
                     chosen = ComputerUtilCard.getMostProminentType(ai.getCardsIn(ZoneType.Graveyard), valid);
@@ -2349,7 +2442,7 @@ public class ComputerUtil {
         } else if (kindOfType.equals("Basic Land")) {
             if (logic != null) {
                 if (logic.equals("MostProminentOppControls")) {
-                    CardCollection list = CardLists.filterControlledBy(game.getCardsIn(ZoneType.Battlefield), ai.getOpponents());
+                    CardCollection list = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
                     List<String> valid = Lists.newArrayList(CardType.getBasicTypes());
                     valid.removeAll(invalidTypes);
 
@@ -2601,8 +2694,7 @@ public class ComputerUtil {
     }
 
     public static CardCollection getSafeTargets(final Player ai, SpellAbility sa, CardCollectionView validCards) {
-        CardCollection safeCards = new CardCollection(validCards);
-        safeCards = CardLists.filter(safeCards, new Predicate<Card>() {
+        CardCollection safeCards = CardLists.filter(validCards, new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
                 if (c.getController() == ai) {
@@ -2615,8 +2707,7 @@ public class ComputerUtil {
     }
 
     public static Card getKilledByTargeting(final SpellAbility sa, CardCollectionView validCards) {
-        CardCollection killables = new CardCollection(validCards);
-        killables = CardLists.filter(killables, new Predicate<Card>() {
+        CardCollection killables = CardLists.filter(validCards, new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
                 return c.getController() != sa.getActivatingPlayer() && c.getSVar("Targeting").equals("Dies");
@@ -2788,7 +2879,7 @@ public class ComputerUtil {
                 || type.is(CounterEnumType.GOLD) || type.is(CounterEnumType.MUSIC) || type.is(CounterEnumType.PUPA)
                 || type.is(CounterEnumType.PARALYZATION) || type.is(CounterEnumType.SHELL) || type.is(CounterEnumType.SLEEP)
                 || type.is(CounterEnumType.SLUMBER) || type.is(CounterEnumType.SLEIGHT) || type.is(CounterEnumType.WAGE)
-                || type.is(CounterEnumType.INCARNATION) || type.is(CounterEnumType.RUST);
+                || type.is(CounterEnumType.INCARNATION) || type.is(CounterEnumType.RUST) || type.is(CounterEnumType.STUN);
     }
 
     // this countertypes has no effect
@@ -2803,7 +2894,7 @@ public class ComputerUtil {
         }
 
         return type.is(CounterEnumType.AWAKENING) || type.is(CounterEnumType.MANIFESTATION) || type.is(CounterEnumType.PETRIFICATION)
-                || type.is(CounterEnumType.TRAINING);
+                || type.is(CounterEnumType.TRAINING) || type.is(CounterEnumType.GHOSTFORM);
     }
 
     public static Player evaluateBoardPosition(final List<Player> listToEvaluate) {
@@ -2911,7 +3002,7 @@ public class ComputerUtil {
         return false;
     }
 
-    public static boolean targetPlayableSpellCard(final Player ai, CardCollection options, final SpellAbility sa, final boolean withoutPayingManaCost, boolean mandatory) {
+    public static boolean targetPlayableSpellCard(final Player ai, Iterable<Card> options, final SpellAbility sa, final boolean withoutPayingManaCost, boolean mandatory) {
         // determine and target a card with a SA that the AI can afford and will play
         AiController aic = ((PlayerControllerAi) ai.getController()).getAi();
         sa.resetTargets();
@@ -2934,7 +3025,7 @@ public class ComputerUtil {
                 }
                 SpellAbility abTest = withoutPayingManaCost ? ab.copyWithNoManaCost() : ab.copy();
                 // at this point, we're assuming that card will be castable from whichever zone it's in by the AI player.
-                abTest.setActivatingPlayer(ai);
+                abTest.setActivatingPlayer(ai, true);
                 abTest.getRestrictions().setZone(c.getZone().getZoneType());
                 if (AiPlayDecision.WillPlay == aic.canPlaySa(abTest) && ComputerUtilCost.canPayCost(abTest, ai, false)) {
                     targets.add(c);
@@ -2943,8 +3034,8 @@ public class ComputerUtil {
         }
 
         if (targets.isEmpty()) {
-            if (mandatory && !options.isEmpty()) {
-                targets = options;
+            if (mandatory && !Iterables.isEmpty(options)) {
+                targets.addAll(options);
             } else {
                 return false;
             }
@@ -3092,4 +3183,14 @@ public class ComputerUtil {
         return remainingLife;
     }
 
+    public static boolean isETBprevented(Card c) {
+        final Map<AbilityKey, Object> repParams = AbilityKey.mapFromAffected(c);
+        // don't need to bother with real LKI since this is a passive check and the card isn't going anywhere
+        repParams.put(AbilityKey.CardLKI, c);
+        repParams.put(AbilityKey.Origin, c.getLastKnownZone().getZoneType());
+        repParams.put(AbilityKey.Destination, ZoneType.Battlefield);
+        List<ReplacementEffect> list = c.getGame().getReplacementHandler().getReplacementList(ReplacementType.Moved, repParams, ReplacementLayer.CantHappen);
+        return !list.isEmpty();
+    }
+    
 }

forge-ai/src/main/java/forge/ai/ComputerUtilAbility.java

@@ -91,7 +91,7 @@ public class ComputerUtilAbility {
         List<SpellAbility> originListWithAddCosts = Lists.newArrayList();
         for (SpellAbility sa : originList) {
             // If this spell has alternative additional costs, add them instead of the unmodified SA itself
-            sa.setActivatingPlayer(player);
+            sa.setActivatingPlayer(player, true);
             originListWithAddCosts.addAll(GameActionUtil.getAdditionalCostSpell(sa));
         }
 
@@ -115,10 +115,10 @@ public class ComputerUtilAbility {
             newAbilities.add(sa);
             newAbilities.addAll(otherAltSa);
         }
-    
+
         final List<SpellAbility> result = Lists.newArrayList();
         for (SpellAbility sa : newAbilities) {
-            sa.setActivatingPlayer(player);
+            sa.setActivatingPlayer(player, true);
 
             // Optional cost selection through the AI controller
             boolean choseOptCost = false;

forge-ai/src/main/java/forge/ai/ComputerUtilCombat.java

@@ -48,6 +48,7 @@ import forge.game.replacement.ReplacementLayer;
 import forge.game.replacement.ReplacementType;
 import forge.game.spellability.SpellAbility;
 import forge.game.staticability.StaticAbility;
+import forge.game.staticability.StaticAbilityAssignCombatDamageAsUnblocked;
 import forge.game.staticability.StaticAbilityMustAttack;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
@@ -127,7 +128,7 @@ public class ComputerUtilCombat {
         //        || (attacker.hasKeyword(Keyword.FADING) && attacker.getCounters(CounterEnumType.FADE) == 0)
         //        || attacker.hasSVar("EndOfTurnLeavePlay"));
         // The creature won't untap next turn
-        return !attacker.isTapped() || Untap.canUntap(attacker);
+        return !attacker.isTapped() || (attacker.getCounters(CounterEnumType.STUN) == 0 && Untap.canUntap(attacker));
     }
 
     /**
@@ -199,8 +200,8 @@ public class ComputerUtilCombat {
             return 0;
         }
 
-        damage += predictPowerBonusOfAttacker(attacker, null, combat, withoutAbilities);
         if (!attacker.hasKeyword(Keyword.INFECT)) {
+            damage += predictPowerBonusOfAttacker(attacker, null, combat, withoutAbilities);
             sum = predictDamageTo(attacked, damage, attacker, true);
             if (attacker.hasDoubleStrike()) {
                 sum *= 2;
@@ -325,13 +326,12 @@ public class ComputerUtilCombat {
                 final List<Card> blockers = combat.getBlockers(attacker);
 
                 if (blockers.size() == 0
-                        || attacker.hasKeyword("You may have CARDNAME assign its combat damage "
-                                + "as though it weren't blocked.")) {
+                        || StaticAbilityAssignCombatDamageAsUnblocked.assignCombatDamageAsUnblocked(attacker)) {
                     unblocked.add(attacker);
-                } else if (attacker.hasKeyword(Keyword.TRAMPLE)
-                        && getAttack(attacker) > totalShieldDamage(attacker, blockers)) {
-                    if (!attacker.hasKeyword(Keyword.INFECT)) {
-                        damage += getAttack(attacker) - totalShieldDamage(attacker, blockers);
+                } else if (attacker.hasKeyword(Keyword.TRAMPLE) && !attacker.hasKeyword(Keyword.INFECT)) {
+                    int dmgAfterShielding = getAttack(attacker) - totalShieldDamage(attacker, blockers);
+                    if (dmgAfterShielding > 0) {
+                        damage += dmgAfterShielding;
                     }
                 }
             }
@@ -367,16 +367,16 @@ public class ComputerUtilCombat {
             final List<Card> blockers = combat.getBlockers(attacker);
 
             if (blockers.size() == 0
-                    || attacker.hasKeyword("You may have CARDNAME assign its combat damage"
-                            + " as though it weren't blocked.")) {
+                    || StaticAbilityAssignCombatDamageAsUnblocked.assignCombatDamageAsUnblocked(attacker)) {
                 unblocked.add(attacker);
-            } else if (attacker.hasKeyword(Keyword.TRAMPLE)
-                    && getAttack(attacker) > totalShieldDamage(attacker, blockers)) {
+            } else if (attacker.hasKeyword(Keyword.TRAMPLE)) {
                 int trampleDamage = getAttack(attacker) - totalShieldDamage(attacker, blockers);
-                if (attacker.hasKeyword(Keyword.INFECT)) {
-                    poison += trampleDamage;
+                if (trampleDamage > 0) {
+                    if (attacker.hasKeyword(Keyword.INFECT)) {
+                        poison += trampleDamage;
+                    }
+                    poison += predictPoisonFromTriggers(attacker, ai, trampleDamage);
                 }
-                poison += predictPoisonFromTriggers(attacker, ai, trampleDamage);
             }
         }
 
@@ -388,7 +388,7 @@ public class ComputerUtilCombat {
     public static List<Card> getLifeThreateningCommanders(final Player ai, final Combat combat) {
         List<Card> res = Lists.newArrayList();
         for (Card c : combat.getAttackers()) {
-            if (c.isCommander()) {
+            if (c.isCommander() && combat.isAttacking(c, ai)) {
                 int currentCommanderDamage = ai.getCommanderDamage(c);
                 if (damageIfUnblocked(c, ai, combat, false) + currentCommanderDamage >= 21) {
                     res.add(c);
@@ -519,7 +519,7 @@ public class ComputerUtilCombat {
             return true;
         }
 
-        return resultingPoison(ai, combat) > 9;
+        return resultingPoison(ai, combat) >= ai.getGame().getRules().getPoisonCountersToLose();
     }
 
     // This calculates the amount of damage a blockgang can deal to the attacker
@@ -687,7 +687,7 @@ public class ComputerUtilCombat {
         final int defenderDefense = blocker.getLethalDamage() - flankingMagnitude + defBushidoMagnitude;
 
         return defenderDefense;
-    } // shieldDamage
+    }
 
     // For AI safety measures like Regeneration
     /**
@@ -919,7 +919,7 @@ public class ComputerUtilCombat {
         final CardCollectionView cardList = CardCollection.combine(game.getCardsIn(ZoneType.Battlefield), game.getCardsIn(ZoneType.Command));
         for (final Card card : cardList) {
             for (final StaticAbility stAb : card.getStaticAbilities()) {
-                if (!stAb.getParam("Mode").equals("Continuous")) {
+                if (!stAb.checkMode("Continuous")) {
                     continue;
                 }
                 if (!stAb.hasParam("Affected") || !stAb.getParam("Affected").contains("blocking")) {
@@ -1181,11 +1181,6 @@ public class ComputerUtilCombat {
     public static int predictPowerBonusOfAttacker(final Card attacker, final Card blocker, final Combat combat, boolean withoutAbilities, boolean withoutCombatStaticAbilities) {
         int power = 0;
 
-        //check Exalted only for the first attacker
-        if (combat != null && combat.getAttackers().isEmpty()) {
-            power += attacker.getController().countExaltedBonus();
-        }
-
         // Serene Master switches power with attacker
         if (blocker!= null && blocker.getName().equals("Serene Master")) {
             power += blocker.getNetPower() - attacker.getNetPower();
@@ -1213,12 +1208,14 @@ public class ComputerUtilCombat {
             theTriggers.addAll(blocker.getTriggers());
         }
 
+        // TODO consider Exert + Enlist
+
         // look out for continuous static abilities that only care for attacking creatures
         if (!withoutCombatStaticAbilities) {
             final CardCollectionView cardList = CardCollection.combine(game.getCardsIn(ZoneType.Battlefield), game.getCardsIn(ZoneType.Command));
             for (final Card card : cardList) {
                 for (final StaticAbility stAb : card.getStaticAbilities()) {
-                    if (!stAb.getParam("Mode").equals("Continuous")) {
+                    if (!stAb.checkMode("Continuous")) {
                         continue;
                     }
                     if (!stAb.hasParam("Affected") || !stAb.getParam("Affected").contains("attacking")) {
@@ -1259,7 +1256,7 @@ public class ComputerUtilCombat {
                 continue;
             }
 
-            sa.setActivatingPlayer(source.getController());
+            sa.setActivatingPlayer(source.getController(), true);
 
             if (sa.hasParam("Cost")) {
                 if (!CostPayment.canPayAdditionalCosts(sa.getPayCosts(), sa)) {
@@ -1268,21 +1265,17 @@ public class ComputerUtilCombat {
             }
 
             List<Card> list = Lists.newArrayList();
-            if (!sa.hasParam("ValidCards")) {
-                list = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), null);
-            }
-            if (sa.hasParam("Defined") && sa.getParam("Defined").startsWith("TriggeredAttacker")) {
-                list.add(attacker);
-            }
             if (sa.hasParam("ValidCards")) {
                 if (attacker.isValid(sa.getParam("ValidCards").split(","), source.getController(), source, null)
                         || attacker.isValid(sa.getParam("ValidCards").replace("attacking+", "").split(","),
                                 source.getController(), source, null)) {
                     list.add(attacker);
                 }
+            } else {
+                list = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), null);
             }
-            if (list.isEmpty()) {
-                continue;
+            if (sa.hasParam("Defined") && sa.getParam("Defined").startsWith("TriggeredAttacker")) {
+                list.add(attacker);
             }
             if (!list.contains(attacker)) {
                 continue;
@@ -1296,8 +1289,8 @@ public class ComputerUtilCombat {
                 power += Integer.parseInt(att);
             } else {
                 String bonus = AbilityUtils.getSVar(sa, att);
-                if (bonus.contains("TriggerCount$NumBlockers")) {
-                    bonus = TextUtil.fastReplace(bonus, "TriggerCount$NumBlockers", "Number$1");
+                if (bonus.contains("Count$Valid Creature.blockingTriggeredAttacker")) {
+                    bonus = TextUtil.fastReplace(bonus, "Count$Valid Creature.blockingTriggeredAttacker", "Number$1");
                 } else if (bonus.contains("TriggeredPlayersDefenders$Amount")) { // for Melee
                     bonus = TextUtil.fastReplace(bonus, "TriggeredPlayersDefenders$Amount", "Number$1");
                 } else if (bonus.contains("TriggeredAttacker$CardPower")) { // e.g. Arahbo, Roar of the World
@@ -1381,11 +1374,6 @@ public class ComputerUtilCombat {
             , boolean withoutAbilities, boolean withoutCombatStaticAbilities) {
         int toughness = 0;
 
-        //check Exalted only for the first attacker
-        if (combat != null && combat.getAttackers().isEmpty()) {
-            toughness += attacker.getController().countExaltedBonus();
-        }
-
         if (blocker != null && attacker.getName().equals("Shape Stealer")) {
             toughness += blocker.getNetToughness() - attacker.getNetToughness();
         }
@@ -1448,7 +1436,7 @@ public class ComputerUtilCombat {
             if (sa == null) {
                 continue;
             }
-            sa.setActivatingPlayer(source.getController());
+            sa.setActivatingPlayer(source.getController(), true);
 
             if (sa.usesTargeting()) {
                 continue; // targeted pumping not supported
@@ -1464,14 +1452,15 @@ public class ComputerUtilCombat {
                 toughness -= predictDamageTo(attacker, damage, source, false);
                 continue;
             } else if (ApiType.Pump.equals(sa.getApi())) {
+                if (!sa.hasParam("NumDef")) {
+                    continue;
+                }
                 if (sa.hasParam("Cost")) {
                     if (!CostPayment.canPayAdditionalCosts(sa.getPayCosts(), sa)) {
                         continue;
                     }
                 }
-                if (!sa.hasParam("NumDef")) {
-                    continue;
-                }
+
                 final String defined = sa.getParam("Defined");
                 CardCollection list = AbilityUtils.getDefinedCards(source, defined, sa);
                 if (defined != null && defined.startsWith("TriggeredAttacker")) {
@@ -1489,14 +1478,17 @@ public class ComputerUtilCombat {
                     toughness += Integer.parseInt(def);
                 } else {
                     String bonus = AbilityUtils.getSVar(sa, def);
-                    if (bonus.contains("TriggerCount$NumBlockers")) {
-                        bonus = TextUtil.fastReplace(bonus, "TriggerCount$NumBlockers", "Number$1");
+                    if (bonus.contains("Count$Valid Creature.blockingTriggeredAttacker")) {
+                        bonus = TextUtil.fastReplace(bonus, "Count$Valid Creature.blockingTriggeredAttacker", "Number$1");
                     } else if (bonus.contains("TriggeredPlayersDefenders$Amount")) { // for Melee
                         bonus = TextUtil.fastReplace(bonus, "TriggeredPlayersDefenders$Amount", "Number$1");
                     }
                     toughness += AbilityUtils.calculateAmount(source, bonus, sa);
                 }
             } else if (ApiType.PumpAll.equals(sa.getApi())) {
+                if (!sa.hasParam("NumDef")) {
+                    continue;
+                }
                 if (sa.hasParam("Cost")) {
                     if (!CostPayment.canPayAdditionalCosts(sa.getPayCosts(), sa)) {
                         continue;
@@ -1506,9 +1498,6 @@ public class ComputerUtilCombat {
                 if (!sa.hasParam("ValidCards")) {
                     continue;
                 }
-                if (!sa.hasParam("NumDef")) {
-                    continue;
-                }
                 if (!attacker.isValid(sa.getParam("ValidCards").replace("attacking+", "").split(","), source.getController(), source, sa)) {
                     continue;
                 }
@@ -1521,8 +1510,8 @@ public class ComputerUtilCombat {
                     toughness += Integer.parseInt(def);
                 } else {
                     String bonus = AbilityUtils.getSVar(sa, def);
-                    if (bonus.contains("TriggerCount$NumBlockers")) {
-                        bonus = TextUtil.fastReplace(bonus, "TriggerCount$NumBlockers", "Number$1");
+                    if (bonus.contains("Count$Valid Creature.blockingTriggeredAttacker")) {
+                        bonus = TextUtil.fastReplace(bonus, "Count$Valid Creature.blockingTriggeredAttacker", "Number$1");
                     } else if (bonus.contains("TriggeredPlayersDefenders$Amount")) { // for Melee
                         bonus = TextUtil.fastReplace(bonus, "TriggeredPlayersDefenders$Amount", "Number$1");
                     }
@@ -1639,9 +1628,8 @@ public class ComputerUtilCombat {
      *            a {@link forge.game.card.Card} object.
      * @return a boolean.
      */
-    public static boolean combatantCantBeDestroyed(Player ai, final Card combatant) {
-        // either indestructible or may regenerate
-        if (combatant.hasKeyword(Keyword.INDESTRUCTIBLE) || ComputerUtil.canRegenerate(ai, combatant)) {
+    public static boolean combatantCantBeDestroyed(final Player ai, final Card combatant) {
+        if (combatant.getCounters(CounterEnumType.SHIELD) > 0) {
             return true;
         }
 
@@ -1650,6 +1638,11 @@ public class ComputerUtilCombat {
             return true;
         }
 
+        // either indestructible or may regenerate
+        if (combatant.hasKeyword(Keyword.INDESTRUCTIBLE) || ComputerUtil.canRegenerate(ai, combatant)) {
+            return true;
+        }
+
         return false;
     }
 
@@ -2047,7 +2040,7 @@ public class ComputerUtilCombat {
 
         final boolean hasTrample = attacker.hasKeyword(Keyword.TRAMPLE);
 
-        if (combat != null && hasTrample && attacker.isAttacking()) {
+        if (combat != null && remaining != null && hasTrample && attacker.isAttacking()) {
             // if attacker has trample and some of its blockers are also blocking others it's generally a good idea
             // to assign those without trample first so we can maximize the damage to the defender
             for (final Card c : remaining) {
@@ -2067,7 +2060,6 @@ public class ComputerUtilCombat {
         if (block.size() == 1) {
             final Card blocker = block.getFirst();
 
-            // trample
             if (hasTrample) {
                 int dmgToKill = getEnoughDamageToKill(blocker, dmgCanDeal, attacker, true);
 
@@ -2123,7 +2115,7 @@ public class ComputerUtilCombat {
             }
         }
         return damageMap;
-    } // setAssignedDamage()
+    }
 
     // how much damage is enough to kill the creature (for AI)
     /**
@@ -2158,24 +2150,15 @@ public class ComputerUtilCombat {
      *            a boolean.
      * @return a int.
      */
-    public static final int getEnoughDamageToKill(final Card c, final int maxDamage, final Card source, final boolean isCombat,
-            final boolean noPrevention) {
-        final int killDamage = getDamageToKill(c, false);
+    public static final int getEnoughDamageToKill(final Card c, final int maxDamage, final Card source, final boolean isCombat, final boolean noPrevention) {
+        int killDamage = getDamageToKill(c, false);
 
-        if (c.hasKeyword(Keyword.INDESTRUCTIBLE) || c.getShieldCount() > 0) {
+        if (c.hasKeyword(Keyword.INDESTRUCTIBLE) || c.getCounters(CounterEnumType.SHIELD) > 0 || (c.getShieldCount() > 0 && c.canBeShielded())) {
             if (!(source.hasKeyword(Keyword.WITHER) || source.hasKeyword(Keyword.INFECT))) {
                 return maxDamage + 1;
             }
-        } else if (source.hasKeyword(Keyword.DEATHTOUCH) && !c.isPlaneswalker()) {
-            for (int i = 1; i <= maxDamage; i++) {
-                if (noPrevention) {
-                    if (c.staticReplaceDamage(i, source, isCombat) > 0) {
-                        return i;
-                    }
-                } else if (predictDamageTo(c, i, source, isCombat) > 0) {
-                    return i;
-                }
-            }
+        } else if (source.hasKeyword(Keyword.DEATHTOUCH) && c.isCreature()) {
+            killDamage = 1;
         }
 
         for (int i = 1; i <= maxDamage; i++) {
@@ -2203,14 +2186,7 @@ public class ComputerUtilCombat {
      */
     public final static int getDamageToKill(final Card c, boolean withShields) {
         int damageShield = withShields ? c.getPreventNextDamageTotalShields() : 0;
-        int killDamage = 0;
-        if (c.isCreature()) {
-            killDamage = Math.max(0, c.getLethalDamage());
-        }
-        if (c.isPlaneswalker()) {
-            int killDamagePW = c.getCurrentLoyalty();
-            killDamage = c.isCreature() ? Math.min(killDamage, killDamagePW) : killDamagePW;
-        }
+        int killDamage = c.getExcessDamageValue(false);
 
         if (killDamage > damageShield
                 && c.hasSVar("DestroyWhenDamaged")) {
@@ -2340,7 +2316,7 @@ public class ComputerUtilCombat {
      * @return transform creature if possible, original creature otherwise
      */
     private final static Card canTransform(Card original) {
-        if (original.isDoubleFaced() && !original.isInAlternateState()) {
+        if (original.isTransformable() && !original.isInAlternateState()) {
             for (SpellAbility sa : original.getSpellAbilities()) {
                 if (sa.getApi() == ApiType.SetState && ComputerUtilCost.canPayCost(sa, original.getController(), false)) {
                     Card transformed = CardUtil.getLKICopy(original);
@@ -2418,7 +2394,6 @@ public class ComputerUtilCombat {
         // (currently looks for the creature with maximum raw power since that's what the AI usually judges by when
         // deciding whether the creature is worth blocking).
         // If the creature doesn't change into anything, returns the original creature.
-        if (attacker == null) { return null; }
         Card attackerAfterTrigs = attacker;
 
         // Test for some special triggers that can change the creature in combat
@@ -2489,21 +2464,23 @@ public class ComputerUtilCombat {
                     }
                 }
                 poison += pd;
-                if (pd > 0 && attacker.hasDoubleStrike()) {
-                    poison += pd;
-                }
                 // TODO: Predict replacement effects for counters (doubled, reduced, additional counters, etc.)
             }
+            // intern toxic effect
+            poison += attacker.getKeywordMagnitude(Keyword.TOXIC);
+        }
+        if (attacker.hasDoubleStrike()) {
+            poison *= 2;
         }
         return poison;
     }
 
-    public static GameEntity addAttackerToCombat(SpellAbility sa, Card attacker, FCollection<GameEntity> defenders) {
+    public static GameEntity addAttackerToCombat(SpellAbility sa, Card attacker, Iterable<? extends GameEntity> defenders) {
         Combat combat = sa.getHostCard().getGame().getCombat();
         if (combat != null) {
             // 1. If the card that spawned the attacker was sent at a planeswalker, attack the same. Consider improving.
             GameEntity def = combat.getDefenderByAttacker(sa.getHostCard());
-            if (def != null && def instanceof Card && ((Card)def).isPlaneswalker() && defenders.contains(def)) {
+            if (def instanceof Card && ((Card)def).isPlaneswalker() && Iterables.contains(defenders, def)) {
                 return def;
             }
             // 2. Otherwise, go through the list of options one by one, choose the first one that can't be blocked profitably.

forge-ai/src/main/java/forge/ai/ComputerUtilCost.java

@@ -7,6 +7,7 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import forge.ai.AiCardMemory.MemorySet;
 import forge.ai.ability.AnimateAi;
+import forge.ai.ability.TokenAi;
 import forge.card.ColorSet;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
@@ -14,13 +15,13 @@ import forge.game.ability.ApiType;
 import forge.game.card.*;
 import forge.game.card.CardPredicates.Presets;
 import forge.game.combat.Combat;
+import forge.game.combat.CombatUtil;
 import forge.game.cost.*;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.Spell;
 import forge.game.spellability.SpellAbility;
-import forge.game.trigger.WrappedAbility;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 import forge.util.TextUtil;
@@ -233,7 +234,7 @@ public class ComputerUtilCost {
         return true;
     }
 
-    public static boolean checkForManaSacrificeCost(final Player ai, final Cost cost, final Card source, final SpellAbility sourceAbility, final boolean effect) {
+    public static boolean checkForManaSacrificeCost(final Player ai, final Cost cost, final SpellAbility sourceAbility, final boolean effect) {
         // TODO cheating via autopay can still happen, need to get the real ai player from controlledBy
         if (cost == null || !ai.isAI()) {
             return true;
@@ -246,18 +247,17 @@ public class ComputerUtilCost {
                     exclude.addAll(AiCardMemory.getMemorySet(ai, MemorySet.PAYS_SAC_COST));
                 }
                 if (part.payCostFromSource()) {
-                    list.add(source);
+                    list.add(sourceAbility.getHostCard());
                 } else if (part.getType().equals("OriginalHost")) {
                     list.add(sourceAbility.getOriginalHost());
                 } else if (part.getAmount().equals("All")) {
                     // Does the AI want to use Sacrifice All?
                     return false;
                 } else {
-                    final String amount = part.getAmount();
                     Integer c = part.convertAmount();
 
                     if (c == null) {
-                        c = AbilityUtils.calculateAmount(source, amount, sourceAbility);
+                        c = part.getAbilityAmount(sourceAbility);
                     }
                     final AiController aic = ((PlayerControllerAi)ai.getController()).getAi();
                     CardCollectionView choices = aic.chooseSacrificeType(part.getType(), sourceAbility, effect, c, exclude);
@@ -407,7 +407,7 @@ public class ComputerUtilCost {
     }
 
     /**
-     * Check creature sacrifice cost.
+     * Check TapType cost.
      *
      * @param cost
      *            the cost
@@ -435,9 +435,7 @@ public class ComputerUtilCost {
                     final int vehicleValue = ComputerUtilCard.evaluateCreature(vehicle);
                     String totalP = type.split("withTotalPowerGE")[1];
                     type = TextUtil.fastReplace(type, TextUtil.concatNoSpace("+withTotalPowerGE", totalP), "");
-                    CardCollection exclude = CardLists.getValidCards(
-                            new CardCollection(ai.getCardsIn(ZoneType.Battlefield)), type.split(";"),
-                            source.getController(), source, sa);
+                    CardCollection exclude = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), type.split(";"), source.getController(), source, sa);
                     exclude = CardLists.filter(exclude, new Predicate<Card>() {
                         @Override
                         public boolean apply(final Card c) {
@@ -525,13 +523,14 @@ public class ComputerUtilCost {
      */
     public static boolean canPayCost(final SpellAbility sa, final Player player, final boolean effect) {
         if (sa.getActivatingPlayer() == null) {
-            sa.setActivatingPlayer(player); // complaints on NPE had came before this line was added.
+            sa.setActivatingPlayer(player, true); // complaints on NPE had came before this line was added.
         }
 
+        final boolean cannotBeCountered = !CardFactoryUtil.isCounterable(sa.getHostCard());
+
         // Check for stuff like Nether Void
         int extraManaNeeded = 0;
         if (sa instanceof Spell) {
-            final boolean cannotBeCountered = !CardFactoryUtil.isCounterable(sa.getHostCard());
             for (Card c : player.getGame().getCardsIn(ZoneType.Battlefield)) {
                 final String snem = c.getSVar("AI_SpellsNeedExtraMana");
                 if (!StringUtils.isBlank(snem)) {
@@ -591,7 +590,7 @@ public class ComputerUtilCost {
         }
 
         // Ward - will be accounted for when rechecking a targeted ability
-        if (!(sa instanceof WrappedAbility) && sa.usesTargeting()) {
+        if (!sa.isTrigger() && sa.usesTargeting() && (!sa.isSpell() || !cannotBeCountered)) {
             for (Card tgt : sa.getTargets().getTargetCards()) {
                 if (tgt.hasKeyword(Keyword.WARD) && tgt.isInPlay() && tgt.getController().isOpponentOf(sa.getHostCard().getController())) {
                     Cost wardCost = ComputerUtilCard.getTotalWardCost(tgt);
@@ -634,7 +633,7 @@ public class ComputerUtilCost {
 
         return ComputerUtilMana.canPayManaCost(sa, player, extraManaNeeded, effect)
                 && CostPayment.canPayAdditionalCosts(sa.getPayCosts(), sa);
-    } // canPayCost()
+    }
 
     public static boolean willPayUnlessCost(SpellAbility sa, Player payer, Cost cost, boolean alreadyPaid, FCollectionView<Player> payers) {
         final Card source = sa.getHostCard();
@@ -691,6 +690,72 @@ public class ComputerUtilCost {
             return false;
         } else if ("LowPriority".equals(aiLogic) && MyRandom.getRandom().nextInt(100) < 67) {
             return false;
+        } else if (aiLogic != null && aiLogic.startsWith("Fabricate")) {
+            final int n = Integer.valueOf(aiLogic.substring("Fabricate".length()));
+
+            // if host would leave the play or if host is useless, create tokens
+            if (source.hasSVar("EndOfTurnLeavePlay") || ComputerUtilCard.isUselessCreature(payer, source)) {
+                return false;
+            }
+
+            // need a copy for one with extra +1/+1 counter boost,
+            // without causing triggers to run
+            final Card copy = CardUtil.getLKICopy(source);
+            copy.setCounters(CounterEnumType.P1P1, copy.getCounters(CounterEnumType.P1P1) + n);
+            copy.setZone(source.getZone());
+
+            // if host would put into the battlefield attacking
+            Combat combat = source.getGame().getCombat();
+            if (combat != null && combat.isAttacking(source)) {
+                final Player defender = combat.getDefenderPlayerByAttacker(source);
+                if (defender.canLoseLife() && !ComputerUtilCard.canBeBlockedProfitably(defender, copy, true)) {
+                    return true;
+                }
+                return false;
+            }
+
+            // if the host has haste and can attack
+            if (CombatUtil.canAttack(copy)) {
+                for (final Player opp : payer.getOpponents()) {
+                    if (CombatUtil.canAttack(copy, opp) &&
+                            opp.canLoseLife() &&
+                            !ComputerUtilCard.canBeBlockedProfitably(opp, copy, true))
+                        return true;
+                }
+            }
+
+            // TODO check for trigger to turn token ETB into +1/+1 counter for host
+            // TODO check for trigger to turn token ETB into damage or life loss for opponent
+            // in this cases Token might be prefered even if they would not survive
+            final Card tokenCard = TokenAi.spawnToken(payer, sa);
+
+            // Token would not survive
+            if (!tokenCard.isCreature() || tokenCard.getNetToughness() < 1) {
+                return true;
+            }
+
+            // Special Card logic, this one try to median its power with the number of artifacts
+            if ("Marionette Master".equals(source.getName())) {
+                CardCollection list = CardLists.filter(payer.getCardsIn(ZoneType.Battlefield), Presets.ARTIFACTS);
+                return list.size() >= copy.getNetPower();
+            } else if ("Cultivator of Blades".equals(source.getName())) {
+                // Cultivator does try to median with number of Creatures
+                CardCollection list = payer.getCreaturesInPlay();
+                return list.size() >= copy.getNetPower();
+            }
+
+            // evaluate Creature with +1/+1
+            int evalCounter = ComputerUtilCard.evaluateCreature(copy);
+
+            final CardCollection tokenList = new CardCollection(source);
+            for (int i = 0; i < n; ++i) {
+                tokenList.add(TokenAi.spawnToken(payer, sa));
+            }
+
+            // evaluate Host with Tokens
+            int evalToken = ComputerUtilCard.evaluateCreatureList(tokenList);
+
+            return evalToken < evalCounter;
         }
 
         // Check for shocklands and similar ETB replacement effects
@@ -709,9 +774,12 @@ public class ComputerUtilCost {
                             // Check if the AI intends to play the card and if it can pay for it with the mana it has
                             boolean willPlay = ComputerUtil.hasReasonToPlayCardThisTurn(payer, c);
                             boolean canPay = c.getManaCost().canBePaidWithAvailable(ColorSet.fromNames(getAvailableManaColors(payer, source)).getColor());
-                            return canPay && willPlay;
+                            if (canPay && willPlay) {
+                                return true;
+                            }
                         }
                     }
+                    return false;
                 }
             }
         }
@@ -721,6 +789,21 @@ public class ComputerUtilCost {
             return false;
         }
 
+        // ward or human misplay
+        if (ApiType.Counter.equals(sa.getApi())) {
+            List<SpellAbility> spells = AbilityUtils.getDefinedSpellAbilities(source, sa.getParamOrDefault("Defined", "Targeted"), sa);
+            for (SpellAbility toBeCountered : spells) {
+                if (toBeCountered.isSpell() && !CardFactoryUtil.isCounterable(toBeCountered.getHostCard())) {
+                    return false;
+                }
+                // no reason to pay if we don't plan to confirm
+                if (toBeCountered.isOptionalTrigger() && !SpellApiToAi.Converter.get(toBeCountered.getApi()).doTriggerNoCostWithSubs(payer, toBeCountered, false)) {
+                    return false;
+                }
+                // TODO check hasFizzled
+            }
+        }
+
         // AI was crashing because the blank ability used to pay costs
         // Didn't have any of the data on the original SA to pay dependant costs
 
@@ -795,7 +878,7 @@ public class ComputerUtilCost {
             }
         }
 
-        val = ObjectUtils.min(val, abCost.getMaxForNonManaX(root, ai, false));
+        val = ObjectUtils.min(val, abCost.getMaxForNonManaX(root, ai, effect));
 
         if (val != null && val > 0) {
             // filter cost parts for preferences, don't choose X > than possible preferences

forge-ai/src/main/java/forge/ai/ComputerUtilMana.java

@@ -82,7 +82,7 @@ public class ComputerUtilMana {
     public static boolean hasEnoughManaSourcesToCast(final SpellAbility sa, final Player ai) {
         if (ai == null || sa == null)
             return false;
-        sa.setActivatingPlayer(ai);
+        sa.setActivatingPlayer(ai, true);
         return payManaCost(sa, ai, true, 0, false, false);
     }
 
@@ -90,9 +90,10 @@ public class ComputerUtilMana {
         int score = 0;
 
         for (SpellAbility ability : card.getSpellAbilities()) {
-            ability.setActivatingPlayer(card.getController());
+            ability.setActivatingPlayer(card.getController(), true);
             if (ability.isManaAbility()) {
                 score += ability.calculateScoreForManaAbility();
+                // TODO check TriggersWhenSpent
             }
             else if (!ability.isTrigger() && ability.isPossible()) {
                 score += 13; //add 13 for any non-mana activated abilities
@@ -315,10 +316,6 @@ public class ComputerUtilMana {
                 continue;
             }
 
-            if (!ComputerUtilCost.checkForManaSacrificeCost(ai, ma.getPayCosts(), ma.getHostCard(), ma, ma.isTrigger())) {
-                continue;
-            }
-
             if (sa.getApi() == ApiType.Animate) {
                 // For abilities like Genju of the Cedars, make sure that we're not activating the aura ability by tapping the enchanted card for mana
                 if (saHost.isAura() && "Enchanted".equals(sa.getParam("Defined"))
@@ -376,13 +373,19 @@ public class ComputerUtilMana {
             }
 
             final String typeRes = cost.getSourceRestriction();
-            if (StringUtils.isNotBlank(typeRes) && !paymentChoice.getHostCard().getType().hasStringType(typeRes)) {
+            if (StringUtils.isNotBlank(typeRes) && !paymentChoice.getHostCard().isValid(typeRes, null, null, null)) {
                 continue;
             }
 
-            if (canPayShardWithSpellAbility(toPay, ai, paymentChoice, sa, checkCosts, cost.getXManaCostPaidByColor())) {
-                return paymentChoice;
+            if (!canPayShardWithSpellAbility(toPay, ai, paymentChoice, sa, checkCosts, cost.getXManaCostPaidByColor())) {
+                continue;
             }
+
+            if (!ComputerUtilCost.checkForManaSacrificeCost(ai, ma.getPayCosts(), ma, ma.isTrigger())) {
+                continue;
+            }
+
+            return paymentChoice;
         }
         return null;
     }
@@ -393,10 +396,9 @@ public class ComputerUtilMana {
         String manaProduced = toPay.isSnow() && hostCard.isSnow() ? "S" : GameActionUtil.generatedTotalMana(saPayment);
         //String originalProduced = manaProduced;
 
-        final Map<AbilityKey, Object> repParams = AbilityKey.newMap();
+        final Map<AbilityKey, Object> repParams = AbilityKey.mapFromAffected(hostCard);
         repParams.put(AbilityKey.Mana, manaProduced);
-        repParams.put(AbilityKey.Affected, hostCard);
-        repParams.put(AbilityKey.Player, ai);
+        repParams.put(AbilityKey.Activator, ai);
         repParams.put(AbilityKey.AbilityMana, saPayment); // RootAbility
 
         // TODO Damping Sphere might replace later?
@@ -515,10 +517,9 @@ public class ComputerUtilMana {
 
         // Run triggers like Nissa
         final Map<AbilityKey, Object> runParams = AbilityKey.mapFromCard(hostCard);
-        runParams.put(AbilityKey.Player, ai); // assuming AI would only ever gives itself mana
+        runParams.put(AbilityKey.Activator, ai); // assuming AI would only ever gives itself mana
         runParams.put(AbilityKey.AbilityMana, saPayment);
         runParams.put(AbilityKey.Produced, manaProduced);
-        runParams.put(AbilityKey.Activator, ai);
         for (Trigger tr : ai.getGame().getTriggerHandler().getActiveTrigger(TriggerType.TapsForMana, runParams)) {
             SpellAbility trSA = tr.ensureAbility();
             if (trSA == null) {
@@ -530,7 +531,7 @@ public class ComputerUtilMana {
                 if (produced.equals("Chosen")) {
                     produced = MagicColor.toShortString(trSA.getHostCard().getChosenColor());
                 }
-                manaProduced += " " + StringUtils.repeat(produced, pAmount);
+                manaProduced += " " + StringUtils.repeat(produced, " ", pAmount);
             } else if (ApiType.ManaReflected.equals(trSA.getApi())) {
                 final String colorOrType = trSA.getParamOrDefault("ColorOrType", "Color");
                 // currently Color or Type, Type is colors + colorless
@@ -589,7 +590,7 @@ public class ComputerUtilMana {
                 final Mana mana = CostPayment.getMana(ai, part, sa, cost.getSourceRestriction(), (byte) -1, cost.getXManaCostPaidByColor());
                 if (mana != null) {
                     if (ai.getManaPool().tryPayCostWithMana(sa, cost, mana, false)) {
-                        manaSpentToPay.add(0, mana);
+                        manaSpentToPay.add(mana);
                     }
                 }
             }
@@ -656,7 +657,7 @@ public class ComputerUtilMana {
         ManaPool.refundMana(manaSpentToPay, ai, sa);
 
         return manaSources;
-    } // getManaSourcesToPayCost()
+    }
 
     private static boolean payManaCost(final ManaCostBeingPaid cost, final SpellAbility sa, final Player ai, final boolean test, boolean checkPlayable, boolean effect) {
         AiCardMemory.clearMemorySet(ai, MemorySet.PAYS_TAP_COST);
@@ -680,14 +681,12 @@ public class ComputerUtilMana {
             } else if (mayPlay.hasParam("MayPlayIgnoreType")) {
                 ignoreType = true;
             }
+        } else if (sa.hasParam("ActivateIgnoreColor")) {
+            ignoreColor = true;
         }
         boolean hasConverge = sa.getHostCard().hasConverge();
         ListMultimap<ManaCostShard, SpellAbility> sourcesForShards = getSourcesForShards(cost, sa, ai, test,
-                checkPlayable, manaSpentToPay, hasConverge, ignoreColor, ignoreType);
-
-        if (sourcesForShards == null && !purePhyrexian) {
-            return false;    // no mana abilities to use for paying
-        }
+                checkPlayable, hasConverge, ignoreColor, ignoreType);
 
         int testEnergyPool = ai.getCounters(CounterEnumType.ENERGY);
         final ManaPool manapool = ai.getManaPool();
@@ -708,8 +707,8 @@ public class ComputerUtilMana {
                 }
                 manapool.applyCardMatrix(pay);
 
-                for (byte color : MagicColor.WUBRGC) {
-                    if (manapool.tryPayCostWithColor(color, sa, cost)) {
+                for (byte color : ManaAtom.MANATYPES) {
+                    if (manapool.tryPayCostWithColor(color, sa, cost, manaSpentToPay)) {
                         found = true;
                         break;
                     }
@@ -721,6 +720,11 @@ public class ComputerUtilMana {
             if (cost.isPaid()) {
                 break;
             }
+
+            if (sourcesForShards == null && !purePhyrexian) {
+                break;    // no mana abilities to use for paying
+            }
+
             toPay = getNextShardToPay(cost);
 
             boolean lifeInsteadOfBlack = toPay.isBlack() && ai.hasKeyword("PayLifeInsteadOf:B");
@@ -884,7 +888,7 @@ public class ComputerUtilMana {
         }
 
         return true;
-    } // payManaCost()
+    }
 
     private static void resetPayment(List<SpellAbility> payments) {
         for (SpellAbility sa : payments) {
@@ -912,13 +916,11 @@ public class ComputerUtilMana {
      */
     private static ListMultimap<ManaCostShard, SpellAbility> getSourcesForShards(final ManaCostBeingPaid cost,
             final SpellAbility sa, final Player ai, final boolean test, final boolean checkPlayable,
-            List<Mana> manaSpentToPay, final boolean hasConverge, final boolean ignoreColor, final boolean ignoreType) {
+            final boolean hasConverge, final boolean ignoreColor, final boolean ignoreType) {
         // arrange all mana abilities by color produced.
         final ListMultimap<Integer, SpellAbility> manaAbilityMap = groupSourcesByManaColor(ai, checkPlayable);
         if (manaAbilityMap.isEmpty()) {
             // no mana abilities, bailing out
-            ManaPool.refundMana(manaSpentToPay, ai, sa);
-            CostPayment.handleOfferings(sa, test, cost.isPaid());
             return null;
         }
         if (DEBUG_MANA_PAYMENT) {
@@ -958,7 +960,6 @@ public class ComputerUtilMana {
 
     private static void setExpressColorChoice(final SpellAbility sa, final Player ai, ManaCostBeingPaid cost,
             ManaCostShard toPay, SpellAbility saPayment) {
-
         AbilityManaPart m = saPayment.getManaPart();
         if (m.isComboMana()) {
             getComboManaChoice(ai, saPayment, sa, cost);
@@ -966,7 +967,7 @@ public class ComputerUtilMana {
         else if (saPayment.getApi() == ApiType.ManaReflected) {
             Set<String> reflected = CardUtil.getReflectableManaColors(saPayment);
 
-            for (byte c : MagicColor.WUBRG) {
+            for (byte c : MagicColor.WUBRGC) {
                 if (ai.getManaPool().canPayForShardWithColor(toPay, c) && reflected.contains(MagicColor.toLongString(c))) {
                     m.setExpressChoice(MagicColor.toShortString(c));
                     return;
@@ -1013,7 +1014,7 @@ public class ComputerUtilMana {
 
         if (checkCosts) {
             // Check if AI can still play this mana ability
-            ma.setActivatingPlayer(ai);
+            ma.setActivatingPlayer(ai, true);
             // if the AI can't pay the additional costs skip the mana ability
             if (!CostPayment.canPayAdditionalCosts(ma.getPayCosts(), ma)) {
                 return false;
@@ -1039,7 +1040,7 @@ public class ComputerUtilMana {
         if (ma.getApi() == ApiType.ManaReflected) {
             Set<String> reflected = CardUtil.getReflectableManaColors(ma);
 
-            for (byte c : MagicColor.WUBRG) {
+            for (byte c : MagicColor.WUBRGC) {
                 if (toPay == ManaCostShard.COLORED_X && !ManaCostBeingPaid.canColoredXShardBePaidByColor(MagicColor.toShortString(c), xManaCostPaidByColor)) {
                     continue;
                 }
@@ -1321,9 +1322,9 @@ public class ComputerUtilMana {
     public static ManaCostBeingPaid calculateManaCost(final SpellAbility sa, final boolean test, final int extraMana) {
         Card card = sa.getHostCard();
         Zone castFromBackup = null;
-        if (test && sa.isSpell()) {
+        if (test && sa.isSpell() && !card.isInZone(ZoneType.Stack)) {
             castFromBackup = card.getCastFrom();
-            sa.getHostCard().setCastFrom(card.getZone() != null ? card.getZone() : null);
+            card.setCastFrom(card.getZone() != null ? card.getZone() : null);
         }
 
         Cost payCosts = CostAdjustment.adjust(sa.getPayCosts(), sa);
@@ -1352,7 +1353,10 @@ public class ComputerUtilMana {
                 manaToAdd = 1;
             }
 
-            String xColor = sa.getParamOrDefault("XColor", "1");
+            String xColor = sa.getXColor();
+            if (xColor == null) {
+                xColor = "1";
+            }
             if (card.hasKeyword("Spend only colored mana on X. No more than one mana of each color may be spent this way.")) {
                 xColor = "WUBRGX";
             }
@@ -1406,8 +1410,7 @@ public class ComputerUtilMana {
     public static int getAvailableManaEstimate(final Player p, final boolean checkPlayable) {
         int availableMana = 0;
 
-        final CardCollectionView list = new CardCollection(p.getCardsIn(ZoneType.Battlefield));
-        final List<Card> srcs = CardLists.filter(list, new Predicate<Card>() {
+        final List<Card> srcs = CardLists.filter(p.getCardsIn(ZoneType.Battlefield), new Predicate<Card>() {
             @Override
             public boolean apply(final Card c) {
                 return !c.getManaAbilities().isEmpty();
@@ -1422,7 +1425,7 @@ public class ComputerUtilMana {
             maxProduced = 0;
 
             for (SpellAbility ma : src.getManaAbilities()) {
-                ma.setActivatingPlayer(p);
+                ma.setActivatingPlayer(p, true);
                 if (!checkPlayable || ma.canPlay()) {
                     int costsToActivate = ma.getPayCosts().getCostMana() != null ? ma.getPayCosts().getCostMana().convertAmount() : 0;
                     int producedMana = ma.getParamOrDefault("Produced", "").split(" ").length;
@@ -1461,7 +1464,7 @@ public class ComputerUtilMana {
             @Override
             public boolean apply(final Card c) {
                 for (final SpellAbility am : getAIPlayableMana(c)) {
-                    am.setActivatingPlayer(ai);
+                    am.setActivatingPlayer(ai, true);
                     if (!checkPlayable || (am.canPlay() && am.checkRestrictions(ai))) {
                         return true;
                     }
@@ -1518,7 +1521,7 @@ public class ComputerUtilMana {
                     needsLimitedResources |= !cost.isReusuableResource();
 
                     // if the AI can't pay the additional costs skip the mana ability
-                    m.setActivatingPlayer(ai);
+                    m.setActivatingPlayer(ai, true);
                     if (!CostPayment.canPayAdditionalCosts(m.getPayCosts(), m)) {
                         continue;
                     }
@@ -1587,7 +1590,7 @@ public class ComputerUtilMana {
                 if (DEBUG_MANA_PAYMENT) {
                     System.out.println("DEBUG_MANA_PAYMENT: groupSourcesByManaColor m = " + m);
                 }
-                m.setActivatingPlayer(ai);
+                m.setActivatingPlayer(ai, true);
                 if (checkPlayable && !m.canPlay()) {
                     continue;
                 }
@@ -1616,10 +1619,9 @@ public class ComputerUtilMana {
 
                         // setup produce mana replacement effects
                         String origin = mp.getOrigProduced();
-                        final Map<AbilityKey, Object> repParams = AbilityKey.newMap();
+                        final Map<AbilityKey, Object> repParams = AbilityKey.mapFromAffected(sourceCard);
                         repParams.put(AbilityKey.Mana, origin);
-                        repParams.put(AbilityKey.Affected, sourceCard);
-                        repParams.put(AbilityKey.Player, ai);
+                        repParams.put(AbilityKey.Activator, ai);
                         repParams.put(AbilityKey.AbilityMana, m); // RootAbility
 
                         List<ReplacementEffect> reList = game.getReplacementHandler().getReplacementList(ReplacementType.ProduceMana, repParams, ReplacementLayer.Other);

forge-ai/src/main/java/forge/ai/CreatureEvaluator.java

@@ -10,6 +10,8 @@ import forge.game.card.CounterEnumType;
 import forge.game.cost.CostPayEnergy;
 import forge.game.keyword.Keyword;
 import forge.game.spellability.SpellAbility;
+import forge.game.staticability.StaticAbilityAssignCombatDamageAsUnblocked;
+import forge.game.staticability.StaticAbilityCantAttackBlock;
 import forge.game.staticability.StaticAbilityMustAttack;
 
 import java.util.List;
@@ -44,7 +46,7 @@ public class CreatureEvaluator implements Function<Card, Integer> {
             value += addValue(toughness * 10, "toughness: " + toughness);
 
             // because backside is always stronger the potential makes it better than a single faced card
-            if (c.hasKeyword(Keyword.DAYBOUND)) {
+            if (c.hasKeyword(Keyword.DAYBOUND) && c.isDoubleFaced()) {
                 value += addValue(power * 10, "transforming");
             }
         }
@@ -59,10 +61,12 @@ public class CreatureEvaluator implements Function<Card, Integer> {
         if (c.hasKeyword(Keyword.HORSEMANSHIP)) {
             value += addValue(power * 10, "horses");
         }
-        if (c.hasKeyword("Unblockable")) {
+
+        if (StaticAbilityCantAttackBlock.cantBlockBy(c, null)) {
             value += addValue(power * 10, "unblockable");
         } else {
-            if (c.hasKeyword("You may have CARDNAME assign its combat damage as though it weren't blocked.")) {
+            if (StaticAbilityAssignCombatDamageAsUnblocked.assignCombatDamageAsUnblocked(c)
+                    || StaticAbilityAssignCombatDamageAsUnblocked.assignCombatDamageAsUnblocked(c, false)) {
                 value += addValue(power * 6, "thorns");
             }
             if (c.hasKeyword(Keyword.FEAR)) {
@@ -102,10 +106,11 @@ public class CreatureEvaluator implements Function<Card, Integer> {
                 value += addValue(power * 15, "infect");
             }
             else if (c.hasKeyword(Keyword.WITHER)) {
-                value += addValue(power * 10, "Wither");
+                value += addValue(power * 10, "wither");
             }
-            value += addValue(c.getKeywordMagnitude(Keyword.RAMPAGE), "rampage");
+            value += addValue(c.getKeywordMagnitude(Keyword.TOXIC) * 5, "toxic");
             value += addValue(c.getKeywordMagnitude(Keyword.AFFLICT) * 5, "afflict");
+            value += addValue(c.getKeywordMagnitude(Keyword.RAMPAGE), "rampage");
         }
 
         value += addValue(c.getKeywordMagnitude(Keyword.ANNIHILATOR) * 50, "eldrazi");

forge-ai/src/main/java/forge/ai/GameState.java

@@ -1,29 +1,19 @@
 package forge.ai;
 
-import java.io.BufferedReader;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.util.*;
-import java.util.Map.Entry;
-
-import com.google.common.collect.*;
-import org.apache.commons.lang3.StringUtils;
-
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
 import forge.StaticData;
+import forge.card.CardEdition;
 import forge.card.CardStateName;
 import forge.card.MagicColor;
 import forge.card.mana.ManaAtom;
 import forge.game.Game;
 import forge.game.GameEntity;
-import forge.game.GameObject;
 import forge.game.ability.AbilityFactory;
 import forge.game.ability.effects.DetachedCardEffect;
-import forge.game.card.Card;
-import forge.game.card.CardCloneStates;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardFactory;
-import forge.game.card.CounterType;
+import forge.game.card.*;
 import forge.game.card.token.TokenInfo;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
@@ -38,8 +28,17 @@ import forge.game.zone.PlayerZone;
 import forge.game.zone.ZoneType;
 import forge.item.IPaperCard;
 import forge.item.PaperCard;
+import forge.item.PaperToken;
 import forge.util.TextUtil;
 import forge.util.collect.FCollectionView;
+import org.apache.commons.lang3.StringUtils;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.*;
+import java.util.Map.Entry;
+import java.util.stream.Stream;
 
 public abstract class GameState {
     private static final Map<ZoneType, String> ZONES = new HashMap<>();
@@ -53,27 +52,24 @@ public abstract class GameState {
         ZONES.put(ZoneType.Sideboard, "sideboard");
     }
 
-    private int humanLife = -1;
-    private int computerLife = -1;
-    private String humanCounters = "";
-    private String computerCounters = "";
-    private String humanManaPool = "";
-    private String computerManaPool = "";
-    private String humanPersistentMana = "";
-    private String computerPersistentMana = "";
-    private int humanLandsPlayed = 0;
-    private int computerLandsPlayed = 0;
-    private int humanLandsPlayedLastTurn = 0;
-    private int computerLandsPlayedLastTurn = 0;
+    static class PlayerState {
+        private int life = -1;
+        private String counters = "";
+        private String manaPool = "";
+        private String persistentMana = "";
+        private int landsPlayed = 0;
+        private int landsPlayedLastTurn = 0;
+        private String precast = null;
+        private String putOnStack = null;
+        private final Map<ZoneType, String> cardTexts = new EnumMap<>(ZoneType.class);
+    }
+    private final List<PlayerState> playerStates = new ArrayList<>();
 
     private boolean puzzleCreatorState = false;
 
-    private final Map<ZoneType, String> humanCardTexts = new EnumMap<>(ZoneType.class);
-    private final Map<ZoneType, String> aiCardTexts = new EnumMap<>(ZoneType.class);
-
     private final Map<Integer, Card> idToCard = new HashMap<>();
     private final Map<Card, Integer> cardToAttachId = new HashMap<>();
-    private final Map<Card, Integer> cardToEnchantPlayerId = new HashMap<>();
+    private final Map<Card, Player> cardToEnchantPlayerId = new HashMap<>();
     private final Map<Card, Integer> markedDamage = new HashMap<>();
     private final Map<Card, List<String>> cardToChosenClrs = new HashMap<>();
     private final Map<Card, CardCollection> cardToChosenCards = new HashMap<>();
@@ -99,12 +95,6 @@ public abstract class GameState {
 
     private String tAdvancePhase = "NONE";
 
-    private String precastHuman = null;
-    private String precastAI = null;
-
-    private String putOnStackHuman = null;
-    private String putOnStackAI = null;
-
     private int turn = 1;
 
     private boolean removeSummoningSickness = false;
@@ -135,32 +125,27 @@ public abstract class GameState {
             sb.append("[state]\n");
         }
 
-        sb.append(TextUtil.concatNoSpace("humanlife=", String.valueOf(humanLife), "\n"));
-        sb.append(TextUtil.concatNoSpace("ailife=", String.valueOf(computerLife), "\n"));
-        sb.append(TextUtil.concatNoSpace("humanlandsplayed=", String.valueOf(humanLandsPlayed), "\n"));
-        sb.append(TextUtil.concatNoSpace("ailandsplayed=", String.valueOf(computerLandsPlayed), "\n"));
-        sb.append(TextUtil.concatNoSpace("humanlandsplayedlastturn=", String.valueOf(humanLandsPlayedLastTurn), "\n"));
-        sb.append(TextUtil.concatNoSpace("ailandsplayedlastturn=", String.valueOf(computerLandsPlayedLastTurn), "\n"));
         sb.append(TextUtil.concatNoSpace("turn=", String.valueOf(turn), "\n"));
-
-        if (!humanCounters.isEmpty()) {
-            sb.append(TextUtil.concatNoSpace("humancounters=", humanCounters, "\n"));
-        }
-        if (!computerCounters.isEmpty()) {
-            sb.append(TextUtil.concatNoSpace("aicounters=", computerCounters, "\n"));
-        }
-
-        if (!humanManaPool.isEmpty()) {
-            sb.append(TextUtil.concatNoSpace("humanmanapool=", humanManaPool, "\n"));
-        }
-        if (!computerManaPool.isEmpty()) {
-            sb.append(TextUtil.concatNoSpace("aimanapool=", computerManaPool, "\n"));
-        }
-
         sb.append(TextUtil.concatNoSpace("activeplayer=", tChangePlayer, "\n"));
         sb.append(TextUtil.concatNoSpace("activephase=", tChangePhase, "\n"));
-        appendCards(humanCardTexts, "human", sb);
-        appendCards(aiCardTexts, "ai", sb);
+
+        int playerIndex = 0;
+        for (PlayerState p : playerStates) {
+            String prefix = "p" + playerIndex++;
+            sb.append(TextUtil.concatNoSpace(prefix + "life=", String.valueOf(p.life), "\n"));
+            sb.append(TextUtil.concatNoSpace(prefix + "landsplayed=", String.valueOf(p.landsPlayed), "\n"));
+            sb.append(TextUtil.concatNoSpace(prefix + "landsplayedlastturn=", String.valueOf(p.landsPlayedLastTurn), "\n"));
+            if (!p.counters.isEmpty()) {
+                sb.append(TextUtil.concatNoSpace(prefix + "counters=", p.counters, "\n"));
+            }
+            if (!p.manaPool.isEmpty()) {
+                sb.append(TextUtil.concatNoSpace(prefix + "manapool=", p.manaPool, "\n"));
+            }
+            if (!p.persistentMana.isEmpty()) {
+                sb.append(TextUtil.concatNoSpace(prefix + "persistentmana=", p.persistentMana, "\n"));
+            }
+            appendCards(p.cardTexts, prefix, sb);
+        }
         return sb.toString();
     }
 
@@ -170,44 +155,32 @@ public abstract class GameState {
         }
     }
 
-    public void initFromGame(Game game) throws Exception {
-        FCollectionView<Player> players = game.getPlayers();
-        // Can only serialize a two player game with one AI and one human.
-        if (players.size() != 2) {
-            throw new Exception("Game not supported");
+    public void initFromGame(Game game) {
+        playerStates.clear();
+        for (Player player : game.getPlayers()) {
+            PlayerState p = new PlayerState();
+            p.life = player.getLife();
+            p.landsPlayed = player.getLandsPlayedThisTurn();
+            p.landsPlayedLastTurn = player.getLandsPlayedLastTurn();
+            p.counters = countersToString(player.getCounters());
+            p.manaPool = processManaPool(player.getManaPool());
+            playerStates.add(p);
         }
-        final Player human = game.getPlayers().get(0);
-        final Player ai = game.getPlayers().get(1);
-        if (!human.getController().isGuiPlayer() || !ai.getController().isAI()) {
-            throw new Exception("Game not supported");
-        }
-        humanLife = human.getLife();
-        computerLife = ai.getLife();
-        humanLandsPlayed = human.getLandsPlayedThisTurn();
-        computerLandsPlayed = ai.getLandsPlayedThisTurn();
-        humanLandsPlayedLastTurn = human.getLandsPlayedLastTurn();
-        computerLandsPlayedLastTurn = ai.getLandsPlayedLastTurn();
-        humanCounters = countersToString(human.getCounters());
-        computerCounters = countersToString(ai.getCounters());
-        humanManaPool = processManaPool(human.getManaPool());
-        computerManaPool = processManaPool(ai.getManaPool());
 
-        tChangePlayer = game.getPhaseHandler().getPlayerTurn() == ai ? "ai" : "human";
+        tChangePlayer = "p" + game.getPlayers().indexOf(game.getPhaseHandler().getPlayerTurn());
         tChangePhase = game.getPhaseHandler().getPhase().toString();
         turn = game.getPhaseHandler().getTurn();
-        aiCardTexts.clear();
-        humanCardTexts.clear();
 
         // Mark the cards that need their ID remembered for various reasons
         cardsReferencedByID.clear();
         for (ZoneType zone : ZONES.keySet()) {
-            for (Card card : game.getCardsIn(zone)) {
+            for (Card card : game.getCardsIncludePhasingIn(zone)) {
                 if (card.getExiledWith() != null) {
                     // Remember the ID of the card that exiled this card
                     cardsReferencedByID.add(card.getExiledWith());
                 }
                 if (zone == ZoneType.Battlefield) {
-                    if (!card.getAttachedCards().isEmpty()) {
+                    if (!card.getAllAttachedCards().isEmpty()) {
                         // Remember the ID of cards that have attachments
                         cardsReferencedByID.add(card);
                     }
@@ -239,33 +212,51 @@ public abstract class GameState {
         for (ZoneType zone : ZONES.keySet()) {
             // Init texts to empty, so that restoring will clear the state
             // if the zone had no cards in it (e.g. empty hand).
-            aiCardTexts.put(zone, "");
-            humanCardTexts.put(zone, "");
-            for (Card card : game.getCardsIn(zone)) {
+            for (PlayerState p : playerStates) {
+                p.cardTexts.put(zone, "");
+            }
+            for (Card card : game.getCardsIncludePhasingIn(zone)) {
                 if (card.getName().equals("Puzzle Goal") && card.getOracleText().contains("New Puzzle")) {
                     puzzleCreatorState = true;
                 }
                 if (card instanceof DetachedCardEffect) {
                     continue;
                 }
-                addCard(zone, card.getController() == ai ? aiCardTexts : humanCardTexts, card);
+                int playerIndex = game.getPlayers().indexOf(card.getController());
+                addCard(zone, playerStates.get(playerIndex).cardTexts, card);
             }
         }
     }
 
+    private String getPlayerString(Player p) {
+        return "P" + p.getGame().getPlayers().indexOf(p);
+    }
+
+    private Player parsePlayerString(Game game, String str) {
+        if (str.equalsIgnoreCase("HUMAN")) {
+            return game.getPlayers().get(0);
+        } else if (str.equalsIgnoreCase("AI")) {
+            return game.getPlayers().get(1);
+        } else if (str.startsWith("P") && Character.isDigit(str.charAt(1))) {
+            return game.getPlayers().get(Integer.parseInt(String.valueOf(str.charAt(1))));
+        } else {
+            return game.getPlayers().get(0);
+        }
+    }
+
     private void addCard(ZoneType zoneType, Map<ZoneType, String> cardTexts, Card c) {
         StringBuilder newText = new StringBuilder(cardTexts.get(zoneType));
         if (newText.length() > 0) {
             newText.append(";");
         }
         if (c.isToken()) {
-            newText.append("t:").append(new TokenInfo(c).toString());
+            newText.append("t:").append(new TokenInfo(c));
         } else {
             if (c.getPaperCard() == null) {
                 return;
             }
 
-            if (!c.getMergedCards().isEmpty()) {
+            if (c.hasMergedCard()) {
                 // we have to go by the current top card name here
                 newText.append(c.getTopMergedCard().getPaperCard().getName());
             } else {
@@ -282,8 +273,7 @@ public abstract class GameState {
 
         if (zoneType == ZoneType.Battlefield) {
             if (c.getOwner() != c.getController()) {
-                // TODO: Handle more than 2-player games.
-                newText.append("|Owner:" + (c.getOwner().isAI() ?  "AI" : "Human"));
+                newText.append("|Owner:").append(getPlayerString(c.getOwner()));
             }
             if (c.isTapped()) {
                 newText.append("|Tapped");
@@ -298,7 +288,8 @@ public abstract class GameState {
                 newText.append("|Monstrous");
             }
             if (c.isPhasedOut()) {
-                newText.append("|PhasedOut");
+                newText.append("|PhasedOut:");
+                newText.append(getPlayerString(c.getPhasedOut()));
             }
             if (c.isFaceDown()) {
                 newText.append("|FaceDown");
@@ -317,10 +308,8 @@ public abstract class GameState {
             }
 
             if (c.getPlayerAttachedTo() != null) {
-                // TODO: improve this for game states with more than two players
                 newText.append("|EnchantingPlayer:");
-                Player p = c.getPlayerAttachedTo();
-                newText.append(p.getController().isAI() ? "AI" : "HUMAN");
+                newText.append(getPlayerString(c.getPlayerAttachedTo()));
             } else if (c.isAttachedToEntity()) {
                 newText.append("|AttachedTo:").append(c.getEntityAttachedTo().getId());
             }
@@ -346,11 +335,8 @@ public abstract class GameState {
             }
 
             List<String> chosenCardIds = Lists.newArrayList();
-            for (Object obj : c.getChosenCards()) {
-                if (obj instanceof Card) {
-                    int id = ((Card)obj).getId();
-                    chosenCardIds.add(String.valueOf(id));
-                }
+            for (Card obj : c.getChosenCards()) {
+                chosenCardIds.add(String.valueOf(obj.getId()));
             }
             if (!chosenCardIds.isEmpty()) {
                 newText.append("|ChosenCards:").append(TextUtil.join(chosenCardIds, ","));
@@ -376,7 +362,7 @@ public abstract class GameState {
                 newText.append("|Imprinting:").append(TextUtil.join(imprintedCardIds, ","));
             }
 
-            if (!c.getMergedCards().isEmpty()) {
+            if (c.hasMergedCard()) {
                 List<String> mergedCardNames = new ArrayList<>();
                 for (Card merged : c.getMergedCards()) {
                     if (c.getTopMergedCard() == merged) {
@@ -463,16 +449,36 @@ public abstract class GameState {
 
     public void parse(InputStream in) throws Exception {
         final BufferedReader br = new BufferedReader(new InputStreamReader(in));
-
-        String line;
-        while ((line = br.readLine()) != null) {
-            parseLine(line);
-        }
+        parse(br.lines());
     }
 
     public void parse(List<String> lines) {
-        for (String line : lines) {
-            parseLine(line);
+        parse(lines.stream());
+    }
+
+    public void parse(Stream<String> lines) {
+        playerStates.clear();
+        lines.forEach(this::parseLine);
+    }
+
+
+    private PlayerState getPlayerState(int index) {
+        while (index >= playerStates.size()) {
+            playerStates.add(new PlayerState());
+        }
+        return playerStates.get(index);
+    }
+
+    private PlayerState getPlayerState(String key) {
+        if (key.startsWith("human")) {
+            return getPlayerState(0);
+        } else if (key.startsWith("ai")) {
+            return getPlayerState(1);
+        } else if (key.startsWith("p") && Character.isDigit(key.charAt(1))) {
+            return getPlayerState(Integer.parseInt(String.valueOf(key.charAt(1))));
+        } else {
+            System.err.println("Unknown player state key: " + key);
+            return new PlayerState();
         }
     }
 
@@ -493,142 +499,56 @@ public abstract class GameState {
             return;
         }
 
-        boolean isHuman = categoryName.startsWith("human");
-
         if (categoryName.equals("turn")) {
             turn = Integer.parseInt(categoryValue);
-        }
-
-        else if (categoryName.equals("removesummoningsickness")) {
+        } else if (categoryName.equals("removesummoningsickness")) {
             removeSummoningSickness = categoryValue.equalsIgnoreCase("true");
-        }
-
-        else if (categoryName.endsWith("life")) {
-            if (isHuman)
-                humanLife = Integer.parseInt(categoryValue);
-            else
-                computerLife = Integer.parseInt(categoryValue);
-        }
-
-        else if (categoryName.endsWith("counters")) {
-            if (isHuman)
-                humanCounters = categoryValue;
-            else
-                computerCounters = categoryValue;
-        }
-
-        else if (categoryName.endsWith("landsplayed")) {
-            if (isHuman)
-                humanLandsPlayed = Integer.parseInt(categoryValue);
-            else
-                computerLandsPlayed = Integer.parseInt(categoryValue);
-        }
-
-        else if (categoryName.endsWith("landsplayedlastturn")) {
-            if (isHuman)
-                humanLandsPlayedLastTurn = Integer.parseInt(categoryValue);
-            else
-                computerLandsPlayedLastTurn = Integer.parseInt(categoryValue);
-        }
-
-        else if (categoryName.endsWith("play") || categoryName.endsWith("battlefield")) {
-            if (isHuman)
-                humanCardTexts.put(ZoneType.Battlefield, categoryValue);
-            else
-                aiCardTexts.put(ZoneType.Battlefield, categoryValue);
-        }
-
-        else if (categoryName.endsWith("hand")) {
-            if (isHuman)
-                humanCardTexts.put(ZoneType.Hand, categoryValue);
-            else
-                aiCardTexts.put(ZoneType.Hand, categoryValue);
-        }
-
-        else if (categoryName.endsWith("graveyard")) {
-            if (isHuman)
-                humanCardTexts.put(ZoneType.Graveyard, categoryValue);
-            else
-                aiCardTexts.put(ZoneType.Graveyard, categoryValue);
-        }
-
-        else if (categoryName.endsWith("library")) {
-            if (isHuman)
-                humanCardTexts.put(ZoneType.Library, categoryValue);
-            else
-                aiCardTexts.put(ZoneType.Library, categoryValue);
-        }
-
-        else if (categoryName.endsWith("exile")) {
-            if (isHuman)
-                humanCardTexts.put(ZoneType.Exile, categoryValue);
-            else
-                aiCardTexts.put(ZoneType.Exile, categoryValue);
-        }
-
-        else if (categoryName.endsWith("command")) {
-            if (isHuman)
-                humanCardTexts.put(ZoneType.Command, categoryValue);
-            else
-                aiCardTexts.put(ZoneType.Command, categoryValue);
-        }
-
-        else if (categoryName.endsWith("sideboard")) {
-            if (isHuman)
-                humanCardTexts.put(ZoneType.Sideboard, categoryValue);
-            else
-                aiCardTexts.put(ZoneType.Sideboard, categoryValue);
-        }
-
-        else if (categoryName.startsWith("ability")) {
+        } else if (categoryName.endsWith("life")) {
+            getPlayerState(categoryName).life = Integer.parseInt(categoryValue);
+        } else if (categoryName.endsWith("counters")) {
+            getPlayerState(categoryName).counters = categoryValue;
+        } else if (categoryName.endsWith("landsplayed")) {
+            getPlayerState(categoryName).landsPlayed = Integer.parseInt(categoryValue);
+        } else if (categoryName.endsWith("landsplayedlastturn")) {
+            getPlayerState(categoryName).landsPlayedLastTurn = Integer.parseInt(categoryValue);
+        } else if (categoryName.endsWith("play") || categoryName.endsWith("battlefield")) {
+            getPlayerState(categoryName).cardTexts.put(ZoneType.Battlefield, categoryValue);
+        } else if (categoryName.endsWith("hand")) {
+            getPlayerState(categoryName).cardTexts.put(ZoneType.Hand, categoryValue);
+        } else if (categoryName.endsWith("graveyard")) {
+            getPlayerState(categoryName).cardTexts.put(ZoneType.Graveyard, categoryValue);
+        } else if (categoryName.endsWith("library")) {
+            getPlayerState(categoryName).cardTexts.put(ZoneType.Library, categoryValue);
+        } else if (categoryName.endsWith("exile")) {
+            getPlayerState(categoryName).cardTexts.put(ZoneType.Exile, categoryValue);
+        } else if (categoryName.endsWith("command")) {
+            getPlayerState(categoryName).cardTexts.put(ZoneType.Command, categoryValue);
+        } else if (categoryName.endsWith("sideboard")) {
+            getPlayerState(categoryName).cardTexts.put(ZoneType.Sideboard, categoryValue);
+        } else if (categoryName.startsWith("ability")) {
             abilityString.put(categoryName.substring("ability".length()), categoryValue);
-        }
-
-        else if (categoryName.endsWith("precast")) {
-            if (isHuman)
-                precastHuman = categoryValue;
-            else
-                precastAI = categoryValue;
-        }
-
-        else if (categoryName.endsWith("putonstack")) {
-            if (isHuman)
-                putOnStackHuman = categoryValue;
-            else
-                putOnStackAI = categoryValue;
-        }
-
-        else if (categoryName.endsWith("manapool")) {
-            if (isHuman)
-                humanManaPool = categoryValue;
-            else
-                computerManaPool = categoryValue;
-        }
-
-        else if (categoryName.endsWith("persistentmana")) {
-            if (isHuman)
-                humanPersistentMana = categoryValue;
-            else
-                computerPersistentMana = categoryValue;
-        }
-
-        else {
-            System.out.println("Unknown key: " + categoryName);
+        } else if (categoryName.endsWith("precast")) {
+            getPlayerState(categoryName).precast = categoryValue;
+        } else if (categoryName.endsWith("putonstack")) {
+            getPlayerState(categoryName).putOnStack = categoryValue;
+        } else if (categoryName.endsWith("manapool")) {
+            getPlayerState(categoryName).manaPool = categoryValue;
+        } else if (categoryName.endsWith("persistentmana")) {
+            getPlayerState(categoryName).persistentMana = categoryValue;
+        } else {
+            System.err.println("Unknown key: " + categoryName);
         }
     }
 
     public void applyToGame(final Game game) {
-        game.getAction().invoke(new Runnable() {
-            @Override
-            public void run() {
-                applyGameOnThread(game);
-            }
-        });
+        game.getAction().invoke(() -> applyGameOnThread(game));
     }
 
     protected void applyGameOnThread(final Game game) {
-        final Player human = game.getPlayers().get(0);
-        final Player ai = game.getPlayers().get(1);
+        if (game.getPlayers().size() != playerStates.size()) {
+            throw new RuntimeException("Non-matching number of players, (" +
+                game.getPlayers().size() + " vs. " + playerStates.size() + ")");
+        }
 
         idToCard.clear();
         cardToAttachId.clear();
@@ -645,32 +565,21 @@ public abstract class GameState {
         cardToScript.clear();
         cardAttackMap.clear();
 
-        Player newPlayerTurn = tChangePlayer.equalsIgnoreCase("human") ? human : tChangePlayer.equalsIgnoreCase("ai") ? ai : null;
+        int playerTurn = playerStates.indexOf(getPlayerState(tChangePlayer));
+        Player newPlayerTurn = game.getPlayers().get(playerTurn);
         PhaseType newPhase = tChangePhase.equalsIgnoreCase("none") ? null : PhaseType.smartValueOf(tChangePhase);
         PhaseType advPhase = tAdvancePhase.equalsIgnoreCase("none") ? null : PhaseType.smartValueOf(tAdvancePhase);
 
         // Set stack to resolving so things won't trigger/effects be checked right away
         game.getStack().setResolving(true);
 
-        updateManaPool(human, humanManaPool, true, false);
-        updateManaPool(ai, computerManaPool, true, false);
-        updateManaPool(human, humanPersistentMana, false, true);
-        updateManaPool(ai, computerPersistentMana, false, true);
-
-        if (!humanCounters.isEmpty()) {
-            applyCountersToGameEntity(human, humanCounters);
-        }
-        if (!computerCounters.isEmpty()) {
-            applyCountersToGameEntity(ai, computerCounters);
-        }
-
         game.getPhaseHandler().devModeSet(newPhase, newPlayerTurn, turn);
 
         game.getTriggerHandler().setSuppressAllTriggers(true);
 
-        setupPlayerState(humanLife, humanCardTexts, human, humanLandsPlayed, humanLandsPlayedLastTurn);
-        setupPlayerState(computerLife, aiCardTexts, ai, computerLandsPlayed, computerLandsPlayedLastTurn);
-
+        for (int i = 0; i < playerStates.size(); i++) {
+            setupPlayerState(game.getPlayers().get(i), playerStates.get(i));
+        }
         handleCardAttachments();
         handleChosenEntities();
         handleRememberedEntities();
@@ -708,12 +617,16 @@ public abstract class GameState {
 
         game.getAction().checkStateEffects(true); //ensure state based effects and triggers are updated
 
+        // prevent interactions with objects from old state
+        game.copyLastState();
+
         // Set negative or zero life after state effects if need be, important for some puzzles that rely on
         // pre-setting negative life (e.g. PS_NEO4).
-        if (humanLife <= 0) {
-            human.setLife(humanLife, null);
-        } else if (computerLife <= 0) {
-            ai.setLife(computerLife, null);
+        for (int i = 0; i < playerStates.size(); i++) {
+            int life = playerStates.get(i).life;
+            if (life <= 0) {
+                game.getPlayers().get(i).setLife(life, null);
+            }
         }
     }
 
@@ -744,12 +657,7 @@ public abstract class GameState {
                 produced.put("PersistentMana", "True");
             }
             final AbilityManaPart abMana = new AbilityManaPart(dummy, produced);
-            game.getAction().invoke(new Runnable() {
-                @Override
-                public void run() {
-                    abMana.produceMana(null);
-                }
-            });
+            game.getAction().invoke(() -> abMana.produceMana(null));
         }
     }
 
@@ -823,14 +731,14 @@ public abstract class GameState {
             String id = rememberedEnts.getValue();
 
             Card exiledWith = idToCard.get(Integer.parseInt(id));
+            exiledWith.addExiledCard(c);
             c.setExiledWith(exiledWith);
             c.setExiledBy(exiledWith.getController());
         }
     }
 
     private int parseTargetInScript(final String tgtDef) {
-        int tgtID = TARGET_NONE;
-
+        int tgtID;
         if (tgtDef.equalsIgnoreCase("human")) {
             tgtID = TARGET_HUMAN;
         } else if (tgtDef.equalsIgnoreCase("ai")) {
@@ -861,9 +769,7 @@ public abstract class GameState {
         }
 
         if (sa.hasParam("RememberTargets")) {
-            for (final GameObject o : sa.getTargets()) {
-                sa.getHostCard().addRemembered(o);
-            }
+            sa.getHostCard().addRemembered(sa.getTargets());
         }
     }
 
@@ -907,7 +813,6 @@ public abstract class GameState {
                     for (SpellAbility ab : saList) {
                         if (ab.getDescription().startsWith("Awaken")) {
                             ab.setActivatingPlayer(c.getController());
-                            ab.getSubAbility().setActivatingPlayer(c.getController());
                             // target for Awaken is set in its first subability
                             handleScriptedTargetingForSA(game, ab.getSubAbility(), tgtID);
                             sa = kwName.equals("AwakenOnly") ? ab.getSubAbility() : ab;
@@ -972,37 +877,23 @@ public abstract class GameState {
     }
 
     private void handlePrecastSpells(final Game game) {
-        Player human = game.getPlayers().get(0);
-        Player ai = game.getPlayers().get(1);
-
-        if (precastHuman != null) {
-            String[] spellList = TextUtil.split(precastHuman, ';');
-            for (String spell : spellList) {
-                precastSpellFromCard(spell, human, game);
-            }
-        }
-        if (precastAI != null) {
-            String[] spellList = TextUtil.split(precastAI, ';');
-            for (String spell : spellList) {
-                precastSpellFromCard(spell, ai, game);
+        for (int i = 0; i < playerStates.size(); i++) {
+            if (playerStates.get(i).precast != null) {
+                String[] spellList = TextUtil.split(playerStates.get(i).precast, ';');
+                for (String spell : spellList) {
+                    precastSpellFromCard(spell, game.getPlayers().get(i), game);
+                }
             }
         }
     }
 
     private void handleAddSAsToStack(final Game game) {
-        Player human = game.getPlayers().get(0);
-        Player ai = game.getPlayers().get(1);
-
-        if (putOnStackHuman != null) {
-            String[] spellList = TextUtil.split(putOnStackHuman, ';');
-            for (String spell : spellList) {
-                precastSpellFromCard(spell, human, game, true);
-            }
-        }
-        if (putOnStackAI != null) {
-            String[] spellList = TextUtil.split(putOnStackAI, ';');
-            for (String spell : spellList) {
-                precastSpellFromCard(spell, ai, game, true);
+        for (int i = 0; i < playerStates.size(); i++) {
+            if (playerStates.get(i).putOnStack != null) {
+                String[] spellList = TextUtil.split(playerStates.get(i).putOnStack, ';');
+                for (String spell : spellList) {
+                    precastSpellFromCard(spell, game.getPlayers().get(i), game, true);
+                }
             }
         }
     }
@@ -1134,18 +1025,13 @@ public abstract class GameState {
             Card attachedTo = idToCard.get(entry.getValue());
             Card attacher = entry.getKey();
             if (attacher.isAttachment()) {
-                attacher.attachToEntity(attachedTo);
+                attacher.attachToEntity(attachedTo, null, true);
             }
         }
 
-        // Enchant players by ID
-        for (Entry<Card, Integer> entry : cardToEnchantPlayerId.entrySet()) {
-            // TODO: improve this for game states with more than two players
-            Card attacher = entry.getKey();
-            Game game = attacher.getGame();
-            Player attachedTo = entry.getValue() == TARGET_AI ? game.getPlayers().get(1) : game.getPlayers().get(0);
-
-            attacher.attachToEntity(attachedTo);
+        // Enchant players
+        for (Entry<Card, Player> entry : cardToEnchantPlayerId.entrySet()) {
+            entry.getKey().attachToEntity(entry.getValue(), null);
         }
     }
 
@@ -1180,11 +1066,9 @@ public abstract class GameState {
         }
         top.addMergedCard(bottom);
 
-        if (top.getMutatedTimestamp() != -1) {
-            top.removeCloneState(top.getMutatedTimestamp());
-        }
+        top.removeMutatedStates();
 
-        final Long ts = game.getNextTimestamp();
+        final long ts = game.getNextTimestamp();
         top.setMutatedTimestamp(ts);
         if (top.getCurrentStateName() != CardStateName.FaceDown) {
             final CardCloneStates mutatedStates = CardFactory.getMutatedCloneStates(top, null/*FIXME*/);
@@ -1203,11 +1087,11 @@ public abstract class GameState {
         String[] allCounterStrings = counterString.split(",");
         for (final String counterPair : allCounterStrings) {
             String[] pair = counterPair.split("=", 2);
-            entity.addCounterInternal(CounterType.getType(pair[0]), Integer.parseInt(pair[1]), null, false, null);
+            entity.addCounterInternal(CounterType.getType(pair[0]), Integer.parseInt(pair[1]), null, false, null, null);
         }
     }
 
-    private void setupPlayerState(int life, Map<ZoneType, String> cardTexts, final Player p, final int landsPlayed, final int landsPlayedLastTurn) {
+    private void setupPlayerState(final Player p, final PlayerState state) {
         // Lock check static as we setup player state
 
         // Clear all zones first, this ensures that any lingering cards and effects (e.g. in command zone) get cleared up
@@ -1219,14 +1103,14 @@ public abstract class GameState {
         p.setCommanders(Lists.newArrayList());
 
         Map<ZoneType, CardCollectionView> playerCards = new EnumMap<>(ZoneType.class);
-        for (Entry<ZoneType, String> kv : cardTexts.entrySet()) {
+        for (Entry<ZoneType, String> kv : state.cardTexts.entrySet()) {
             String value = kv.getValue();
             playerCards.put(kv.getKey(), processCardsForZone(value.isEmpty() ? new String[0] : value.split(";"), p));
         }
 
-        if (life >= 0) p.setLife(life, null);
-        p.setLandsPlayedThisTurn(landsPlayed);
-        p.setLandsPlayedLastTurn(landsPlayedLastTurn);
+        if (state.life >= 0) p.setLife(state.life, null);
+        p.setLandsPlayedThisTurn(state.landsPlayed);
+        p.setLandsPlayedLastTurn(state.landsPlayedLastTurn);
 
         p.clearPaidForSA();
 
@@ -1275,6 +1159,13 @@ public abstract class GameState {
         for (Card cmd : p.getCommanders()) {
             p.getZone(ZoneType.Command).add(Player.createCommanderEffect(p.getGame(), cmd));
         }
+
+        updateManaPool(p, state.manaPool, true, false);
+        updateManaPool(p, state.persistentMana, false, true);
+
+        if (!state.counters.isEmpty()) {
+            applyCountersToGameEntity(p, state.counters);
+        }
     }
 
     /**
@@ -1307,6 +1198,15 @@ public abstract class GameState {
                 // TODO Make sure Game State conversion works with new tokens
                 String tokenStr = cardinfo[0].substring(2);
                 c = new TokenInfo(tokenStr).makeOneToken(player);
+            } else if (cardinfo[0].startsWith("T:")) {
+                String tokenStr = cardinfo[0].substring(2);
+                PaperToken token = StaticData.instance().getAllTokens().getToken(tokenStr,
+                        setCode != null ? setCode : CardEdition.UNKNOWN.getName());
+                if (token == null) {
+                    System.err.println("ERROR: Tried to create a non-existent token named " + cardinfo[0] + " when loading game state!");
+                    continue;
+                }
+                c = Card.fromPaperCard(token, player, player.getGame());
             } else {
                 PaperCard pc = StaticData.instance().getCommonCards().getCard(cardinfo[0], setCode);
                 if (pc == null) {
@@ -1329,7 +1229,8 @@ public abstract class GameState {
                 } else if (info.startsWith("Monstrous")) {
                     c.setMonstrous(true);
                 } else if (info.startsWith("PhasedOut")) {
-                    c.setPhasedOut(true);
+                    String tgt = info.substring(info.indexOf(':') + 1);
+                    c.setPhasedOut(parsePlayerString(player.getGame(), tgt));
                 } else if (info.startsWith("Counters:")) {
                     applyCountersToGameEntity(c, info.substring(info.indexOf(':') + 1));
                 } else if (info.startsWith("SummonSick")) {
@@ -1341,15 +1242,18 @@ public abstract class GameState {
                     }
                 } else if (info.startsWith("Transformed")) {
                     c.setState(CardStateName.Transformed, true);
+                    c.setBackSide(true);
                 } else if (info.startsWith("Flipped")) {
                     c.setState(CardStateName.Flipped, true);
                 } else if (info.startsWith("Meld")) {
                     c.setState(CardStateName.Meld, true);
+                    c.setBackSide(true);
                 } else if (info.startsWith("Modal")) {
                     c.setState(CardStateName.Modal, true);
+                    c.setBackSide(true);
                 }
                 else if (info.startsWith("OnAdventure")) {
-                    String abAdventure = "DB$ Effect | RememberObjects$ Self | StaticAbilities$ Play | ExileOnMoved$ Exile | Duration$ Permanent | ConditionDefined$ Self | ConditionPresent$ Card.nonCopiedSpell";
+                    String abAdventure = "DB$ Effect | RememberObjects$ Self | StaticAbilities$ Play | ForgetOnMoved$ Exile | Duration$ Permanent | ConditionDefined$ Self | ConditionPresent$ Card.nonCopiedSpell";
                     SpellAbility saAdventure = AbilityFactory.getAbility(abAdventure, c);
                     StringBuilder sbPlay = new StringBuilder();
                     sbPlay.append("Mode$ Continuous | MayPlay$ True | EffectZone$ Command | Affected$ Card.IsRemembered+nonAdventure");
@@ -1371,16 +1275,12 @@ public abstract class GameState {
                     int id = Integer.parseInt(info.substring(info.indexOf(':') + 1));
                     cardToAttachId.put(c, id);
                 } else if (info.startsWith("EnchantingPlayer:")) {
-                    // TODO: improve this for game states with more than two players
                     String tgt = info.substring(info.indexOf(':') + 1);
-                    cardToEnchantPlayerId.put(c, tgt.equalsIgnoreCase("AI") ? TARGET_AI : TARGET_HUMAN);
+                    cardToEnchantPlayerId.put(c, parsePlayerString(player.getGame(), tgt));
                 } else if (info.startsWith("Owner:")) {
-                    // TODO: improve this for game states with more than two players
-                    Player human = player.getGame().getPlayers().get(0);
-                    Player ai = player.getGame().getPlayers().get(1);
                     String owner = info.substring(info.indexOf(':') + 1);
                     Player controller = c.getController();
-                    c.setOwner(owner.equalsIgnoreCase("AI") ? ai : human);
+                    c.setOwner(parsePlayerString(player.getGame(), owner));
                     c.setController(controller, c.getGame().getNextTimestamp());
                 } else if (info.startsWith("Ability:")) {
                     String abString = info.substring(info.indexOf(':') + 1).toLowerCase();

forge-ai/src/main/java/forge/ai/PlayerControllerAi.java

@@ -1,23 +1,11 @@
 package forge.ai;
 
-import java.security.InvalidParameterException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.tuple.ImmutablePair;
-import org.apache.commons.lang3.tuple.Pair;
-
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.ListMultimap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Multimap;
-
 import forge.LobbyPlayer;
 import forge.ai.ability.ProtectAi;
 import forge.card.CardStateName;
@@ -28,48 +16,26 @@ import forge.card.mana.ManaCost;
 import forge.card.mana.ManaCostShard;
 import forge.deck.Deck;
 import forge.deck.DeckSection;
-import forge.game.Game;
-import forge.game.GameEntity;
-import forge.game.GameObject;
-import forge.game.GameType;
+import forge.game.*;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
+import forge.game.ability.effects.CharmEffect;
+import forge.game.card.*;
 import forge.game.card.CardPredicates.Presets;
-import forge.game.card.CardUtil;
-import forge.game.card.CardView;
-import forge.game.card.CounterType;
 import forge.game.combat.Combat;
 import forge.game.cost.Cost;
-import forge.game.cost.CostAdjustment;
-import forge.game.cost.CostExile;
+import forge.game.cost.CostEnlist;
 import forge.game.cost.CostPart;
 import forge.game.cost.CostPartMana;
+import forge.game.keyword.Keyword;
 import forge.game.keyword.KeywordInterface;
 import forge.game.mana.Mana;
 import forge.game.mana.ManaConversionMatrix;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
-import forge.game.player.DelayedReveal;
-import forge.game.player.Player;
-import forge.game.player.PlayerActionConfirmMode;
-import forge.game.player.PlayerController;
-import forge.game.player.PlayerView;
+import forge.game.player.*;
 import forge.game.replacement.ReplacementEffect;
-import forge.game.spellability.Ability;
-import forge.game.spellability.AbilityStatic;
-import forge.game.spellability.AbilitySub;
-import forge.game.spellability.LandAbility;
-import forge.game.spellability.OptionalCost;
-import forge.game.spellability.OptionalCostValue;
-import forge.game.spellability.Spell;
-import forge.game.spellability.SpellAbility;
-import forge.game.spellability.SpellAbilityStackInstance;
-import forge.game.spellability.TargetChoices;
+import forge.game.spellability.*;
 import forge.game.trigger.WrappedAbility;
 import forge.game.zone.ZoneType;
 import forge.item.PaperCard;
@@ -78,6 +44,12 @@ import forge.util.ITriggerEvent;
 import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 import forge.util.collect.FCollectionView;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.security.InvalidParameterException;
+import java.util.*;
 
 
 /**
@@ -114,7 +86,7 @@ public class PlayerControllerAi extends PlayerController {
 
     @Override
     public SpellAbility getAbilityToPlay(Card hostCard, List<SpellAbility> abilities, ITriggerEvent triggerEvent) {
-        if (abilities.size() == 0) {
+        if (abilities.isEmpty()) {
             return null;
         }
         return abilities.get(0);
@@ -269,8 +241,8 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @Override
-    public boolean confirmAction(SpellAbility sa, PlayerActionConfirmMode mode, String message) {
-        return getAi().confirmAction(sa, mode, message);
+    public boolean confirmAction(SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {
+        return getAi().confirmAction(sa, mode, message, params);
     }
 
     @Override
@@ -341,6 +313,21 @@ public class PlayerControllerAi extends PlayerController {
     public List<Card> exertAttackers(List<Card> attackers) {
         return AiAttackController.exertAttackers(attackers, brains.getAttackAggression());
     }
+ 
+    @Override
+    public List<Card> enlistAttackers(List<Card> attackers) {
+        CardCollection cards = CostEnlist.getCardsForEnlisting(brains.getPlayer());
+        cards = CardLists.filter(cards, CardPredicates.hasGreaterPowerThan(0));
+        CardCollection chosenAttackers = new CardCollection(attackers);
+        ComputerUtilCard.sortByEvaluateCreature(chosenAttackers);
+
+        // do not enlist more than available payment choices (currently ignores multiple instances of Enlist, but can that even happen?)
+        if (attackers.size() > cards.size()) {
+            chosenAttackers = chosenAttackers.subList(0, cards.size());
+        }
+        // TODO check if not needed as defender
+        return chosenAttackers;
+    }
 
     @Override
     public CardCollection orderBlocker(Card attacker, Card blocker, CardCollection oldBlockers) {
@@ -576,10 +563,10 @@ public class PlayerControllerAi extends PlayerController {
 
     @Override
     public String chooseSomeType(String kindOfType, SpellAbility sa, Collection<String> validTypes, List<String> invalidTypes, boolean isOptional) {
-        String chosen = ComputerUtil.chooseSomeType(player, kindOfType, sa.getParam("AILogic"), validTypes, invalidTypes);
+        String chosen = ComputerUtil.chooseSomeType(player, kindOfType, sa, validTypes, invalidTypes);
         if (StringUtils.isBlank(chosen) && !validTypes.isEmpty()) {
             chosen = validTypes.iterator().next();
-            System.err.println("AI has no idea how to choose " + kindOfType +", defaulting to arbitrary element: chosen");
+            System.err.println("AI has no idea how to choose " + kindOfType +", defaulting to arbitrary element: " + chosen);
         }
         return chosen;
     }
@@ -590,8 +577,14 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @Override
-    public boolean confirmReplacementEffect(ReplacementEffect replacementEffect, SpellAbility effectSA, GameEntity affected, String question) {
-        return brains.aiShouldRun(replacementEffect, effectSA, affected);
+    public String chooseSector(Card assignee, String ai, List<String> sectors) {
+        return Aggregates.random(sectors);
+    }
+
+    @Override
+    public PlanarDice choosePDRollToIgnore(List<PlanarDice> rolls) {
+        //TODO create AI logic for this
+        return Aggregates.random(rolls);
     }
 
     @Override
@@ -697,29 +690,12 @@ public class PlayerControllerAi extends PlayerController {
     public boolean payManaOptional(Card c, Cost cost, SpellAbility sa, String prompt, ManaPaymentPurpose purpose) {
         // TODO replace with EmptySa
         final Ability ability = new AbilityStatic(c, cost, null) { @Override public void resolve() {} };
-        ability.setActivatingPlayer(c.getController());
+        ability.setActivatingPlayer(c.getController(), true);
         ability.setCardState(sa.getCardState());
 
-        // FIXME: This is a hack to check if the AI can play the "exile from library" pay costs (Cumulative Upkeep,
-        // e.g. Thought Lash). We have to do it and bail early if the AI can't pay, because otherwise the AI will
-        // pay the cost partially, which should not be possible
-        int nExileLib = 0;
-        List<CostPart> parts = CostAdjustment.adjust(cost, sa).getCostParts();
-        for (final CostPart part : parts) {
-            if (part instanceof CostExile) {
-                CostExile exile = (CostExile) part;
-                if (exile.from == ZoneType.Library) {
-                    nExileLib += exile.convertAmount();
-                }
-            }
-        }
-        if (nExileLib > c.getController().getCardsIn(ZoneType.Library).size()) {
-            return false;
-        }
-        // - End of hack for Exile a card from library Cumulative Upkeep -
-
-        if (ComputerUtilCost.canPayCost(ability, c.getController(), true)) {
-            ComputerUtil.playNoStack(c.getController(), ability, getGame(), true);
+        if (ComputerUtil.playNoStack(c.getController(), ability, getGame(), true)) {
+            // transfer this info for Balduvian Fallen
+            sa.setPayingMana(ability.getPayingMana());
             return true;
         }
         return false;
@@ -727,7 +703,6 @@ public class PlayerControllerAi extends PlayerController {
 
     @Override
     public List<SpellAbility> chooseSaToActivateFromOpeningHand(List<SpellAbility> usableFromOpeningHand) {
-        // AI would play everything. But limits to one copy of (Leyline of Singularity) and (Gemstone Caverns)
         return brains.chooseSaToActivateFromOpeningHand(usableFromOpeningHand);
     }
 
@@ -787,7 +762,7 @@ public class PlayerControllerAi extends PlayerController {
 
     @Override
     public boolean chooseBinary(SpellAbility sa, String question, BinaryChoiceType kindOfChoice, Boolean defaultVal) {
-        switch(kindOfChoice) {
+        switch (kindOfChoice) {
             case TapOrUntap: return true;
             case UntapOrLeaveTapped:
                 Card source = sa.getHostCard();
@@ -798,7 +773,7 @@ public class PlayerControllerAi extends PlayerController {
                         case "Never":
                             return false;
                         case "NothingRemembered":
-                            if (source.getRememberedCount() == 0) {
+                            if (!source.hasRemembered()) {
                                 return true;
                             } else {
                                 Card rem = (Card) source.getFirstRemembered();
@@ -808,7 +783,7 @@ public class PlayerControllerAi extends PlayerController {
                             }
                             break;
                         case "BetterTgtThanRemembered":
-                            if (source.getRememberedCount() > 0) {
+                            if (source.hasRemembered()) {
                                 Card rem = (Card) source.getFirstRemembered();
                                 //  avoid pumping opponent creature
                                 if (!rem.isInPlay() || rem.getController().isOpponentOf(source.getController())) {
@@ -939,11 +914,81 @@ public class PlayerControllerAi extends PlayerController {
         return SpellApiToAi.Converter.get(api).chooseCounterType(options, sa, params);
     }
 
+    @Override
+    public String chooseKeywordForPump(final List<String> options, final SpellAbility sa, final String prompt, final Card tgtCard) {
+        if (options.size() <= 1) {
+            return Iterables.getFirst(options, null);
+        }
+        List<String> possible = Lists.newArrayList();
+        CardCollection oppUntappedCreatures = CardLists.filter(player.getOpponents().getCreaturesInPlay(), CardPredicates.Presets.UNTAPPED);
+        if (tgtCard != null) {
+            for (String kw : options) {
+                if (tgtCard.hasKeyword(kw)) {
+                    continue;
+                } else if ("Indestructible".equals(kw)) {
+                    if (oppUntappedCreatures.isEmpty()) {
+                        continue; // no threats on battlefield - removal still a concern perhaps?
+                    } else {
+                        possible.clear();
+                        possible.add(kw); // prefer Indestructible above all else
+                        break;
+                    }
+                } else if ("Flying".equals(kw)) {
+                    if (oppUntappedCreatures.isEmpty()) {
+                        continue; // no need for evasion
+                    } else {
+                        boolean flyingGood = true;
+                        for (Card c : oppUntappedCreatures) {
+                            if (c.hasKeyword(Keyword.FLYING) || c.hasKeyword(Keyword.REACH)) {
+                                flyingGood = false;
+                                break;
+                            }
+                        }
+                        if (flyingGood) {
+                            possible.clear();
+                            possible.add(kw); // flying is great when no one else has it
+                            break;
+                        } // even if opp has flying or reach, flying might still be useful so we won't skip it
+                    }
+                } else if (kw.startsWith("Protection from ")) {
+                    //currently, keyword choice lists only include color protection
+                    final String fromWhat = kw.substring(16);
+                    boolean found = false;
+                    for (String color : MagicColor.Constant.ONLY_COLORS) {
+                        if (color.equalsIgnoreCase(fromWhat)) {
+                            CardCollection known = player.getOpponents().getCardsIn(ZoneType.Battlefield);
+                            for (final Card c : known) {
+                                if (c.associatedWithColor(color)) {
+                                    found = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (!found) {
+                        continue;
+                    }
+                }
+                possible.add(kw);
+            }
+        }
+        if (!possible.isEmpty()) {
+            return Aggregates.random(possible);
+        } else {
+            return Aggregates.random(options); // if worst comes to worst, at least do something
+        }
+    }
+
     @Override
     public boolean confirmPayment(CostPart costPart, String prompt, SpellAbility sa) {
         return brains.confirmPayment(costPart); // AI is expected to know what it is paying for at the moment (otherwise add another parameter to this method)
     }
 
+    @Override
+    public boolean confirmReplacementEffect(ReplacementEffect replacementEffect, SpellAbility effectSA, GameEntity affected, String question) {
+        return brains.aiShouldRun(replacementEffect, effectSA, affected);
+    }
+
     @Override
     public ReplacementEffect chooseSingleReplacementEffect(String prompt, List<ReplacementEffect> possibleReplacers) {
         return brains.chooseSingleReplacementEffect(possibleReplacers);
@@ -1017,14 +1062,18 @@ public class PlayerControllerAi extends PlayerController {
         final Card source = sa.getHostCard();
         // TODO replace with EmptySa
         final Ability emptyAbility = new AbilityStatic(source, cost, sa.getTargetRestrictions()) { @Override public void resolve() { } };
-        emptyAbility.setActivatingPlayer(player);
+        emptyAbility.setActivatingPlayer(player, true);
         emptyAbility.setTriggeringObjects(sa.getTriggeringObjects());
         emptyAbility.setSVars(sa.getSVars());
         emptyAbility.setCardState(sa.getCardState());
         emptyAbility.setXManaCostPaid(sa.getRootAbility().getXManaCostPaid());
-        if (ComputerUtilCost.willPayUnlessCost(sa, player, cost, alreadyPaid, allPayers) && ComputerUtilCost.canPayCost(emptyAbility, player, true)) {
-            ComputerUtil.playNoStack(player, emptyAbility, getGame(), true); // AI needs something to resolve to pay that cost
-            return true;
+        if (ComputerUtilCost.willPayUnlessCost(sa, player, cost, alreadyPaid, allPayers)) {
+            boolean result = ComputerUtil.playNoStack(player, emptyAbility, getGame(), true); // AI needs something to resolve to pay that cost
+            if (!emptyAbility.getPaidHash().isEmpty()) {
+                // report info to original sa (Argentum Masticore)
+                sa.setPaidHash(emptyAbility.getPaidHash());
+            }
+            return result;
         }
         return false;
     }
@@ -1032,7 +1081,7 @@ public class PlayerControllerAi extends PlayerController {
     @Override
     public void orderAndPlaySimultaneousSa(List<SpellAbility> activePlayerSAs) {
         for (final SpellAbility sa : getAi().orderPlaySa(activePlayerSAs)) {
-            if (sa.isTrigger()) {
+            if (sa.isTrigger() && !sa.isCopied()) {
                 if (prepareSingleSa(sa.getHostCard(), sa, true)) {
                     ComputerUtil.playStack(sa, player, getGame());
                 }
@@ -1046,16 +1095,14 @@ public class PlayerControllerAi extends PlayerController {
                         }
                     }
 
-                    /* FIXME: the new implementation (below) requires implementing setupNewTargets in the AI controller, among other possible changes, otherwise breaks AI
                     if (sa.isMayChooseNewTargets()) {
-                        sa.setupNewTargets(player);
-                    }
-                    */
-                    if (sa.isMayChooseNewTargets() && !sa.setupTargets()) {
-                        if (sa.isSpell()) {
-                            getGame().getAction().ceaseToExist(sa.getHostCard(), false);
+                        TargetChoices tc = sa.getTargets();
+                        if (!sa.setupTargets()) {
+                            // if AI can't choose targets need to keep old one even if illegal
+                            sa.setTargets(tc);
                         }
-                        continue;
+                        // FIXME: the new implementation (below) requires implementing setupNewTargets in the AI controller, among other possible changes, otherwise breaks AI
+                        // sa.setupNewTargets(player);
                     }
                 }
                 // need finally add the new spell to the stack
@@ -1065,6 +1112,9 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     private boolean prepareSingleSa(final Card host, final SpellAbility sa, boolean isMandatory) {
+        if (sa.getApi() == ApiType.Charm) {
+            return CharmEffect.makeChoices(sa);
+        }
         if (sa.hasParam("TargetingPlayer")) {
             Player targetingPlayer = AbilityUtils.getDefinedPlayers(host, sa.getParam("TargetingPlayer"), sa).get(0);
             sa.setTargetingPlayer(targetingPlayer);
@@ -1088,7 +1138,7 @@ public class PlayerControllerAi extends PlayerController {
         if (tgtSA instanceof Spell) { // Isn't it ALWAYS a spell?
             Spell spell = (Spell) tgtSA;
             // TODO if mandatory AI is only forced to use mana when it's already in the pool
-            if (tgtSA.checkRestrictions(brains.getPlayer()) && (brains.canPlayFromEffectAI(spell, !optional, noManaCost) == AiPlayDecision.WillPlay || !optional)) {
+            if (brains.canPlayFromEffectAI(spell, !optional, noManaCost) == AiPlayDecision.WillPlay || !optional) {
                 if (noManaCost) {
                     return ComputerUtil.playSpellAbilityWithoutPayingManaCost(player, tgtSA, getGame());
                 }

forge-ai/src/main/java/forge/ai/SpecialCardAi.java

@@ -17,33 +17,20 @@
  */
 package forge.ai;
 
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import forge.game.GameEntity;
-import org.apache.commons.lang3.tuple.Pair;
-
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-
 import forge.ai.ability.AnimateAi;
 import forge.card.ColorSet;
 import forge.card.MagicColor;
 import forge.card.mana.ManaCost;
 import forge.game.Game;
+import forge.game.GameEntity;
 import forge.game.GameType;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.card.CardUtil;
-import forge.game.card.CounterEnumType;
+import forge.game.card.*;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.CostPart;
@@ -64,6 +51,11 @@ import forge.util.MyRandom;
 import forge.util.TextUtil;
 import forge.util.maps.LinkedHashMapToAmount;
 import forge.util.maps.MapToAmount;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
 
 /**
  * Special logic for individual cards
@@ -218,7 +210,7 @@ public class SpecialCardAi {
 
             Card animated = AnimateAi.becomeAnimated(sa.getHostCard(), sa.getSubAbility());
             if (sa.getHostCard().canReceiveCounters(CounterEnumType.P1P1)) {
-                animated.addCounterInternal(CounterEnumType.P1P1, 2, ai, false, null);
+                animated.addCounterInternal(CounterEnumType.P1P1, 2, ai, false, null, null);
             }
             boolean isOppEOT = ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn() == ai;
             boolean isValuableAttacker = ph.is(PhaseType.MAIN1, ai) && ComputerUtilCard.doesSpecifiedCreatureAttackAI(ai, animated);
@@ -609,38 +601,6 @@ public class SpecialCardAi {
             }
             return true;
         }
-
-        public static SpellAbility chooseSpellAbility(final Player ai, final SpellAbility sa, final List<SpellAbility> spells) {
-            // TODO: generalize and improve this so that it acts in a more reasonable way and can potentially be used for other cards too
-            List<SpellAbility> best = Lists.newArrayList();
-            List<SpellAbility> possible = Lists.newArrayList();
-            Card tgtCard = sa.getTargetCard();
-            if (tgtCard != null) {
-                for (SpellAbility sp : spells) {
-                    if (SpellApiToAi.Converter.get(sp.getApi()).canPlayAIWithSubs(ai, sp)) {
-                        best.add(sp); // these SAs are prioritized since the AI sees a reason to play them now
-                    }
-                    final List<String> keywords = sp.hasParam("KW") ? Arrays.asList(sp.getParam("KW").split(" & "))
-                            : Lists.newArrayList();
-                    for (String kw : keywords) {
-                        if (!tgtCard.hasKeyword(kw)) {
-                            if ("Indestructible".equals(kw) && ai.getOpponents().getCreaturesInPlay().isEmpty()) {
-                                continue; // nothing to damage or kill the creature with
-                            }
-                            possible.add(sp); // these SAs at least don't duplicate a keyword on the card
-                            break;
-                        }
-                    }
-                }
-            }
-            if (!best.isEmpty()) {
-                return Aggregates.random(best);
-            } else if (!possible.isEmpty()) {
-                return Aggregates.random(possible);
-            } else {
-                return Aggregates.random(spells); // if worst comes to worst, it's a PW +1 ability, so do at least something
-            }
-        }
     }
 
     // Goblin Polka Band

forge-ai/src/main/java/forge/ai/SpellAbilityAi.java

@@ -118,7 +118,7 @@ public abstract class SpellAbilityAi {
     protected boolean checkAiLogic(final Player ai, final SpellAbility sa, final String aiLogic) {
         if (aiLogic.equals("CheckCondition")) {
             SpellAbility saCopy = sa.copy();
-            saCopy.setActivatingPlayer(ai);
+            saCopy.setActivatingPlayer(ai, true);
             return saCopy.metConditions();
         }
 
@@ -253,7 +253,7 @@ public abstract class SpellAbilityAi {
      */
     protected static boolean isSorcerySpeed(final SpellAbility sa, Player ai) {
         return (sa.getRootAbility().isSpell() && sa.getHostCard().isSorcery())
-            || (sa.getRootAbility().isActivatedAbility() && sa.getRestrictions().isSorcerySpeed())
+            || (sa.getRootAbility().isActivatedAbility() && sa.getRootAbility().getRestrictions().isSorcerySpeed())
             || (sa.getRootAbility().isAdventure() && sa.getHostCard().getState(CardStateName.Adventure).getType().isSorcery())
             || (sa.isPwAbility() && !sa.withFlash(sa.getHostCard(), ai));
     }
@@ -305,7 +305,7 @@ public abstract class SpellAbilityAi {
         return SpellApiToAi.Converter.get(ab.getApi()).chkAIDrawback(ab, aiPlayer) && (subAb == null || chkDrawbackWithSubs(aiPlayer, subAb));  
     }
 
-    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {
         System.err.println("Warning: default (ie. inherited from base class) implementation of confirmAction is used by " + sa.getHostCard().getName() + " for " + this.getClass().getName() + ". Consider declaring an overloaded method");
         return true;
     }

forge-ai/src/main/java/forge/ai/SpellApiToAi.java

@@ -32,6 +32,7 @@ public enum SpellApiToAi {
             .put(ApiType.BecomeMonarch, AlwaysPlayAi.class)
             .put(ApiType.BecomesBlocked, BecomesBlockedAi.class)
             .put(ApiType.BidLife, BidLifeAi.class)
+            .put(ApiType.BlankLine, AlwaysPlayAi.class)
             .put(ApiType.Bond, BondAi.class)
             .put(ApiType.Branch, AlwaysPlayAi.class)
             .put(ApiType.Camouflage, ChooseCardAi.class)
@@ -40,6 +41,7 @@ public enum SpellApiToAi {
             .put(ApiType.ChangeX, AlwaysPlayAi.class)
             .put(ApiType.ChangeZone, ChangeZoneAi.class)
             .put(ApiType.ChangeZoneAll, ChangeZoneAllAi.class)
+            .put(ApiType.ChaosEnsues, AlwaysPlayAi.class)
             .put(ApiType.Charm, CharmAi.class)
             .put(ApiType.ChooseCard, ChooseCardAi.class)
             .put(ApiType.ChooseColor, ChooseColorAi.class)
@@ -47,6 +49,7 @@ public enum SpellApiToAi {
             .put(ApiType.ChooseEvenOdd, ChooseEvenOddAi.class)
             .put(ApiType.ChooseNumber, ChooseNumberAi.class)
             .put(ApiType.ChoosePlayer, ChoosePlayerAi.class)
+            .put(ApiType.ChooseSector, AlwaysPlayAi.class)
             .put(ApiType.ChooseSource, ChooseSourceAi.class)
             .put(ApiType.ChooseType, ChooseTypeAi.class)
             .put(ApiType.Clash, ClashAi.class)
@@ -54,6 +57,7 @@ public enum SpellApiToAi {
             .put(ApiType.Cleanup, AlwaysPlayAi.class)
             .put(ApiType.Clone, CloneAi.class)
             .put(ApiType.CompanionChoose, ChooseCompanionAi.class)
+            .put(ApiType.Connive, ConniveAi.class)
             .put(ApiType.CopyPermanent, CopyPermanentAi.class)
             .put(ApiType.CopySpellAbility, CopySpellAbilityAi.class)
             .put(ApiType.ControlPlayer, CannotPlayAi.class)
@@ -71,6 +75,7 @@ public enum SpellApiToAi {
             .put(ApiType.DigMultiple, DigMultipleAi.class)
             .put(ApiType.DigUntil, DigUntilAi.class)
             .put(ApiType.Discard, DiscardAi.class)
+            .put(ApiType.Draft, ChooseCardNameAi.class)
             .put(ApiType.DrainMana, DrainManaAi.class)
             .put(ApiType.Draw, DrawAi.class)
             .put(ApiType.EachDamage, DamageEachAi.class)
@@ -160,6 +165,7 @@ public enum SpellApiToAi {
             .put(ApiType.Sacrifice, SacrificeAi.class)
             .put(ApiType.SacrificeAll, SacrificeAllAi.class)
             .put(ApiType.Scry, ScryAi.class)
+            .put(ApiType.Seek, AlwaysPlayAi.class)
             .put(ApiType.SetInMotion, AlwaysPlayAi.class)
             .put(ApiType.SetLife, LifeSetAi.class)
             .put(ApiType.SetState, SetStateAi.class)
@@ -169,6 +175,7 @@ public enum SpellApiToAi {
             .put(ApiType.StoreSVar, StoreSVarAi.class)
             .put(ApiType.Subgame, AlwaysPlayAi.class)
             .put(ApiType.Surveil, SurveilAi.class)
+            .put(ApiType.TakeInitiative, AlwaysPlayAi.class)
             .put(ApiType.Tap, TapAi.class)
             .put(ApiType.TapAll, TapAllAi.class)
             .put(ApiType.TapOrUntap, TapOrUntapAi.class)
@@ -184,7 +191,6 @@ public enum SpellApiToAi {
             .put(ApiType.WinsGame, GameWinAi.class)
 
             .put(ApiType.DamageResolve, AlwaysPlayAi.class)
-            .put(ApiType.InternalEtbReplacement, CanPlayAsDrawbackAi.class)
             .put(ApiType.InternalLegendaryRule, LegendaryRuleAi.class)
             .put(ApiType.InternalIgnoreEffect, CannotPlayAi.class)
             .build());

forge-ai/src/main/java/forge/ai/ability/AlwaysPlayAi.java

@@ -1,6 +1,8 @@
 package forge.ai.ability;
 
 
+import java.util.Map;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
@@ -16,7 +18,7 @@ public class AlwaysPlayAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {
         return true;
     }
 }

forge-ai/src/main/java/forge/ai/ability/AmassAi.java

@@ -29,7 +29,7 @@ public class AmassAi extends SpellAbilityAi {
         final Game game = ai.getGame();
 
         if (!aiArmies.isEmpty()) {
-            return CardLists.count(aiArmies, CardPredicates.canReceiveCounters(CounterEnumType.P1P1)) > 0;
+            return Iterables.any(aiArmies, CardPredicates.canReceiveCounters(CounterEnumType.P1P1));
         }
         final String tokenScript = "b_0_0_zombie_army";
         final int amount = AbilityUtils.calculateAmount(host, sa.getParamOrDefault("Num", "1"), sa);
@@ -85,7 +85,7 @@ public class AmassAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {
         return true;
     }
 

forge-ai/src/main/java/forge/ai/ability/AnimateAi.java

@@ -240,7 +240,7 @@ public class AnimateAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {
         return player.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2);
     }
     
@@ -261,10 +261,10 @@ public class AnimateAi extends SpellAbilityAi {
         // something is used for animate into creature
         if (types.isCreature()) {
             final Game game = ai.getGame();
-            CardCollectionView list = CardLists.getTargetableCards(game.getCardsIn(ZoneType.Battlefield), sa);
+            CardCollection list = CardLists.getTargetableCards(game.getCardsIn(ZoneType.Battlefield), sa);
 
             // Filter AI-specific targets if provided
-            list = ComputerUtil.filterAITgts(sa, ai, (CardCollection)list, false);
+            list = ComputerUtil.filterAITgts(sa, ai, list, false);
 
             // list is empty, no possible targets
             if (list.isEmpty() && !alwaysActivatePWAbility) {
@@ -500,17 +500,19 @@ public class AnimateAi extends SpellAbilityAi {
         }
 
         // give sVars
-        if (sVars.size() > 0) {
-            for (final String s : sVars) {
-                String actualsVar = source.getSVar(s);
+        if (sa.hasParam("sVars")) {
+            Map<String, String> sVarsMap = Maps.newHashMap();
+            for (final String s : sa.getParam("sVars").split(",")) {
+                String actualsVar = AbilityUtils.getSVar(sa, s);
                 String name = s;
                 if (actualsVar.startsWith("SVar:")) {
                     actualsVar = actualsVar.split("SVar:")[1];
                     name = actualsVar.split(":")[0];
                     actualsVar = actualsVar.split(":")[1];
                 }
-                card.setSVar(name, actualsVar);
+                sVarsMap.put(name, actualsVar);
             }
+            card.addChangedSVars(sVarsMap, timestamp, 0);
         }
         ComputerUtilCard.applyStaticContPT(game, card, null);
     }

forge-ai/src/main/java/forge/ai/ability/AttachAi.java

@@ -22,7 +22,6 @@ import forge.ai.SpecialCardAi;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.GameObject;
-import forge.game.GlobalRuleChange;
 import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
@@ -43,9 +42,9 @@ import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.SpellAbility;
-import forge.game.spellability.SpellPermanent;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.staticability.StaticAbility;
+import forge.game.staticability.StaticAbilityCantAttackBlock;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
 import forge.game.zone.ZoneType;
@@ -78,9 +77,7 @@ public class AttachAi extends SpellAbilityAi {
             }
         }
 
-        if (!ai.getGame().getStaticEffects().getGlobalRuleChange(GlobalRuleChange.noLegendRule)
-                && source.getType().isLegendary() && sa instanceof SpellPermanent
-                && ai.isCardInPlay(source.getName())) {
+        if (source.isAura() && sa.isSpell() && !source.ignoreLegendRule() && ai.isCardInPlay(source.getName())) {
             // Don't play the second copy of a legendary enchantment already in play
 
             // TODO: Add some extra checks for where the AI may want to cast a replacement aura
@@ -125,7 +122,7 @@ public class AttachAi extends SpellAbilityAi {
 
         if (ComputerUtilAbility.getAbilitySourceName(sa).equals("Chained to the Rocks")) {
             final SpellAbility effectExile = AbilityFactory.getAbility(source.getSVar("TrigExile"), source);
-            effectExile.setActivatingPlayer(ai);
+            effectExile.setActivatingPlayer(ai, true);
             final TargetRestrictions exile_tgt = effectExile.getTargetRestrictions();
             final List<Card> targets = CardUtil.getValidCardsToTarget(exile_tgt, effectExile);
             return !targets.isEmpty();
@@ -618,7 +615,7 @@ public class AttachAi extends SpellAbilityAi {
                 CardCollection preList = new CardCollection(lki);
                 preList.add(attachSourceLki);
                 c.getGame().getAction().checkStaticAbilities(false, Sets.newHashSet(preList), preList);
-                boolean result = lki.canBeAttached(attachSourceLki);
+                boolean result = lki.canBeAttached(attachSourceLki, null);
 
                 //reset static abilities
                 c.getGame().getAction().checkStaticAbilities(false);
@@ -665,14 +662,14 @@ public class AttachAi extends SpellAbilityAi {
             if (card.hasKeyword(Keyword.HORSEMANSHIP)) {
                 cardPriority += 40;
             }
-            if (card.hasKeyword("Unblockable")) {
+            //check if card is generally unblockable
+            if (StaticAbilityCantAttackBlock.cantBlockBy(card, null)) {
                 cardPriority += 50;
             }
             // Prefer "tap to deal damage"
             // TODO : Skip this one if triggers on combat damage only?
             for (SpellAbility sa2 : card.getSpellAbilities()) {
-                if (ApiType.DealDamage.equals(sa2.getApi())
-                        && (sa2.getTargetRestrictions().canTgtPlayer())) {
+                if (ApiType.DealDamage.equals(sa2.getApi()) && sa2.usesTargeting() && sa2.getTargetRestrictions().canTgtPlayer()) {
                     cardPriority += 300;
                 }
             }
@@ -1307,20 +1304,35 @@ public class AttachAi extends SpellAbilityAi {
      * @return the card
      */
     private static Card attachToCardAIPreferences(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
-        final TargetRestrictions tgt = sa.getTargetRestrictions();
-        final Card attachSource = sa.getHostCard();
         // TODO AttachSource is currently set for the Source of the Spell, but
         // at some point can support attaching a different card
+        Card attachSource = sa.getHostCard();
+        if (sa.hasParam("Object")) {
+            CardCollection objs = AbilityUtils.getDefinedCards(attachSource, sa.getParam("Object"), sa);
+            if (objs.isEmpty()) {
+                if (!mandatory) {
+                    return null;
+                }
+            } else {
+                attachSource = objs.get(0);
+            }
+        }
 
         // Don't equip if DontEquip SVar is set
         if (attachSource.hasSVar("DontEquip")) {
             return null;
         }
 
+        // is no attachment so no using attach
+        if (!mandatory && !attachSource.isAttachment()) {
+            return null;
+        }
+
+        final TargetRestrictions tgt = sa.getTargetRestrictions();
+
         // Is a SA that moves target attachment
         if ("MoveTgtAura".equals(sa.getParam("AILogic"))) {
-            CardCollection list = new CardCollection(CardUtil.getValidCardsToTarget(tgt, sa));
-            list = CardLists.filter(list, Predicates.or(CardPredicates.isControlledByAnyOf(aiPlayer.getOpponents()), new Predicate<Card>() {
+            CardCollection list = CardLists.filter(CardUtil.getValidCardsToTarget(tgt, sa), Predicates.or(CardPredicates.isControlledByAnyOf(aiPlayer.getOpponents()), new Predicate<Card>() {
                 @Override
                 public boolean apply(final Card card) {
                     return ComputerUtilCard.isUselessCreature(aiPlayer, card.getAttachedTo());
@@ -1329,7 +1341,7 @@ public class AttachAi extends SpellAbilityAi {
 
             return !list.isEmpty() ? ComputerUtilCard.getBestAI(list) : null;
         } else if ("Unenchanted".equals(sa.getParam("AILogic"))) {
-            CardCollection list = new CardCollection(CardUtil.getValidCardsToTarget(tgt, sa));
+            List<Card> list = CardUtil.getValidCardsToTarget(tgt, sa);
             CardCollection preferred = CardLists.filter(list, new Predicate<Card>() {
                 @Override
                 public boolean apply(final Card card) {
@@ -1339,31 +1351,26 @@ public class AttachAi extends SpellAbilityAi {
             return preferred.isEmpty() ? Aggregates.random(list) : Aggregates.random(preferred);
         }
 
-        // is no attachment so no using attach
-        if (!attachSource.isAttachment()) {
-            return null;
-        }
-
         // Don't fortify if already fortifying
         if (attachSource.isFortification() && attachSource.getAttachedTo() != null
                 && attachSource.getAttachedTo().getController() == aiPlayer) {
             return null;
         }
 
-        CardCollection list = null;
+        List<Card> list = null;
         if (tgt == null) {
             list = AbilityUtils.getDefinedCards(attachSource, sa.getParam("Defined"), sa);
         } else {
-            list = CardLists.filter(CardUtil.getValidCardsToTarget(tgt, sa), CardPredicates.canBeAttached(attachSource));
+            list = CardUtil.getValidCardsToTarget(tgt, sa);
         }
 
         if (list.isEmpty()) {
             return null;
         }
-        CardCollection prefList = list;
+        CardCollection prefList = CardLists.filter(list, CardPredicates.canBeAttached(attachSource, sa));
 
         // Filter AI-specific targets if provided
-        prefList = ComputerUtil.filterAITgts(sa, aiPlayer, list, true);
+        prefList = ComputerUtil.filterAITgts(sa, aiPlayer, prefList, true);
 
         Card c = attachGeneralAI(aiPlayer, sa, prefList, mandatory, attachSource, sa.getParam("AILogic"));
 
@@ -1404,7 +1411,7 @@ public class AttachAi extends SpellAbilityAi {
             }
 
             // avoid randomly moving the equipment back and forth between several creatures in one turn
-            if (AiCardMemory.isRememberedCard(aiPlayer, sa.getHostCard(), AiCardMemory.MemorySet.ATTACHED_THIS_TURN) && !mandatory) {
+            if (AiCardMemory.isRememberedCard(aiPlayer, attachSource, AiCardMemory.MemorySet.ATTACHED_THIS_TURN) && !mandatory) {
                 return null;
             }
 
@@ -1415,12 +1422,13 @@ public class AttachAi extends SpellAbilityAi {
             }
         }
 
-        AiCardMemory.rememberCard(aiPlayer, sa.getHostCard(), AiCardMemory.MemorySet.ATTACHED_THIS_TURN);
+        AiCardMemory.rememberCard(aiPlayer, attachSource, AiCardMemory.MemorySet.ATTACHED_THIS_TURN);
 
         if (c == null && mandatory) {
             CardLists.shuffle(list);
-            c = list.getFirst();
+            c = list.get(0);
         }
+
         return c;
     }
 
@@ -1555,7 +1563,7 @@ public class AttachAi extends SpellAbilityAi {
             }
         }
 
-        final boolean evasive = keyword.equals("Unblockable") || keyword.equals("Fear")
+        final boolean evasive = keyword.equals("Fear")
                 || keyword.equals("Intimidate") || keyword.equals("Shadow")
                 || keyword.equals("Flying") || keyword.equals("Horsemanship")
                 || keyword.endsWith("walk") || keyword.equals("All creatures able to block CARDNAME do so.");
@@ -1563,8 +1571,9 @@ public class AttachAi extends SpellAbilityAi {
 
         boolean canBeBlocked = false;
         for (Player opp : ai.getOpponents()) {
-            if (CombatUtil.canBeBlocked(card, opp)) {
+            if (CombatUtil.canBeBlocked(card, null, opp)) {
                 canBeBlocked = true;
+                break;
             }
         }
 
@@ -1573,7 +1582,7 @@ public class AttachAi extends SpellAbilityAi {
                     && canBeBlocked
                     && ComputerUtilCombat.canAttackNextTurn(card);
         } else if (keyword.equals("Haste")) {
-            return card.hasSickness() && ph.isPlayerTurn(sa.getActivatingPlayer()) && !card.isTapped()
+            return card.hasSickness() && ph.isPlayerTurn(ai) && !card.isTapped()
                     && card.getNetCombatDamage() + powerBonus > 0
                     && !ph.getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS)
                     && ComputerUtilCombat.canAttackNextTurn(card);
@@ -1609,8 +1618,6 @@ public class AttachAi extends SpellAbilityAi {
                     && CombatUtil.canBlock(card, true);
         } else if (keyword.equals("Reach")) {
             return !card.hasKeyword(Keyword.FLYING) && CombatUtil.canBlock(card, true);
-        } else if (keyword.equals("CARDNAME can attack as though it didn't have defender.")) {
-            return card.hasKeyword(Keyword.DEFENDER) && card.getNetCombatDamage() + powerBonus > 0;
         } else if (keyword.equals("Shroud") || keyword.equals("Hexproof")) {
             return !card.hasKeyword(Keyword.SHROUD) && !card.hasKeyword(Keyword.HEXPROOF);
         } else return !keyword.equals("Defender");
@@ -1627,7 +1634,6 @@ public class AttachAi extends SpellAbilityAi {
      * @return true, if is useful keyword
      */
     private static boolean isUsefulCurseKeyword(final String keyword, final Card card, final SpellAbility sa) {
-        final Player ai = sa.getActivatingPlayer();
         if (!CardUtil.isStackingKeyword(keyword) && card.hasKeyword(keyword)) {
             return false;
         }
@@ -1667,12 +1673,6 @@ public class AttachAi extends SpellAbilityAi {
         if (c == null) {
             return false;
         }
-        if (sa.getHostCard() == null) {
-            // FIXME: Not sure what should the resolution be if a SpellAbility has no host card. This should
-            // not happen normally. Possibly remove this block altogether? (if it's an impossible condition).
-            System.out.println("AttachAi: isUsefulAttachAction unexpectedly called with SpellAbility with no host card. Assuming it's a determined useful action.");
-            return true;
-        }
 
         // useless to equip a creature that can't attack or block.
         return !sa.getHostCard().isEquipment() || !ComputerUtilCard.isUselessCreature(ai, c);
@@ -1736,7 +1736,7 @@ public class AttachAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {
         return true;
     }
 

forge-ai/src/main/java/forge/ai/ability/BecomesBlockedAi.java

@@ -29,7 +29,6 @@ public class BecomesBlockedAi extends SpellAbilityAi {
         if (tgt != null) {
         	sa.resetTargets();
 	        CardCollection list = CardLists.filterControlledBy(game.getCardsIn(ZoneType.Battlefield), aiPlayer.getOpponents());
-	        list = CardLists.getValidCards(list, tgt.getValidTgts(), source.getController(), source, sa);
 	        list = CardLists.getTargetableCards(list, sa);
 	        list = CardLists.getNotKeyword(list, Keyword.TRAMPLE);
 

forge-ai/src/main/java/forge/ai/ability/BidLifeAi.java

@@ -26,7 +26,6 @@ public class BidLifeAi extends SpellAbilityAi {
             sa.resetTargets();
             if (tgt.canTgtCreature()) {
                 List<Card> list = CardLists.getTargetableCards(AiAttackController.choosePreferredDefenderPlayer(aiPlayer).getCardsIn(ZoneType.Battlefield), sa);
-                list = CardLists.getValidCards(list, tgt.getValidTgts(), source.getController(), source, sa);
                 if (list.isEmpty()) {
                     return false;
                 }

forge-ai/src/main/java/forge/ai/ability/CanPlayAsDrawbackAi.java

@@ -1,35 +0,0 @@
-package forge.ai.ability;
-
-import forge.ai.SpellAbilityAi;
-import forge.game.player.Player;
-import forge.game.spellability.SpellAbility;
-
-public class CanPlayAsDrawbackAi extends SpellAbilityAi {
-
-    /* (non-Javadoc)
-     * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
-     */
-    @Override
-    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
-        return false;
-    }
-
-    /**
-     * <p>
-     * copySpellTriggerAI.
-     * </p>
-     * @param sa
-     *            a {@link forge.game.spellability.SpellAbility} object.
-     * @param mandatory
-     *            a boolean.
-     * @param af
-     *            a {@link forge.game.ability.AbilityFactory} object.
-     * 
-     * @return a boolean.
-     */
-    @Override
-    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
-        return false;
-    }
-
-}

forge-ai/src/main/java/forge/ai/ability/ChangeZoneAi.java

@@ -11,7 +11,6 @@ import forge.card.MagicColor;
 import forge.game.Game;
 import forge.game.GameEntity;
 import forge.game.GameObject;
-import forge.game.GlobalRuleChange;
 import forge.game.ability.AbilityKey;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
@@ -34,7 +33,6 @@ import forge.game.staticability.StaticAbilityMustTarget;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 import forge.util.MyRandom;
-import forge.util.collect.FCollection;
 import org.apache.commons.lang3.StringUtils;
 
 import java.util.*;
@@ -124,8 +122,6 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 return doSacAndReturnFromGraveLogic(aiPlayer, sa);
             } else if (aiLogic.equals("Necropotence")) {
                 return SpecialCardAi.Necropotence.consider(aiPlayer, sa);
-            } else if (aiLogic.equals("SameName")) { // Declaration in Stone
-                return doSameNameLogic(aiPlayer, sa);
             } else if (aiLogic.equals("ReanimateAll")) {
                 return SpecialCardAi.LivingDeath.consider(aiPlayer, sa);
             } else if (aiLogic.equals("TheScarabGod")) {
@@ -274,13 +270,9 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 }
             }
 
-            //Ninjutsu
-            if (sa.hasParam("Ninjutsu")) {
-                if (source.getType().isLegendary()
-                        && !ai.getGame().getStaticEffects().getGlobalRuleChange(GlobalRuleChange.noLegendRule)) {
-                    if (ai.getZone(ZoneType.Battlefield).contains(CardPredicates.nameEquals(source.getName()))) {
-                        return false;
-                    }
+            if (sa.isNinjutsu()) {
+                if (!source.ignoreLegendRule() && ai.isCardInPlay(source.getName())) {
+                    return false;
                 }
                 if (ai.getGame().getPhaseHandler().getPhase().isAfter(PhaseType.COMBAT_DAMAGE)) {
                     return false;
@@ -680,10 +672,8 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 return false;
             }
 
-            // if (origin.equals("Graveyard")) {
             // return this card from graveyard: cards like Hammer of Bogardan
-            // in general this is cool, but we should add some type of
-            // restrictions
+            // in general this is cool, but we should add some type of restrictions
 
             // return this card from battlefield: cards like Blinking Spirit
             // in general this should only be used to protect from Imminent Harm
@@ -720,6 +710,10 @@ public class ChangeZoneAi extends SpellAbilityAi {
             }
 
             if (destination == ZoneType.Battlefield) {
+                if (ComputerUtil.isETBprevented(retrieval.get(0))) {
+                    return false;
+                }
+
                 // predict whether something may put a ETBing creature below zero toughness
                 // (e.g. Reassembing Skeleton + Elesh Norn, Grand Cenobite)
                 for (final Card c : retrieval) {
@@ -732,18 +726,16 @@ public class ChangeZoneAi extends SpellAbilityAi {
                     }
                 }
                 // predict Legendary cards already present
-                if (!ai.getGame().getStaticEffects().getGlobalRuleChange(GlobalRuleChange.noLegendRule)) {
-                    boolean nothingWillReturn = true;
-                    for (final Card c : retrieval) {
-                        if (!(c.getType().isLegendary() && ai.isCardInPlay(c.getName()))) {
-                            nothingWillReturn = false;
-                            break;
-                        }
-                    }
-                    if (nothingWillReturn) {
-                        return false;
+                boolean nothingWillReturn = true;
+                for (final Card c : retrieval) {
+                    if (!(!c.ignoreLegendRule() && ai.isCardInPlay(c.getName()))) {
+                        nothingWillReturn = false;
+                        break;
                     }
                 }
+                if (nothingWillReturn) {
+                    return false;
+                }
             }
         }
 
@@ -1009,6 +1001,35 @@ public class ChangeZoneAi extends SpellAbilityAi {
 
                     return true;
                 }
+                // blink logic: get my own permanents back or blink permanents with ETB effects
+                if (blink) {
+                    CardCollection blinkTargets = CardLists.filter(list, new Predicate<Card>() {
+                        @Override
+                        public boolean apply(final Card c) {
+                            return !c.isToken() && c.getOwner().equals(ai) && (c.getController().isOpponentOf(ai) || c.hasETBTrigger(false));
+                        }
+                    });
+                    if (!blinkTargets.isEmpty()) {
+                        CardCollection opponentBlinkTargets = CardLists.filterControlledBy(blinkTargets, ai.getOpponents());
+                        // prefer post-combat unless targeting opponent's stuff or part of another ability
+                        if (immediately || sa.getParent() != null || sa.isTrigger() || !opponentBlinkTargets.isEmpty() || !game.getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2)) {
+                            while (!blinkTargets.isEmpty() && sa.canAddMoreTarget()) {
+                                Card choice = null;
+                                // first prefer targeting opponents stuff
+                                if (!opponentBlinkTargets.isEmpty()) {
+                                    choice = ComputerUtilCard.getBestAI(opponentBlinkTargets);
+                                    opponentBlinkTargets.remove(choice);
+                                }
+                                else {
+                                    choice = ComputerUtilCard.getBestAI(blinkTargets);
+                                }
+                                sa.getTargets().add(choice);
+                                blinkTargets.remove(choice);
+                            }
+                            return true;
+                        }
+                    }
+                }
                 // bounce opponent's stuff
                 list = CardLists.filterControlledBy(list, ai.getOpponents());
                 if (!CardLists.getNotType(list, "Land").isEmpty()) {
@@ -1026,26 +1047,6 @@ public class ChangeZoneAi extends SpellAbilityAi {
                         }
                     });
                 }
-                // TODO: Blink permanents with ETB triggers
-                /*else if (!sa.isTrigger() && SpellAbilityAi.playReusable(ai, sa)) {
-                    aiPermanents = CardLists.filter(aiPermanents, new Predicate<Card>() {
-                        @Override
-                        public boolean apply(final Card c) {
-                            if (c.hasCounters()) {
-                                return false; // don't blink something with
-                            }
-                            // counters TODO check good and
-                            // bad counters
-                            // checks only if there is a dangerous ETB effect
-                            return !c.equals(sa.getHostCard()) && SpellPermanent.checkETBEffects(c, ai);
-                        }
-                    });
-                    if (!aiPermanents.isEmpty()) {
-                        // Choose "best" of the remaining to save
-                        sa.getTargets().add(ComputerUtilCard.getBestAI(aiPermanents));
-                        return true;
-                    }
-                }*/
             }
 
         } else if (origin.contains(ZoneType.Graveyard)) {
@@ -1089,7 +1090,6 @@ public class ChangeZoneAi extends SpellAbilityAi {
 
         // Exile and bounce opponents stuff
         if (destination.equals(ZoneType.Exile) || origin.contains(ZoneType.Battlefield)) {
-
             // don't rush bouncing stuff when not going to attack
             if (!immediately && game.getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2)
                     && game.getPhaseHandler().isPlayerTurn(ai)
@@ -1216,7 +1216,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 }
             }
             if (choice == null) { // can't find anything left
-                if (sa.getTargets().size() == 0 || !sa.isTargetNumberValid()) {
+                if (sa.getTargets().isEmpty() || !sa.isTargetNumberValid()) {
                     if (!mandatory) {
                         sa.resetTargets();
                     }
@@ -1275,17 +1275,15 @@ public class ChangeZoneAi extends SpellAbilityAi {
         // TODO: ideally the AI should consider at this point which targets exactly to pick (e.g. one card in the first player's graveyard
         // vs. two cards in the second player's graveyard, which cards are more relevant to be targeted, etc.). Consider improving.
         if (sa.getTargetRestrictions().isSingleZone()) {
-            Card firstTgt = sa.getTargets().getFirstTargetedCard();
+            Card firstTgt = sa.getTargetCard();
             CardCollection toRemove = new CardCollection();
             if (firstTgt != null) {
                 for (Card t : sa.getTargets().getTargetCards()) {
-                   if (!t.getController().equals(firstTgt.getController())) {
-                       toRemove.add(t);
-                   }
-                }
-                for (Card dontTarget : toRemove) {
-                   sa.getTargets().remove(dontTarget);
+                    if (!t.getController().equals(firstTgt.getController())) {
+                        toRemove.add(t);
+                    }
                 }
+                sa.getTargets().removeAll(toRemove);
             }
         }
 
@@ -1359,12 +1357,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 chance = aic.getIntProperty(AiProps.BLINK_RELOAD_PLANESWALKER_CHANCE);
             }
             if (MyRandom.percentTrue(chance)) {
-                Collections.sort(aiPlaneswalkers, new Comparator<Card>() {
-                    @Override
-                    public int compare(final Card a, final Card b) {
-                        return a.getCounters(CounterEnumType.LOYALTY) - b.getCounters(CounterEnumType.LOYALTY);
-                    }
-                });
+                Collections.sort(aiPlaneswalkers, CardPredicates.compareByCounterType(CounterEnumType.LOYALTY));
                 for (Card pw : aiPlaneswalkers) {
                     int curLoyalty = pw.getCounters(CounterEnumType.LOYALTY);
                     int freshLoyalty = Integer.valueOf(pw.getCurrentState().getBaseLoyalty());
@@ -1439,17 +1432,14 @@ public class ChangeZoneAi extends SpellAbilityAi {
         final ZoneType destination = ZoneType.smartValueOf(sa.getParam("Destination"));
         final TargetRestrictions tgt = sa.getTargetRestrictions();
 
-        CardCollection list = CardLists.getValidCards(ai.getGame().getCardsIn(tgt.getZone()), tgt.getValidTgts(), ai, source, sa);
-        list = CardLists.getTargetableCards(list, sa);
-
-        list.removeAll(sa.getTargets().getTargetCards());
+        List<Card> list = CardUtil.getValidCardsToTarget(tgt, sa);
 
         if (list.isEmpty()) {
             return false;
         }
 
         // target loop
-        while (sa.getTargets().size() < tgt.getMinTargets(sa.getHostCard(), sa)) {
+        while (!sa.isMinTargetChosen()) {
             // AI Targeting
             Card choice = null;
 
@@ -1746,7 +1736,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
      * @see forge.card.ability.SpellAbilityAi#confirmAction(forge.game.player.Player, forge.card.spellability.SpellAbility, forge.game.player.PlayerActionConfirmMode, java.lang.String)
      */
     @Override
-    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {
         // AI was never asked
         return true;
     }
@@ -1764,7 +1754,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
     public Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options, Map<String, Object> params) {
         // Called when attaching Aura to player or adding creature to combat
         if (params != null && params.containsKey("Attacker")) {
-            return (Player) ComputerUtilCombat.addAttackerToCombat(sa, (Card) params.get("Attacker"), new FCollection<GameEntity>(options));
+            return (Player) ComputerUtilCombat.addAttackerToCombat(sa, (Card) params.get("Attacker"), options);
         }
         return AttachAi.attachToPlayerAIPreferences(ai, sa, true, (List<Player>)options);
     }
@@ -1772,7 +1762,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
     @Override
     protected GameEntity chooseSinglePlayerOrPlaneswalker(Player ai, SpellAbility sa, Iterable<GameEntity> options, Map<String, Object> params) {
         if (params != null && params.containsKey("Attacker")) {
-            return ComputerUtilCombat.addAttackerToCombat(sa, (Card) params.get("Attacker"), new FCollection<GameEntity>(options));
+            return ComputerUtilCombat.addAttackerToCombat(sa, (Card) params.get("Attacker"), options);
         }
         // should not be reached
         return super.chooseSinglePlayerOrPlaneswalker(ai, sa, options, params);
@@ -1862,80 +1852,6 @@ public class ChangeZoneAi extends SpellAbilityAi {
         return false;
     }
 
-    private boolean doSameNameLogic(Player aiPlayer, SpellAbility sa) {
-        final Game game = aiPlayer.getGame();
-        final Card source = sa.getHostCard();
-        final TargetRestrictions tgt = sa.getTargetRestrictions();
-        final ZoneType origin = ZoneType.listValueOf(sa.getParam("Origin")).get(0);
-        CardCollection list = CardLists.getValidCards(game.getCardsIn(origin), tgt.getValidTgts(), aiPlayer,
-                source, sa);
-        list = CardLists.filterControlledBy(list, aiPlayer.getOpponents());
-        if (list.isEmpty()) {
-            return false; // no valid targets
-        }
-
-        Map<Player, Map.Entry<String, Integer>> data = Maps.newHashMap();
-
-        // need to filter for the opponents first
-        for (final Player opp : aiPlayer.getOpponents()) {
-            CardCollection oppList = CardLists.filterControlledBy(list, opp);
-
-            // no cards
-            if (oppList.isEmpty()) {
-                continue;
-            }
-
-            // Compute value for each possible target
-            Map<String, Integer> values = ComputerUtilCard.evaluateCreatureListByName(oppList);
-
-            // reject if none of them can be targeted
-            oppList = CardLists.filter(oppList, CardPredicates.isTargetableBy(sa));
-            // none can be targeted
-            if (oppList.isEmpty()) {
-                continue;
-            }
-
-            List<String> toRemove = Lists.newArrayList();
-            for (final String name : values.keySet()) {
-                if (!Iterables.any(oppList, CardPredicates.nameEquals(name))) {
-                    toRemove.add(name);
-                }
-            }
-            values.keySet().removeAll(toRemove);
-
-            // JAVA 1.8 use Map.Entry.comparingByValue()
-            data.put(opp, Collections.max(values.entrySet(), new Comparator<Map.Entry<String, Integer>>() {
-                @Override
-                public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
-                    return o1.getValue() - o2.getValue();
-                }
-            }));
-        }
-
-        if (!data.isEmpty()) {
-            // JAVA 1.8 use Map.Entry.comparingByValue() somehow
-            Map.Entry<Player, Map.Entry<String, Integer>> max = Collections.max(data.entrySet(), new Comparator<Map.Entry<Player, Map.Entry<String, Integer>>>() {
-                @Override
-                public int compare(Map.Entry<Player, Map.Entry<String, Integer>> o1, Map.Entry<Player, Map.Entry<String, Integer>> o2) {
-                    return o1.getValue().getValue() - o2.getValue().getValue();
-                }
-            });
-
-            // filter list again by the opponent and a creature of the wanted name that can be targeted
-            list = CardLists.filter(CardLists.filterControlledBy(list, max.getKey()),
-                    CardPredicates.nameEquals(max.getValue().getKey()), CardPredicates.isTargetableBy(sa));
-
-            // list should contain only one element or zero
-            sa.resetTargets();
-            for (Card c : list) {
-                sa.getTargets().add(c);
-                return true;
-            }
-        }
-
-        return false;
-    }
-
     public boolean doReturnCommanderLogic(SpellAbility sa, Player aiPlayer) {
         @SuppressWarnings("unchecked")
         Map<AbilityKey, Object> originalParams = (Map<AbilityKey, Object>)sa.getReplacingObject(AbilityKey.OriginalParams);

forge-ai/src/main/java/forge/ai/ability/ChangeZoneAllAi.java

@@ -1,10 +1,10 @@
 package forge.ai.ability;
 
 import java.util.Collections;
+import java.util.Map;
 
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
 
 import forge.ai.AiController;
 import forge.ai.AiPlayerPredicates;
@@ -70,7 +70,7 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
         // ex. "Return all Auras attached to target"
         // ex. "Return all blocking/blocked by target creature"
 
-        CardCollectionView oppType = CardLists.filterControlledBy(game.getCardsIn(origin), ai.getOpponents());
+        CardCollectionView oppType = ai.getOpponents().getCardsIn(origin);
         CardCollectionView computerType = ai.getCardsIn(origin);
 
         // remove cards that won't be seen in AI's own library if it can't be searched
@@ -196,8 +196,7 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
 
             // mass zone change for creatures: if in dire danger, do it; otherwise, only do it if the opponent's
             // creatures are better in value
-            if ((CardLists.getNotType(oppType, "Creature").size() == 0)
-                    && (CardLists.getNotType(computerType, "Creature").size() == 0)) {
+            if (CardLists.getNotType(oppType, "Creature").isEmpty() && CardLists.getNotType(computerType, "Creature").isEmpty()) {
                 if (game.getCombat() != null && ComputerUtilCombat.lifeInSeriousDanger(ai, game.getCombat())) {
                     if (game.getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS)
                             && game.getPhaseHandler().getPlayerTurn().isOpponentOf(ai)) {
@@ -224,17 +223,15 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
         } else if (origin.equals(ZoneType.Graveyard)) {
             if (sa.usesTargeting()) {
                 // search targetable Opponents
-                final Iterable<Player> oppList = Iterables.filter(ai.getOpponents(),
-                        PlayerPredicates.isTargetableBy(sa));
+                final PlayerCollection oppList = ai.getOpponents().filter(PlayerPredicates.isTargetableBy(sa));
 
-                if (Iterables.isEmpty(oppList)) {
+                if (oppList.isEmpty()) {
                     return false;
                 }
 
                 // get the one with the most in graveyard
                 // zone is visible so evaluate which would be hurt the most
-                Player oppTarget = Collections.max(Lists.newArrayList(oppList),
-                        AiPlayerPredicates.compareByZoneValue(sa.getParam("ChangeType"), origin, sa));
+                Player oppTarget = Collections.max(oppList, AiPlayerPredicates.compareByZoneValue(sa.getParam("ChangeType"), origin, sa));
 
                 // set the target
                 if (!oppTarget.getCardsIn(ZoneType.Graveyard).isEmpty()) {
@@ -269,18 +266,14 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
                 return (curHandSize + minAdv - 1 < numExiledWithSrc) || (!noDiscard && numExiledWithSrc >= ai.getMaxHandSize());
             }
         } else if (origin.equals(ZoneType.Stack)) {
-            // time stop can do something like this:
-            // Origin$ Stack | Destination$ Exile | SubAbility$ DBSkip
-            // DBSKipToPhase | DB$SkipToPhase | Phase$ Cleanup
-            // otherwise, this situation doesn't exist
+            // TODO
             return false;
         }
 
         if (destination.equals(ZoneType.Battlefield)) {
-            if (sa.getParam("GainControl") != null) {
+            if (sa.hasParam("GainControl")) {
                 // Check if the cards are valuable enough
-                if (CardLists.getNotType(oppType, "Creature").size() == 0
-                        && CardLists.getNotType(computerType, "Creature").size() == 0) {
+                if (CardLists.getNotType(oppType, "Creature").isEmpty() && CardLists.getNotType(computerType, "Creature").isEmpty()) {
                     if ((ComputerUtilCard.evaluateCreatureList(computerType) + ComputerUtilCard
                             .evaluateCreatureList(oppType)) < 400) {
                         return false;
@@ -293,8 +286,7 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
                 }
             } else {
                 // don't activate if human gets more back than AI does
-                if ((CardLists.getNotType(oppType, "Creature").size() == 0)
-                        && (CardLists.getNotType(computerType, "Creature").size() == 0)) {
+                if (CardLists.getNotType(oppType, "Creature").isEmpty() && CardLists.getNotType(computerType, "Creature").isEmpty()) {
                     if (ComputerUtilCard.evaluateCreatureList(computerType) <= (ComputerUtilCard
                             .evaluateCreatureList(oppType) + 100)) {
                         return false;
@@ -334,7 +326,7 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
      * @see forge.card.ability.SpellAbilityAi#confirmAction(forge.game.player.Player, forge.card.spellability.SpellAbility, forge.game.player.PlayerActionConfirmMode, java.lang.String)
      */
     @Override
-    public boolean confirmAction(Player ai, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+    public boolean confirmAction(Player ai, SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {
         final Card source = sa.getHostCard();
         final String hostName = source.getName();
         final ZoneType origin = ZoneType.listValueOf(sa.getParam("Origin")).get(0);
@@ -353,8 +345,7 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
         		return true;
 
         	// if AI creature is better than Human Creature
-            return ComputerUtilCard.evaluateCreatureList(aiCards) >= ComputerUtilCard
-                    .evaluateCreatureList(humanCards);
+            return ComputerUtilCard.evaluateCreatureList(aiCards) >= ComputerUtilCard.evaluateCreatureList(humanCards);
         }
         return true;
     }
@@ -373,7 +364,7 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
             return Iterables.any(ai.getOpponents().getCardsIn(origin), CardPredicates.Presets.CREATURES);
         }
 
-        CardCollectionView humanType = CardLists.filterControlledBy(ai.getGame().getCardsIn(origin), ai.getOpponents());
+        CardCollectionView humanType = ai.getOpponents().getCardsIn(origin);
         humanType = AbilityUtils.filterListByType(humanType, sa.getParam("ChangeType"), sa);
 
         CardCollectionView computerType = ai.getCardsIn(origin);
@@ -415,15 +406,13 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
             // if the AI is using it defensively, then something else needs to occur
             // if only creatures are affected evaluate both lists and pass only
             // if human creatures are more valuable
-            if ((CardLists.getNotType(humanType, "Creature").isEmpty()) && (CardLists.getNotType(computerType, "Creature").isEmpty())) {
-                if (ComputerUtilCard.evaluateCreatureList(computerType) >= ComputerUtilCard
-                        .evaluateCreatureList(humanType)) {
+            if (CardLists.getNotType(humanType, "Creature").isEmpty() && CardLists.getNotType(computerType, "Creature").isEmpty()) {
+                if (ComputerUtilCard.evaluateCreatureList(computerType) >= ComputerUtilCard.evaluateCreatureList(humanType)) {
                     return false;
                 }
             } // otherwise evaluate both lists by CMC and pass only if human
               // permanents are more valuable
-            else if (ComputerUtilCard.evaluatePermanentList(computerType) >= ComputerUtilCard
-                    .evaluatePermanentList(humanType)) {
+            else if (ComputerUtilCard.evaluatePermanentList(computerType) >= ComputerUtilCard.evaluatePermanentList(humanType)) {
                 return false;
             }
         } else if (origin.equals(ZoneType.Graveyard)) {
@@ -456,11 +445,7 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
         } else if (origin.equals(ZoneType.Exile)) {
 
         } else if (origin.equals(ZoneType.Stack)) {
-            // time stop can do something like this:
-            // Origin$ Stack | Destination$ Exile | SubAbility$ DBSkip
-            // DBSKipToPhase | DB$SkipToPhase | Phase$ Cleanup
-            // otherwise, this situation doesn't exist
-            return false;
+            // currently only exists indirectly (e.g. Summary Dismissal via PlayAi)
         }
 
         if (destination.equals(ZoneType.Battlefield)) {
@@ -468,25 +453,22 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
             if (mandatory) {
                 return true;
             }
-            if (sa.getParam("GainControl") != null) {
+            if (sa.hasParam("GainControl")) {
                 // Check if the cards are valuable enough
-                if ((CardLists.getNotType(humanType, "Creature").size() == 0) && (CardLists.getNotType(computerType, "Creature").size() == 0)) {
-                    return (ComputerUtilCard.evaluateCreatureList(computerType) + ComputerUtilCard
-                            .evaluateCreatureList(humanType)) >= 1;
+                if (CardLists.getNotType(humanType, "Creature").isEmpty() && CardLists.getNotType(computerType, "Creature").isEmpty()) {
+                    return (ComputerUtilCard.evaluateCreatureList(computerType) + ComputerUtilCard.evaluateCreatureList(humanType)) >= 1;
                 } // otherwise evaluate both lists by CMC and pass only if human
                   // permanents are less valuable
-                else return (ComputerUtilCard.evaluatePermanentList(computerType) + ComputerUtilCard
+                return (ComputerUtilCard.evaluatePermanentList(computerType) + ComputerUtilCard
                         .evaluatePermanentList(humanType)) >= 1;
-            } else {
-                // don't activate if human gets more back than AI does
-                if ((CardLists.getNotType(humanType, "Creature").isEmpty()) && (CardLists.getNotType(computerType, "Creature").isEmpty())) {
-                    return ComputerUtilCard.evaluateCreatureList(computerType) > ComputerUtilCard
-                            .evaluateCreatureList(humanType);
-                } // otherwise evaluate both lists by CMC and pass only if human
-                  // permanents are less valuable
-                else return ComputerUtilCard.evaluatePermanentList(computerType) > ComputerUtilCard
-                        .evaluatePermanentList(humanType);
             }
+
+            // don't activate if human gets more back than AI does
+            if (CardLists.getNotType(humanType, "Creature").isEmpty() && CardLists.getNotType(computerType, "Creature").isEmpty()) {
+                return ComputerUtilCard.evaluateCreatureList(computerType) > ComputerUtilCard.evaluateCreatureList(humanType);
+            } // otherwise evaluate both lists by CMC and pass only if human
+            // permanents are less valuable
+            return ComputerUtilCard.evaluatePermanentList(computerType) > ComputerUtilCard.evaluatePermanentList(humanType);
         }
 
         return true;

forge-ai/src/main/java/forge/ai/ability/CharmAi.java

@@ -14,6 +14,7 @@ import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.effects.CharmEffect;
 import forge.game.card.Card;
+import forge.game.keyword.Keyword;
 import forge.game.player.Player;
 import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
@@ -26,7 +27,6 @@ public class CharmAi extends SpellAbilityAi {
     protected boolean checkApiLogic(Player ai, SpellAbility sa) {
         final Card source = sa.getHostCard();
         List<AbilitySub> choices = CharmEffect.makePossibleOptions(sa);
-        Collections.shuffle(choices);
 
         final int num;
         final int min;
@@ -37,6 +37,11 @@ public class CharmAi extends SpellAbilityAi {
             min = sa.hasParam("MinCharmNum") ? AbilityUtils.calculateAmount(source, sa.getParam("MinCharmNum"), sa) : num;
         }
 
+        // only randomize if not all possible together
+        if (num < choices.size() || source.hasKeyword(Keyword.ESCALATE)) {
+            Collections.shuffle(choices);
+        }
+
         boolean timingRight = sa.isTrigger(); //is there a reason to play the charm now?
 
         // Reset the chosen list otherwise it will be locked in forever by earlier calls
@@ -88,8 +93,7 @@ public class CharmAi extends SpellAbilityAi {
         AiController aic = ((PlayerControllerAi) ai.getController()).getAi();
         // First pass using standard canPlayAi() for good choices
         for (AbilitySub sub : choices) {
-            sub.setActivatingPlayer(ai);
-            sub.getRestrictions().setZone(sub.getParent().getRestrictions().getZone());
+            sub.setActivatingPlayer(ai, true);
             if (AiPlayDecision.WillPlay == aic.canPlaySa(sub)) {
                 chosenList.add(sub);
                 if (chosenList.size() == num) {
@@ -101,8 +105,6 @@ public class CharmAi extends SpellAbilityAi {
             // Second pass using doTrigger(false) to fulfill minimum choice
             choices.removeAll(chosenList);
             for (AbilitySub sub : choices) {
-                sub.setActivatingPlayer(ai);
-                sub.getRestrictions().setZone(sub.getParent().getRestrictions().getZone());
                 if (aic.doTrigger(sub, false)) {
                     chosenList.add(sub);
                     if (chosenList.size() == min) {
@@ -114,8 +116,6 @@ public class CharmAi extends SpellAbilityAi {
             if (chosenList.size() < min) {
                 choices.removeAll(chosenList);
                 for (AbilitySub sub : choices) {
-                    sub.setActivatingPlayer(ai);
-                    sub.getRestrictions().setZone(sub.getParent().getRestrictions().getZone());
                     if (aic.doTrigger(sub, true)) {
                         chosenList.add(sub);
                         if (chosenList.size() == min) {
@@ -224,14 +224,13 @@ public class CharmAi extends SpellAbilityAi {
         List<AbilitySub> chosenList = Lists.newArrayList();
         AiController aic = ((PlayerControllerAi) ai.getController()).getAi();
         for (AbilitySub sub : choices) {
-            sub.setActivatingPlayer(ai);
+            sub.setActivatingPlayer(ai, true);
             // Assign generic good choice to fill up choices if necessary 
             if ("Good".equals(sub.getParam("AILogic")) && aic.doTrigger(sub, false)) {
                 goodChoice = sub;
             } else {
                 // Standard canPlayAi()
-                sub.setActivatingPlayer(ai);
-                sub.getRestrictions().setZone(sub.getParent().getRestrictions().getZone());
+                sub.setActivatingPlayer(ai, true);
                 if (AiPlayDecision.WillPlay == aic.canPlaySa(sub)) {
                     chosenList.add(sub);
                     if (chosenList.size() == min) {
@@ -255,15 +254,6 @@ public class CharmAi extends SpellAbilityAi {
         return Aggregates.random(opponents);
     }
 
-    @Override
-    protected boolean doTriggerAINoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
-        // already done by chooseOrderOfSimultaneousStackEntry
-        if (sa.getChosenList() != null) {
-            return true;
-        }
-        return super.doTriggerAINoCost(aiPlayer, sa, mandatory);
-    }
-
     @Override
     public boolean chkDrawbackWithSubs(Player aiPlayer, AbilitySub ab) {
         // choices were already targeted

forge-ai/src/main/java/forge/ai/ability/ChooseCardAi.java

@@ -162,9 +162,17 @@ public class ChooseCardAi extends SpellAbilityAi {
     public Card chooseSingleCard(final Player ai, final SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         final Card host = sa.getHostCard();
         final Player ctrl = host.getController();
-        final String logic = sa.getParam("AILogic");
+        String logic = sa.getParamOrDefault("AILogic", "");
+        if (logic.contains("NotSelf")) {
+            CardCollection opt = (CardCollection) options;
+            if (opt.contains(host)) {
+                opt.remove(host);
+            }
+            options = opt;
+            logic = logic.replace("NotSelf", "");
+        }
         Card choice = null;
-        if (logic == null) {
+        if (logic.equals("")) {
             // Base Logic is choose "best"
             choice = ComputerUtilCard.getBestAI(options);
         } else if ("WorstCard".equals(logic)) {
@@ -190,13 +198,6 @@ public class ChooseCardAi extends SpellAbilityAi {
         } else if ("RandomNonLand".equals(logic)) {
             options = CardLists.getValidCards(options, "Card.nonLand", host.getController(), host, sa);
             choice = Aggregates.random(options);
-        } else if (logic.equals("Untap")) {
-            final String filter = "Permanent.YouCtrl,Permanent.tapped";
-            CardCollection newOptions = CardLists.getValidCards(options, filter, ctrl, host, sa);
-            if (!newOptions.isEmpty()) {
-                options = newOptions;
-            }
-            choice = ComputerUtilCard.getBestAI(options);
         } else if (logic.equals("NeedsPrevention")) {
             final Game game = ai.getGame();
             final Combat combat = game.getCombat();
@@ -294,6 +295,7 @@ public class ChooseCardAi extends SpellAbilityAi {
             choice = ComputerUtilCard.getBestCreatureToAttackNextTurnAI(ai, options);
         } else {
             choice = ComputerUtilCard.getBestAI(options);
+            System.err.println("Bad ChooseCard AILogic value for " + host.getName() + " - reverting to default");
         }
         return choice;
     }

forge-ai/src/main/java/forge/ai/ability/ChooseGenericEffectAi.java

@@ -1,30 +1,17 @@
 package forge.ai.ability;
 
-import java.util.List;
-import java.util.Map;
-
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
-
 import forge.ai.ComputerUtilAbility;
-import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCost;
-import forge.ai.SpecialCardAi;
 import forge.ai.SpellAbilityAi;
 import forge.ai.SpellApiToAi;
 import forge.card.MagicColor;
 import forge.game.Game;
-import forge.game.card.Card;
-import forge.game.card.CardCollection;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates.Presets;
-import forge.game.card.CardUtil;
-import forge.game.card.CounterEnumType;
+import forge.game.card.*;
 import forge.game.combat.Combat;
-import forge.game.combat.CombatUtil;
 import forge.game.cost.Cost;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseHandler;
@@ -36,6 +23,9 @@ import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 import forge.util.collect.FCollection;
 
+import java.util.List;
+import java.util.Map;
+
 
 public class ChooseGenericEffectAi extends SpellAbilityAi {
 
@@ -43,7 +33,7 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
     protected boolean checkAiLogic(final Player ai, final SpellAbility sa, final String aiLogic) {
         if ("Khans".equals(aiLogic) || "Dragons".equals(aiLogic)) {
             return true;
-        } else if (aiLogic.startsWith("Fabricate") || "Riot".equals(aiLogic)) {
+        } else if ("Riot".equals(aiLogic)) {
             return true;
         } else if ("Pump".equals(aiLogic) || "BestOption".equals(aiLogic)) {
             for (AbilitySub sb : sa.getAdditionalAbilityList("Choices")) {
@@ -51,8 +41,6 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
                     return true;
                 }
             }
-        } else if ("GideonBlackblade".equals(aiLogic)) {
-            return SpecialCardAi.GideonBlackblade.consider(ai, sa);
         } else if ("AtOppEOT".equals(aiLogic)) {
             PhaseHandler ph = ai.getGame().getPhaseHandler();
             return ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn() == ai;
@@ -103,8 +91,6 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
             return spells.get(0);
         } else if ("Random".equals(logic)) {
             return Aggregates.random(spells);
-        } else if ("GideonBlackblade".equals(logic)) {
-            return SpecialCardAi.GideonBlackblade.chooseSpellAbility(player, sa, spells);
         } else if ("Phasing".equals(logic)) { // Teferi's Realm : keep aggressive
             List<SpellAbility> filtered = Lists.newArrayList(Iterables.filter(spells, new Predicate<SpellAbility>() {
                 @Override
@@ -116,7 +102,7 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
         } else if ("PayUnlessCost".equals(logic)) {
             for (final SpellAbility sp : spells) {
                 String unlessCost = sp.getParam("UnlessCost");
-                sp.setActivatingPlayer(sa.getActivatingPlayer());
+                sp.setActivatingPlayer(sa.getActivatingPlayer(), true);
                 Cost unless = new Cost(unlessCost, false);
                 SpellAbility paycost = new SpellAbility.EmptySa(sa.getHostCard(), player);
                 paycost.setPayCosts(unless);
@@ -202,7 +188,7 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
         } else if ("SinProdder".equals(logic)) {
             SpellAbility allow = null, deny = null;
             for (final SpellAbility sp : spells) {
-                if (sp.getDescription().equals("Allow")) {
+                if (sp.getDescription().equals("No")) {
                     allow = sp;
                 } else {
                     deny = sp;
@@ -265,83 +251,6 @@ public class ChooseGenericEffectAi extends SpellAbilityAi {
             }
             // if unsure, random?
             return Aggregates.random(spells);
-        } else if (logic.startsWith("Fabricate")) {
-            final int n = Integer.valueOf(logic.substring("Fabricate".length()));
-            if(spells.size() < 2) {
-				// If the creature is no longer on the battlefield, the option
-				// to add counters is already removed at this point. Return the
-				// only available option: create servo tokens.
-            	return spells.get(0);
-            }
-            SpellAbility counterSA = spells.get(0), tokenSA = spells.get(1);
-
-            // check for something which might prevent the counters to be placed on host
-            if (!host.canReceiveCounters(CounterEnumType.P1P1)) {
-                return tokenSA;
-            }
-
-            // if host would leave the play or if host is useless, create tokens
-            if (host.hasSVar("EndOfTurnLeavePlay") || ComputerUtilCard.isUselessCreature(player, host)) {
-                return tokenSA;
-            }
-
-            // need a copy for one with extra +1/+1 counter boost,
-            // without causing triggers to run
-            final Card copy = CardUtil.getLKICopy(host);
-            copy.setCounters(CounterEnumType.P1P1, copy.getCounters(CounterEnumType.P1P1) + n);
-            copy.setZone(host.getZone());
-
-            // if host would put into the battlefield attacking
-            if (combat != null && combat.isAttacking(host)) {
-                final Player defender = combat.getDefenderPlayerByAttacker(host);
-                if (defender.canLoseLife() && !ComputerUtilCard.canBeBlockedProfitably(defender, copy, true)) {
-                    return counterSA;
-                }
-                return tokenSA;
-            }
-
-            // if the host has haste and can attack
-            if (CombatUtil.canAttack(copy)) {
-                for (final Player opp : player.getOpponents()) {
-                    if (CombatUtil.canAttack(copy, opp) &&
-                            opp.canLoseLife() &&
-                            !ComputerUtilCard.canBeBlockedProfitably(opp, copy, true))
-                        return counterSA;
-                }
-            }
-
-            // TODO check for trigger to turn token ETB into +1/+1 counter for host
-            // TODO check for trigger to turn token ETB into damage or life loss for opponent
-            // in this cases Token might be prefered even if they would not survive
-            final Card tokenCard = TokenAi.spawnToken(player, tokenSA);
-
-            // Token would not survive
-            if (!tokenCard.isCreature() || tokenCard.getNetToughness() < 1) {
-                return counterSA;
-            }
-
-            // Special Card logic, this one try to median its power with the number of artifacts
-            if ("Marionette Master".equals(sourceName)) {
-                CardCollection list = CardLists.filter(player.getCardsIn(ZoneType.Battlefield), Presets.ARTIFACTS);
-                return list.size() >= copy.getNetPower() ? counterSA : tokenSA;
-            } else if ("Cultivator of Blades".equals(sourceName)) {
-                // Cultivator does try to median with number of Creatures
-                CardCollection list = player.getCreaturesInPlay();
-                return list.size() >= copy.getNetPower() ? counterSA : tokenSA;
-            }
-
-            // evaluate Creature with +1/+1
-            int evalCounter = ComputerUtilCard.evaluateCreature(copy);
-
-            final CardCollection tokenList = new CardCollection(host);
-            for (int i = 0; i < n; ++i) {
-                tokenList.add(TokenAi.spawnToken(player, tokenSA));
-            }
-
-            // evaluate Host with Tokens
-            int evalToken = ComputerUtilCard.evaluateCreatureList(tokenList);
-
-            return evalToken >= evalCounter ? tokenSA : counterSA;
         } else if ("CombustibleGearhulk".equals(logic)) {
             Player controller = sa.getActivatingPlayer();
             List<ZoneType> zones = ZoneType.listValueOf("Graveyard, Battlefield, Exile");

forge-ai/src/main/java/forge/ai/ability/ChooseSourceAi.java

@@ -6,7 +6,6 @@ import java.util.Map;
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
 
 import forge.ai.AiAttackController;
 import forge.ai.ComputerUtilCard;
@@ -74,9 +73,11 @@ public class ChooseSourceAi extends SpellAbilityAi {
                     }
 
                     final Card threatSource = topStack.getHostCard();
-                    List<? extends GameObject> objects = getTargets(topStack);
+                    List<? extends GameObject> objects;
                     if (!topStack.usesTargeting() && topStack.hasParam("ValidPlayers") && !topStack.hasParam("Defined")) {
                         objects = AbilityUtils.getDefinedPlayers(threatSource, topStack.getParam("ValidPlayers"), topStack);
+                    } else {
+                        objects = getTargets(topStack);
                     }
 
                     if (!objects.contains(ai) || topStack.hasParam("NoPrevention")) {
@@ -201,7 +202,7 @@ public class ChooseSourceAi extends SpellAbilityAi {
 
     private static List<GameObject> getTargets(final SpellAbility sa) {
         return sa.usesTargeting() && (!sa.hasParam("Defined"))
-                ? Lists.newArrayList(sa.getTargets())
+                ? sa.getTargets()
                 : AbilityUtils.getDefinedObjects(sa.getHostCard(), sa.getParam("Defined"), sa);
     }
 }

forge-ai/src/main/java/forge/ai/ability/ChooseTypeAi.java

@@ -4,8 +4,6 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-import com.google.common.base.Predicates;
-
 import com.google.common.collect.Iterables;
 import forge.ai.AiCardMemory;
 import forge.ai.ComputerUtilAbility;
@@ -82,7 +80,7 @@ public class ChooseTypeAi extends SpellAbilityAi {
 
         if (maxX > 1) {
             CardCollection cre = CardLists.filter(aiPlayer.getCardsIn(ZoneType.Battlefield),
-                    Predicates.and(CardPredicates.isType(chosenType), CardPredicates.Presets.UNTAPPED));
+                    CardPredicates.isType(chosenType), CardPredicates.Presets.UNTAPPED);
             if (!cre.isEmpty()) {
                 for (Card c: cre) {
                     avgPower += c.getNetPower();

forge-ai/src/main/java/forge/ai/ability/ClashAi.java

@@ -59,7 +59,7 @@ public class ClashAi extends SpellAbilityAi {
     @Override
     protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options, Map<String, Object> params) {
         for (Player p : options) {
-            if (p.getCardsIn(ZoneType.Library).size() == 0)
+            if (p.getCardsIn(ZoneType.Library).isEmpty())
                 return p;
         }
 

forge-ai/src/main/java/forge/ai/ability/CloneAi.java

@@ -69,7 +69,6 @@ public class CloneAi extends SpellAbilityAi {
                         bFlag = true;
                     }
                 }
-
             }
 
             if (!bFlag) { // All of the defined stuff is cloned, not very useful
@@ -154,11 +153,11 @@ public class CloneAi extends SpellAbilityAi {
      * @see forge.card.ability.SpellAbilityAi#confirmAction(forge.game.player.Player, forge.card.spellability.SpellAbility, forge.game.player.PlayerActionConfirmMode, java.lang.String)
      */
     @Override
-    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {
         if (sa.hasParam("AILogic") && (!sa.usesTargeting() || sa.isTargetNumberValid())) {
             // Had a special logic for it and managed to target, so confirm if viable
             if ("CloneBestCreature".equals(sa.getParam("AILogic"))) {
-                return ComputerUtilCard.evaluateCreature(sa.getTargets().getFirstTargetedCard()) > ComputerUtilCard.evaluateCreature(sa.getHostCard());
+                return ComputerUtilCard.evaluateCreature(sa.getTargetCard()) > ComputerUtilCard.evaluateCreature(sa.getHostCard());
             } else if ("IfDefinedCreatureIsBetter".equals(sa.getParam("AILogic"))) {
                 List<Card> defined = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa);
                 Card bestDefined = ComputerUtilCard.getBestCreatureAI(defined);
@@ -229,7 +228,7 @@ public class CloneAi extends SpellAbilityAi {
                 tgtCard = cloneTargets.get(0);
             }
         } else if (sa.hasParam("Choices") && sa.usesTargeting()) {
-            tgtCard = sa.getTargets().getFirstTargetedCard();
+            tgtCard = sa.getTargetCard();
         }
 
         return tgtCard;

forge-ai/src/main/java/forge/ai/ability/ConniveAi.java

@@ -0,0 +1,116 @@
+package forge.ai.ability;
+
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilMana;
+import forge.ai.SpellAbilityAi;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardLists;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+import forge.game.zone.ZoneType;
+
+public class ConniveAi extends SpellAbilityAi {
+    @Override
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
+        if (!ai.canDraw()) {
+            return false; // can't draw anything
+        }
+
+        CardCollection list = CardLists.getTargetableCards(ai.getCardsIn(ZoneType.Battlefield), sa);
+
+        // Filter AI-specific targets if provided
+        list = ComputerUtil.filterAITgts(sa, ai, list, false);
+
+        if ("X".equals(sa.getParam("TargetMax")) && "Count$xPaid".equals(sa.getSVar("X"))) {
+            // TODO: consider making the library margin (currently hardcoded to 5) a configurable AI parameter
+            int maxTargets = Math.min(list.size(), Math.max(0, ai.getCardsIn(ZoneType.Library).size() - 5));
+            maxTargets = Math.min(maxTargets, ComputerUtilMana.getAvailableManaEstimate(ai));
+            sa.setXManaCostPaid(maxTargets);
+        }
+
+        sa.resetTargets();
+        while (sa.canAddMoreTarget()) {
+            if ((list.isEmpty() && sa.isTargetNumberValid() && !sa.getTargets().isEmpty())) {
+                return true;
+            }
+
+            if (list.isEmpty()) {
+                // Still an empty list, but we have to choose something (mandatory); expand targeting to
+                // include AI's own cards to see if there's anything targetable (e.g. Plague Belcher).
+                list = CardLists.getTargetableCards(ai.getCardsIn(ZoneType.Battlefield), sa);
+            }
+
+            if (list.isEmpty()) {
+                // Not mandatory, or the the list was regenerated and is still empty,
+                // so return whether or not we found enough targets
+                return sa.isTargetNumberValid();
+            }
+
+            Card choice = ComputerUtilCard.getBestCreatureAI(list);
+
+            if (choice != null) {
+                sa.getTargets().add(choice);
+                list.remove(choice);
+            } else {
+                // Didn't want to choose anything?
+                list.clear();
+            }
+        }
+        return !sa.getTargets().isEmpty() && sa.isTargetNumberValid();
+    }
+
+    @Override
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
+        if (!ai.canDraw() && !mandatory) {
+            return false; // can't draw anything
+        }
+
+        boolean preferred = true;
+        CardCollection list = CardLists.getTargetableCards(ai.getCardsIn(ZoneType.Battlefield), sa);
+
+        // Filter AI-specific targets if provided
+        list = ComputerUtil.filterAITgts(sa, ai, list, false);
+
+        sa.resetTargets();
+        while (sa.canAddMoreTarget()) {
+            if (mandatory) {
+                if ((list.isEmpty() || !preferred) && sa.isTargetNumberValid()) {
+                    return true;
+                }
+
+                if (list.isEmpty() && preferred) {
+                    // If it's required to choose targets and the list is empty, get a new list
+                    list = CardLists.getTargetableCards(ai.getOpponents().getCardsIn(ZoneType.Battlefield), sa);
+                    preferred = false;
+                }
+
+                if (list.isEmpty()) {
+                    // Still an empty list, but we have to choose something (mandatory); expand targeting to
+                    // include AI's own cards to see if there's anything targetable (e.g. Plague Belcher).
+                    list = CardLists.getTargetableCards(ai.getCardsIn(ZoneType.Battlefield), sa);
+                    preferred = false;
+                }
+            }
+
+            if (list.isEmpty()) {
+                // Not mandatory, or the the list was regenerated and is still empty,
+                // so return whether or not we found enough targets
+                return sa.isTargetNumberValid();
+            }
+
+            Card choice = ComputerUtilCard.getBestCreatureAI(list);
+
+            if (choice != null) {
+                sa.getTargets().add(choice);
+                list.remove(choice);
+            } else {
+                // Didn't want to choose anything?
+                list.clear();
+            }
+        }
+        return true;
+    }
+
+}

forge-ai/src/main/java/forge/ai/ability/ControlGainAi.java

@@ -82,7 +82,7 @@ public class ControlGainAi extends SpellAbilityAi {
         // if Defined, then don't worry about targeting
         if (tgt == null) {
             if (sa.hasParam("AllValid")) {
-                CardCollectionView tgtCards = CardLists.filterControlledBy(game.getCardsIn(ZoneType.Battlefield), opponents);
+                CardCollectionView tgtCards = opponents.getCardsIn(ZoneType.Battlefield);
                 tgtCards = AbilityUtils.filterListByType(tgtCards, sa.getParam("AllValid"), sa);
                 return !tgtCards.isEmpty();
             }
@@ -309,7 +309,7 @@ public class ControlGainAi extends SpellAbilityAi {
 
         if (!sa.usesTargeting()) {
             if (sa.hasParam("AllValid")) {
-                CardCollectionView tgtCards = CardLists.filterControlledBy(game.getCardsIn(ZoneType.Battlefield), ai.getOpponents());
+                CardCollectionView tgtCards = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
                 tgtCards = AbilityUtils.filterListByType(tgtCards, sa.getParam("AllValid"), sa);
                 if (tgtCards.isEmpty()) {
                     return false;

forge-ai/src/main/java/forge/ai/ability/CopyPermanentAi.java

@@ -34,7 +34,6 @@ import forge.game.player.PlayerActionConfirmMode;
 import forge.game.player.PlayerCollection;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
-import forge.util.collect.FCollection;
 
 public class CopyPermanentAi extends SpellAbilityAi {
     @Override
@@ -131,7 +130,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
         if (sa.usesTargeting()) {
             sa.resetTargets();
 
-            CardCollection list = new CardCollection(CardUtil.getValidCardsToTarget(sa.getTargetRestrictions(), sa));
+            List<Card> list = CardUtil.getValidCardsToTarget(sa.getTargetRestrictions(), sa);
 
             //Nothing to target
             if (list.isEmpty()) {
@@ -224,7 +223,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
      * @see forge.card.ability.SpellAbilityAi#confirmAction(forge.game.player.Player, forge.card.spellability.SpellAbility, forge.game.player.PlayerActionConfirmMode, java.lang.String)
      */
     @Override
-    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {
         //TODO: add logic here
         return true;
     }
@@ -254,7 +253,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
     @Override
     protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options, Map<String, Object> params) {
         if (params != null && params.containsKey("Attacker")) {
-            return (Player) ComputerUtilCombat.addAttackerToCombat(sa, (Card) params.get("Attacker"), new FCollection<GameEntity>(options));
+            return (Player) ComputerUtilCombat.addAttackerToCombat(sa, (Card) params.get("Attacker"), options);
         }
         final List<Card> cards = new PlayerCollection(options).getCreaturesInPlay();
         Card chosen = ComputerUtilCard.getBestCreatureAI(cards);
@@ -264,7 +263,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
     @Override
     protected GameEntity chooseSinglePlayerOrPlaneswalker(Player ai, SpellAbility sa, Iterable<GameEntity> options, Map<String, Object> params) {
         if (params != null && params.containsKey("Attacker")) {
-            return ComputerUtilCombat.addAttackerToCombat(sa, (Card) params.get("Attacker"), new FCollection<GameEntity>(options));
+            return ComputerUtilCombat.addAttackerToCombat(sa, (Card) params.get("Attacker"), options);
         }
         // should not be reached
         return super.chooseSinglePlayerOrPlaneswalker(ai, sa, options, params);

forge-ai/src/main/java/forge/ai/ability/CopySpellAbilityAi.java

@@ -71,6 +71,9 @@ public class CopySpellAbilityAi extends SpellAbilityAi {
             } else if (top.getApi() == ApiType.CopySpellAbility) {
                 // Don't try to copy a copy ability, too complex for the AI to handle
                 return false;
+            } else if (top.getApi() == ApiType.Mana) {
+                // would lead to Stack Overflow by trying to play this again
+                return false;
             } else if (top.getApi() == ApiType.DestroyAll || top.getApi() == ApiType.SacrificeAll || top.getApi() == ApiType.ChangeZoneAll || top.getApi() == ApiType.TapAll || top.getApi() == ApiType.UnattachAll) {
                 if (!top.usesTargeting() || top.getActivatingPlayer().equals(aiPlayer)) {
                     // If we activated a mass removal / mass tap / mass bounce / etc. spell, or if the opponent activated it but
@@ -134,7 +137,7 @@ public class CopySpellAbilityAi extends SpellAbilityAi {
     }
 
     @Override
-    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message) {
+    public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {
         // Chain of Acid requires special attention here since otherwise the AI will confirm the copy and then
         // run into the necessity of confirming a mandatory Destroy, thus destroying all of its own permanents.
         if ("ChainOfAcid".equals(sa.getParam("AILogic"))) {

forge-ai/src/main/java/forge/ai/ability/CounterAi.java

@@ -64,8 +64,7 @@ public class CounterAi extends SpellAbilityAi {
 
         if (sa.usesTargeting()) {
             final SpellAbility topSA = ComputerUtilAbility.getTopSpellAbilityOnStack(game, sa);
-            if (!CardFactoryUtil.isCounterableBy(topSA.getHostCard(), sa) || topSA.getActivatingPlayer() == ai
-                    || ai.getAllies().contains(topSA.getActivatingPlayer())) {
+            if ((topSA.isSpell() && !CardFactoryUtil.isCounterableBy(topSA.getHostCard(), sa)) || ai.getYourTeam().contains(topSA.getActivatingPlayer())) {
                 // might as well check for player's friendliness
                 return false;
             } else if (sa.hasParam("ConditionWouldDestroy") && !CounterEffect.checkForConditionWouldDestroy(sa, topSA)) {
@@ -326,7 +325,7 @@ public class CounterAi extends SpellAbilityAi {
                 leastBadOption = tgtSA;
             }
 
-            if (!CardFactoryUtil.isCounterableBy(tgtSA.getHostCard(), sa) ||
+            if ((tgtSA.isSpell() && !CardFactoryUtil.isCounterableBy(tgtSA.getHostCard(), sa)) ||
                 tgtSA.getActivatingPlayer() == ai ||
                 !tgtSA.getActivatingPlayer().isOpponentOf(ai)) {
                 // Is this a "better" least bad option