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

Rename: Urtet, Remnant of Memnarch

.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/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"

.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>

forge-adventure/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>forge</artifactId>
         <groupId>forge</groupId>
-        <version>1.6.50-SNAPSHOT</version>
+        <version>1.6.54</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -11,13 +11,24 @@
     <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>
+        <repository>
+        <id>4thline-repo</id>
+        <url>http://4thline.org/m2</url>
+        <snapshots>
+            <enabled>false</enabled>
+        </snapshots>
+    </repository>
     </repositories>
     <build>
-        <sourceDirectory>src</sourceDirectory>
+        <sourceDirectory>src/main/java</sourceDirectory>
         <resources>
             <resource>
                 <directory>${project.basedir}</directory>
@@ -26,6 +37,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 +67,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 +99,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 +114,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 +132,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 +169,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 +193,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 +235,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>
@@ -272,10 +302,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>
 

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/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("pointsOfInterest:",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/EditorMainWindow.java

@@ -1,5 +1,9 @@
 package forge.adventure.editor;
 
+
+
+import com.badlogic.gdx.tools.particleeditor.ParticleEditor;
+
 import javax.swing.*;
 import java.awt.*;
 
@@ -7,17 +11,37 @@ 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);
+        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());
+
         setVisible(true);
         setSize(800,600);
     }

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,21 +3,21 @@ package forge.adventure.editor;
 import forge.adventure.data.EnemyData;
 
 import javax.swing.*;
-import java.awt.*;
 
 /**
  * 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 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();
+    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();
@@ -28,27 +28,34 @@ public class EnemyEdit extends JComponent {
     public EnemyEdit()
     {
 
-        JComponent center=new JComponent() {  };
-        center.setLayout(new GridLayout(9,2));
+        FormPanel center=new FormPanel() {  };
 
-        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);
+        center.add("Name:",nameField);
+        center.add("Life:",lifeFiled);
+        center.add("Spawn rate:",spawnRate);
+        center.add("Difficulty:",difficulty);
+        center.add("Speed:",speed);
+        center.add("Deck:",deck);
+        center.add("Sprite:",atlas);
+        center.add("Equipment:",equipment);
+        center.add("Colors:",colorField);
+
+        center.add("ai:",ai);
+        center.add("flying:",flying);
+        center.add("boss:",boss);
+
+
+        add(preview);
+        add(center);
+        add(rewards);
 
         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());
+
         nameField.getDocument().addDocumentListener(new DocumentChangeListener(() -> EnemyEdit.this.updateEnemy()));
         deck.getEdit().getDocument().addDocumentListener(new DocumentChangeListener(() -> EnemyEdit.this.updateEnemy()));
         lifeFiled.addChangeListener(e -> EnemyEdit.this.updateEnemy());
@@ -65,6 +72,9 @@ public class EnemyEdit extends JComponent {
             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,7 +84,7 @@ 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);
     }
@@ -94,13 +104,16 @@ 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());

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/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,88 @@
+package forge.adventure.editor;
+
+import forge.adventure.data.PointOfInterestData;
+
+import javax.swing.*;
+
+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);
+
+
+    private boolean updating=false;
+
+    public PointOfInterestEdit()
+    {
+
+        setLayout(new BoxLayout(this,BoxLayout.Y_AXIS));
+        FormPanel parameters=new FormPanel();
+        parameters.setBorder(BorderFactory.createTitledBorder("Parameter"));
+
+        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);
+
+        add(parameters);
+
+        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());
+        refresh();
+    }
+
+    private void updateItem() {
+        if(currentData==null||updating)
+            return;
+        currentData.name=name.getText();
+        currentData.type=  type.getText();
+        currentData.count= ((Integer)  count.getValue()).intValue();
+        currentData.spriteAtlas=spriteAtlas.getEdit().getText();
+        currentData.sprite=sprite.getText();
+        currentData.map=map.getEdit().getText();
+        currentData.radiusFactor=((Float)  radiusFactor.getValue()).floatValue();
+    }
+
+    public void setCurrent(PointOfInterestData data)
+    {
+        currentData=data;
+        refresh();
+    }
+
+    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);
+        updating=false;
+    }
+}

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

@@ -1,6 +1,132 @@
 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 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);
+        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())
+        {
+            Array readEnemies=json.fromJson(Array.class, PointOfInterestData.class, handle);
+            allEnemies = readEnemies;
+        }
+        for (int i=0;i<allEnemies.size;i++) {
+            model.add(i,allEnemies.get(i));
+        }
+    }
+    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/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","mana"});
     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;
 
 /**
@@ -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);

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();
             }
         }
     }
+    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());
-        return new ImageIcon(img.getSubimage(sprite.left,sprite.top, sprite.width, sprite.height).getScaledInstance(32,32,SCALE_FAST));
+            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(32,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&&name!=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())
+        {
+            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()));
             }
+        }
+        if(maxCount<=1)
+        {
+            timer.stop();
+        }
+        else
+        {
             timer.restart();
+        }
+        doLayout();
+        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

@@ -3,10 +3,12 @@ package forge.adventure.editor;
 import forge.adventure.util.Config;
 
 import javax.swing.*;
+import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.io.File;
 import java.io.IOException;
+import java.util.List;
 
 /**
  * Editor class to edit configuration, maybe moved or removed
@@ -26,6 +28,7 @@ public class TextListEdit extends Box {
         });
 
         add(edit);
+        edit.setPreferredSize(new Dimension(400,edit.getPreferredSize().height));
         //add(findButton);
         elements= new JComboBox(possibleElements);
         add(elements);
@@ -59,6 +62,12 @@ public class TextListEdit extends Box {
         }
     }
 
+    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 +86,7 @@ public class TextListEdit extends Box {
         {
             values.append(intValues[i]);
             if(intValues.length>i+2)
-                values.append(";");
+                values.append("\n");
         }
         edit.setText(values.toString());
     }

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.54</version>
     </parent>
 
     <artifactId>forge-ai</artifactId>

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

@@ -20,7 +20,7 @@ package forge.ai;
 import java.util.ArrayList;
 import java.util.List;
 
-import forge.game.staticability.StaticAbilityMustAttack;
+import forge.game.staticability.StaticAbilityAssignCombatDamageAsUnblocked;
 import org.apache.commons.lang3.tuple.Pair;
 
 import com.google.common.base.Predicate;
@@ -47,6 +47,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 +59,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 +73,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 +96,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 +115,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 +151,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 +167,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 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
 
-        if (defender.getLife() > 8) { //Otherwise choose a random opponent to ensure no ganging up on players
+            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);
+                    }
+                }
+            }
+
             // 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;
     }
@@ -356,7 +376,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 +395,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 +414,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 +558,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 +592,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 +600,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 +623,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 +638,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 +680,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 +732,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 +803,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 +812,19 @@ 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()) {
+                    if (combat.getAttackConstraints().getRequirements().get(attacker) == null) continue;
                     // check defenders in order of maximum requirements
-                        GameEntity mustAttackDefMaybe = MapToAmountUtil.max(amounts).getKey();
+                    for (Pair<GameEntity, Integer> e : combat.getAttackConstraints().getRequirements().get(attacker).getSortedRequirements()) {
+                        if (e.getRight() == 0) continue;
+                        GameEntity mustAttackDefMaybe = e.getLeft();
+                        // Gideon Jura returns LKI
+                        if (mustAttackDefMaybe instanceof Card) {
+                            mustAttackDefMaybe = ai.getGame().getCardState((Card) mustAttackDefMaybe);
+                        }
                         if (canAttackWrapper(attacker, mustAttackDefMaybe) && CombatUtil.getAttackCost(ai.getGame(), attacker, mustAttackDefMaybe) == null) {
                             mustAttackDef = mustAttackDefMaybe;
                             break;
                         }
-                        amounts.remove(mustAttackDefMaybe);
                     }
                 }
                 if (mustAttackDef != null) {
@@ -836,6 +856,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 +866,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 +912,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 +947,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 +955,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 +997,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 +1022,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 +1072,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 +1086,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 +1149,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 +1199,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);
@@ -1422,7 +1441,7 @@ public class AiAttackController {
                     continue;
                 }
                 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;
-                }
+
                 // 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

@@ -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;
@@ -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;
     }
@@ -141,13 +150,6 @@ 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);
@@ -164,7 +166,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);
                     }
@@ -261,11 +263,6 @@ public class AiController {
             }
         }
 
-        if (card.isCreature()
-                && game.getStaticEffects().getGlobalRuleChange(GlobalRuleChange.noCreatureETBTriggers)) {
-            return api == null;
-        }
-
         boolean rightapi = false;
 
         // Trigger play improvements
@@ -280,6 +277,12 @@ 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")) {
@@ -445,7 +448,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 +501,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;
@@ -582,7 +585,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);
@@ -637,7 +640,7 @@ public class AiController {
             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.
@@ -709,9 +712,10 @@ public class AiController {
             return AiPlayDecision.CantPlaySa;
         }
 
+        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 +738,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,21 +746,21 @@ 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;
+        CardStateName currentState = sa.getCardState() != null && host.getCurrentStateName() != sa.getCardStateName() && !host.isInPlay() ? host.getCurrentStateName() : null;
         if (currentState != null) {
-            sa.getHostCard().setState(sa.getCardStateName(), false);
+            host.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);
+            host.setState(currentState, false);
         }
 
         if (canPlay != AiPlayDecision.WillPlay) {
@@ -765,11 +769,11 @@ public class AiController {
 
         // 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 +782,9 @@ 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 +810,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 +817,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,13 +889,14 @@ 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);
         }
         if (sa.usesTargeting()) {
@@ -906,18 +908,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;
     }
 
@@ -1049,11 +1046,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;
                 }
             }
@@ -1082,6 +1077,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;
@@ -1321,7 +1319,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 +1332,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) {
@@ -1404,8 +1402,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;
                 }
             }
@@ -1469,11 +1467,9 @@ 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")
         );
-
         if (!playBeforeLand.isEmpty()) {
             SpellAbility wantToPlayBeforeLand = chooseSpellAbilityToPlayFromList(
                 ComputerUtilAbility.getSpellAbilities(playBeforeLand, player), false
@@ -1483,15 +1479,15 @@ public class AiController {
             }
         }
         
+        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)) {
+                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
@@ -1521,13 +1517,12 @@ public class AiController {
                 }
             }
         }
-        }
 
         return singleSpellAbilityList(getSpellAbilityToPlay());
     }
 
     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 +1605,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")
@@ -1639,7 +1641,8 @@ public class AiController {
     }
 
     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;
@@ -1677,8 +1680,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()));
             }
         });
 
@@ -1719,7 +1723,7 @@ public class AiController {
                 }
             }
 
-            sa.setActivatingPlayer(player);
+            sa.setActivatingPlayer(player, true);
             SpellAbility root = sa.getRootAbility();
 
             if (root.isSpell() || root.isTrigger() || root.isReplacementAbility()) {
@@ -1839,7 +1843,6 @@ 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) {
@@ -1925,8 +1928,8 @@ public class AiController {
             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 +1944,22 @@ 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");
     }
@@ -2106,22 +2125,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();

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;
 
@@ -55,6 +57,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(),
@@ -438,7 +448,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

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;
@@ -127,15 +128,15 @@ 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)) {
+        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();
             if (!sa.isTargetNumberValid()) {
@@ -230,7 +231,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 +246,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 +265,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 +286,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 +298,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,17 +307,30 @@ 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)) {
+            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);
@@ -310,7 +338,7 @@ public class ComputerUtil {
     }
 
     public static final void playNoStack(final Player ai, SpellAbility sa, final Game game, final boolean effect) {
-        sa.setActivatingPlayer(ai);
+        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();
@@ -329,9 +357,6 @@ public class ComputerUtil {
             }
 
             AbilityUtils.resolve(sa);
-
-            // destroys creatures if they have lethal damage, etc..
-            //game.getAction().checkStateEffects();
         }
     }
 
@@ -426,8 +451,20 @@ public class ComputerUtil {
             }
 
             // try everything when about to die
-            if (game.getPhaseHandler().getPhase().equals(PhaseType.COMBAT_DECLARE_BLOCKERS)
-                    && ComputerUtilCombat.lifeInSeriousDanger(ai, game.getCombat())) {
+            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);
@@ -437,6 +474,7 @@ public class ComputerUtil {
                     }
                 }
             }
+        }
         else if (pref.contains("DiscardCost")) { // search for permanents with DiscardMe
             for (int ip = 0; ip < 6; ip++) { // priority 0 is the lowest, priority 5 the highest
                 final int priority = 6 - ip;
@@ -586,7 +624,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);
             }
@@ -817,17 +855,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 +970,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
                     }
@@ -1039,6 +1078,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 +1089,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 +1109,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 +1117,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;
                 }
             }
@@ -1227,12 +1267,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 +1546,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) {
@@ -2030,7 +2070,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 +2298,31 @@ public class ComputerUtil {
         if (goodChoices.isEmpty()) {
             goodChoices = validCards;
         }
-        final CardCollection dChoices = new CardCollection();
+
+        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) {
-                    dChoices.add(c);
+                        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 new CardCollection(Aggregates.random(goodChoices, max));
     }
 
     public static CardCollection getCardsToDiscardFromFriend(Player aiChooser, Player p, SpellAbility sa, CardCollection validCards, int min, int max) {
@@ -2286,7 +2334,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 +2363,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 +2395,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 +2417,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 +2669,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 +2682,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 +2854,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 +2869,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 +2977,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 +3000,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 +3009,8 @@ public class ComputerUtil {
         }
 
         if (targets.isEmpty()) {
-            if (mandatory && !options.isEmpty()) {
-                targets = options;
+            if (mandatory && !Iterables.isEmpty(options)) {
+                targets.addAll(options);
             } else {
                 return false;
             }

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));
         }
 
@@ -118,7 +118,7 @@ public class ComputerUtilAbility {
 
         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/ComputerUtilCard.java

@@ -45,6 +45,7 @@ import forge.game.combat.CombatUtil;
 import forge.game.cost.Cost;
 import forge.game.cost.CostPayEnergy;
 import forge.game.cost.CostRemoveCounter;
+import forge.game.cost.CostUntap;
 import forge.game.keyword.Keyword;
 import forge.game.keyword.KeywordCollection;
 import forge.game.keyword.KeywordInterface;
@@ -385,6 +386,9 @@ public class ComputerUtilCard {
      * @return the card
      */
     public static Card getBestCreatureAI(final Iterable<Card> list) {
+        if (Iterables.size(list) == 1) {
+            return Iterables.get(list, 0);
+        }
         return Aggregates.itemWithMax(Iterables.filter(list, CardPredicates.Presets.CREATURES), ComputerUtilCard.creatureEvaluator);
     }
 
@@ -397,6 +401,9 @@ public class ComputerUtilCard {
      * @return a {@link forge.game.card.Card} object.
      */
     public static Card getWorstCreatureAI(final Iterable<Card> list) {
+        if (Iterables.size(list) == 1) {
+            return Iterables.get(list, 0);
+        }
         return Aggregates.itemWithMin(Iterables.filter(list, CardPredicates.Presets.CREATURES), ComputerUtilCard.creatureEvaluator);
     }
 
@@ -410,6 +417,9 @@ public class ComputerUtilCard {
      * @return a {@link forge.game.card.Card} object.
      */
     public static Card getBestCreatureToBounceAI(final CardCollectionView list) {
+        if (Iterables.size(list) == 1) {
+            return Iterables.get(list, 0);
+        }
         final int tokenBonus = 60;
         Card biggest = null;
         int biggestvalue = -1;
@@ -678,7 +688,7 @@ public class ComputerUtilCard {
                     if (!ComputerUtilCost.canPayCost(sa, opp, sa.isTrigger())) {
                         continue;
                     }
-                    sa.setActivatingPlayer(opp);
+                    sa.setActivatingPlayer(opp, true);
                     if (sa.canTarget(card)) {
                         continue;
                     }
@@ -753,30 +763,21 @@ public class ComputerUtilCard {
         return maxName;
     }
 
-    public static String getMostProminentBasicLandType(final CardCollectionView list) {
-        return getMostProminentType(list, CardType.getBasicTypes());
+    public static String getMostProminentType(final CardCollectionView list, final Collection<String> valid) {
+        return getMostProminentType(list, valid, true);
     }
 
-    /**
-     * <p>
-     * getMostProminentCreatureType.
-     * </p>
-     * 
-     * @param list
-     * @return a {@link java.lang.String} object.
-     */
-    public static String getMostProminentCreatureType(final CardCollectionView list) {
-        return getMostProminentType(list, CardType.getAllCreatureTypes());
-    }
-    public static String getMostProminentType(final CardCollectionView list, final Collection<String> valid) {
+    public static String getMostProminentType(final CardCollectionView list, final Collection<String> valid, boolean includeTokens) {
         if (list.size() == 0) {
             return "";
         }
 
         final Map<String, Integer> typesInDeck = Maps.newHashMap();
 
-        // TODO JAVA 8 use getOrDefault
         for (final Card c : list) {
+            if (!includeTokens && c.isToken()) {
+                continue;
+            }
             // Changeling are all creature types, they are not interesting for
             // counting creature types
             if (c.hasStartOfKeyword(Keyword.CHANGELING.toString())) {
@@ -794,15 +795,20 @@ public class ComputerUtilCard {
                 continue;
             }
 
+            // Cards in hand and commanders are worth double, as they are more likely to be played.
+            int weight = 1;
+            if (c.isInZone(ZoneType.Hand) || c.isRealCommander()) {
+                weight = 2;
+            }
+
             Set<String> cardCreatureTypes = c.getType().getCreatureTypes();
             for (String type : cardCreatureTypes) {
-                Integer count = typesInDeck.get(type);
-                if (count == null) {
-                    count = 0;
-                }
-                typesInDeck.put(type, count + 1);
+                Integer count = typesInDeck.getOrDefault(type, 0);
+                typesInDeck.put(type, count + weight);
             }
+
             //also take into account abilities that generate tokens
+            if (includeTokens) {
                 for (SpellAbility sa : c.getAllSpellAbilities()) {
                     if (sa.getApi() != ApiType.Token) {
                         continue;
@@ -812,11 +818,8 @@ public class ComputerUtilCard {
                             if (!CardType.isACreatureType(var)) {
                                 continue;
                             }
-                        Integer count = typesInDeck.get(var);
-                        if (count == null) {
-                            count = 0;
-                        }
-                        typesInDeck.put(var, count + 1);
+                            Integer count = typesInDeck.getOrDefault(var, 0);
+                            typesInDeck.put(var, count + weight);
                         }
                     }
                 }
@@ -831,21 +834,16 @@ public class ComputerUtilCard {
                             if (!CardType.isACreatureType(var)) {
                                 continue;
                             }
-                        Integer count = typesInDeck.get(var);
-                        if (count == null) {
-                            count = 0;
-                        }
-                        typesInDeck.put(var, count + 1);
+                            Integer count = typesInDeck.getOrDefault(var, 0);
+                            typesInDeck.put(var, count + weight);
                         }
                     }
                 }
                 // special rule for Fabricate and Servo
                 if (c.hasStartOfKeyword(Keyword.FABRICATE.toString())) {
-                Integer count = typesInDeck.get("Servo");
-                if (count == null) {
-                    count = 0;
+                    Integer count = typesInDeck.getOrDefault("Servo", 0);
+                    typesInDeck.put("Servo", count + weight);
                 }
-                typesInDeck.put("Servo", count + 1);
             }
         } // for
 
@@ -864,6 +862,41 @@ public class ComputerUtilCard {
         return maxType;
     }
 
+    public static String getMostProminentCardType(final CardCollectionView list, final Collection<String> valid) {
+        if (list.isEmpty() || valid.isEmpty()) {
+            return "";
+        }
+
+        final Map<String, Integer> typesInDeck = Maps.newHashMap();
+        for (String type : valid) {
+            typesInDeck.put(type, 0);
+        }
+
+        for (final Card c : list) {
+            Iterable<CardType.CoreType> cardTypes = c.getType().getCoreTypes();
+            for (CardType.CoreType type : cardTypes) {
+                Integer count = typesInDeck.get(type.toString());
+                if (count != null) {
+                    typesInDeck.put(type.toString(), count + 1);
+                }
+            }
+        }
+
+        int max = 0;
+        String maxType = "";
+
+        for (final Entry<String, Integer> entry : typesInDeck.entrySet()) {
+            final String type = entry.getKey();
+
+            if (max < entry.getValue()) {
+                max = entry.getValue();
+                maxType = type;
+            }
+        }
+
+        return maxType;
+    }
+
     /**
      * <p>
      * getMostProminentColor.
@@ -1034,7 +1067,8 @@ public class ComputerUtilCard {
 
         }
         if (chosen.isEmpty()) {
-            chosen.add(MagicColor.Constant.GREEN);
+            //chosen.add(MagicColor.Constant.GREEN);
+            chosen.add(getMostProminentColor(ai.getAllCards(), colorChoices));
         }
         return chosen;
     }
@@ -1384,14 +1418,16 @@ public class ComputerUtilCard {
                 double nonCombatChance = 0.0f;
                 double combatChance = 0.0f;
                 // non-combat Haste: has an activated ability with tap cost
+                if (c.isAbilitySick()) {
                     for (SpellAbility ab : c.getSpellAbilities()) {
                         Cost abCost = ab.getPayCosts();
-                    if (abCost != null && abCost.hasTapCost()
-                            && (!abCost.hasManaCost() || ComputerUtilMana.canPayManaCost(ab, ai, 0, false))) {
+                        if (abCost != null && (abCost.hasTapCost() || abCost.hasSpecificCostType(CostUntap.class))
+                                && (!abCost.hasManaCost() || ComputerUtilMana.canPayManaCost(ab, ai, sa.getPayCosts().getTotalMana().getCMC(), false))) {
                             nonCombatChance += 0.5f;
                             break;
                         }
                     }
+                }
                 // combat Haste: only grant it if the creature will attack
                 if (doesSpecifiedCreatureAttackAI(ai, pumped)) {
                     combatChance += 0.5f + (0.5f * ComputerUtilCombat.damageIfUnblocked(pumped, opp, combat, true) / opp.getLife());
@@ -1675,7 +1711,7 @@ public class ComputerUtilCard {
         pumped.addPTBoost(power + berserkPower, toughness, timestamp, 0);
 
         if (!kws.isEmpty()) {
-            pumped.addChangedCardKeywords(kws, null, false, timestamp, 0);
+            pumped.addChangedCardKeywords(kws, null, false, timestamp, 0, false);
         }
         if (!hiddenKws.isEmpty()) {
             pumped.addHiddenExtrinsicKeywords(timestamp, 0, hiddenKws);
@@ -1696,7 +1732,8 @@ public class ComputerUtilCard {
             }
         }
         final long timestamp2 = c.getGame().getNextTimestamp(); //is this necessary or can the timestamp be re-used?
-        pumped.addChangedCardKeywordsInternal(toCopy, null, false, timestamp2, 0, true);
+        pumped.addChangedCardKeywordsInternal(toCopy, null, false, timestamp2, 0, false);
+        pumped.updateKeywordsCache(pumped.getCurrentState());
         applyStaticContPT(ai.getGame(), pumped, new CardCollection(c));
         return pumped;
     }
@@ -1883,7 +1920,7 @@ public class ComputerUtilCard {
                 }
             }
             if (!canBeBlocked) {
-                boolean threat = atk.getNetCombatDamage() >= ai.getLife() - lifeInDanger;
+                boolean threat = ComputerUtilCombat.getAttack(atk) >= ai.getLife() - lifeInDanger;
                 if (!priorityRemovalOnlyInDanger || threat) {
                     priorityCards.add(atk);
                 }
@@ -2019,6 +2056,28 @@ public class ComputerUtilCard {
         return false;
     }
 
+    public static CardCollection dedupeCards(CardCollection cc) {
+        if (cc.size() <= 1) {
+            return cc;
+        }
+        CardCollection deduped = new CardCollection();
+        for (Card c : cc) {
+            boolean unique = true;
+            if (c.isInZone(ZoneType.Hand)) {
+                for (Card d : deduped) {
+                    if (d.isInZone(ZoneType.Hand) && d.getOwner().equals(c.getOwner()) && d.getName().equals(c.getName())) {
+                        unique = false;
+                        break;
+                    }
+                }
+            }
+            if (unique) {
+                deduped.add(c);
+            }
+        }
+        return deduped;
+    }
+
     // Determine if the AI has an AI:RemoveDeck:All or an AI:RemoveDeck:Random hint specified.
     // Includes a NPE guard on getRules() which might otherwise be tripped on some cards (e.g. tokens).
     public static boolean isCardRemAIDeck(final Card card) {

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;
@@ -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,18 +367,18 @@ 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 (trampleDamage > 0) {
                     if (attacker.hasKeyword(Keyword.INFECT)) {
                         poison += trampleDamage;
                     }
                     poison += predictPoisonFromTriggers(attacker, ai, trampleDamage);
                 }
             }
+        }
 
         poison += sumPoisonIfUnblocked(unblocked, ai);
 
@@ -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
     /**
@@ -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();
@@ -1259,7 +1254,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 +1263,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 +1287,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 +1372,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 +1434,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 +1450,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 +1476,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 +1496,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 +1508,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");
                     }
@@ -2067,7 +2054,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 +2109,7 @@ public class ComputerUtilCombat {
             }
         }
         return damageMap;
-    } // setAssignedDamage()
+    }
 
     // how much damage is enough to kill the creature (for AI)
     /**
@@ -2489,11 +2475,13 @@ 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;
     }
@@ -2503,7 +2491,7 @@ public class ComputerUtilCombat {
         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() && defenders.contains(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
@@ -525,13 +525,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 +592,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 +635,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 +692,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,10 +776,13 @@ 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 +791,17 @@ 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;
+                }
+                // 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 +876,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
@@ -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,6 +681,8 @@ 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,
@@ -708,7 +711,7 @@ public class ComputerUtilMana {
                 }
                 manapool.applyCardMatrix(pay);
 
-                for (byte color : MagicColor.WUBRGC) {
+                for (byte color : ManaAtom.MANATYPES) {
                     if (manapool.tryPayCostWithColor(color, sa, cost)) {
                         found = true;
                         break;
@@ -884,7 +887,7 @@ public class ComputerUtilMana {
         }
 
         return true;
-    } // payManaCost()
+    }
 
     private static void resetPayment(List<SpellAbility> payments) {
         for (SpellAbility sa : payments) {
@@ -958,7 +961,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 +968,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 +1015,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 +1041,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;
                 }
@@ -1406,8 +1408,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 +1423,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 +1462,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 +1519,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 +1588,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 +1617,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,7 +10,10 @@ import forge.game.card.CounterEnumType;
 import forge.game.cost.CostPayEnergy;
 import forge.game.keyword.Keyword;
 import forge.game.spellability.SpellAbility;
+import forge.game.staticability.StaticAbility;
+import forge.game.staticability.StaticAbilityAssignCombatDamageAsUnblocked;
 import forge.game.staticability.StaticAbilityMustAttack;
+import forge.game.zone.ZoneType;
 
 import java.util.List;
 
@@ -44,7 +47,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.hasBackSide()) {
                 value += addValue(power * 10, "transforming");
             }
         }
@@ -59,10 +62,19 @@ public class CreatureEvaluator implements Function<Card, Integer> {
         if (c.hasKeyword(Keyword.HORSEMANSHIP)) {
             value += addValue(power * 10, "horses");
         }
-        if (c.hasKeyword("Unblockable")) {
+        boolean unblockable = false;
+        for (final Card ca : c.getGame().getCardsIn(ZoneType.STATIC_ABILITIES_SOURCE_ZONES)) {
+            for (final StaticAbility stAb : ca.getStaticAbilities()) {
+                if (stAb.applyAbility("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.")) {
+                    unblockable = true;
+                    break;
+                }
+            }
+        }
+        if (!unblockable) {
+            if (StaticAbilityAssignCombatDamageAsUnblocked.assignCombatDamageAsUnblocked(c)
+                    || StaticAbilityAssignCombatDamageAsUnblocked.assignCombatDamageAsUnblocked(c, false)) {
                 value += addValue(power * 6, "thorns");
             }
             if (c.hasKeyword(Keyword.FEAR)) {
@@ -102,10 +114,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");
@@ -314,13 +305,13 @@ public abstract class GameState {
                 newText.append("|Meld");
             } else if (c.getCurrentStateName().equals(CardStateName.Modal)) {
                 newText.append("|Modal");
+            } else if (c.getCurrentStateName().equals(CardStateName.Converted)) {
+                newText.append("|Converted");
             }
 
             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 +337,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 +364,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 +451,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 +501,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 +567,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 +619,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 +659,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 +733,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 +771,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 +815,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,38 +879,24 @@ 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 (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, human, game);
+                    precastSpellFromCard(spell, game.getPlayers().get(i), game);
                 }
             }
-        if (precastAI != null) {
-            String[] spellList = TextUtil.split(precastAI, ';');
-            for (String spell : spellList) {
-                precastSpellFromCard(spell, ai, 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 (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, human, game, true);
+                    precastSpellFromCard(spell, game.getPlayers().get(i), game, true);
                 }
             }
-        if (putOnStackAI != null) {
-            String[] spellList = TextUtil.split(putOnStackAI, ';');
-            for (String spell : spellList) {
-                precastSpellFromCard(spell, ai, game, true);
-            }
         }
     }
 
@@ -1134,18 +1027,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 +1068,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 +1089,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 +1105,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 +1161,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 +1200,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 +1231,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,12 +1244,15 @@ 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";
@@ -1371,16 +1277,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,12 +1,9 @@
 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 java.util.*;
 
+import forge.game.keyword.Keyword;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
@@ -34,6 +31,7 @@ import forge.game.GameObject;
 import forge.game.GameType;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
+import forge.game.ability.effects.CharmEffect;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardCollectionView;
@@ -45,8 +43,6 @@ 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.CostPart;
 import forge.game.cost.CostPartMana;
 import forge.game.keyword.KeywordInterface;
@@ -269,8 +265,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
@@ -576,10 +572,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 +586,8 @@ 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
@@ -697,29 +693,13 @@ 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);
+            // transfer this info for Balduvian Fallen
+            sa.setPayingMana(ability.getPayingMana());
             return true;
         }
         return false;
@@ -727,7 +707,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);
     }
 
@@ -798,7 +777,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 +787,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 +918,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,7 +1066,7 @@ 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());
@@ -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);
+                        TargetChoices tc = sa.getTargets();
+                        if (!sa.setupTargets()) {
+                            // if AI can't choose targets need to keep old one even if illegal
+                            sa.setTargets(tc);
                         }
-                    */
-                    if (sa.isMayChooseNewTargets() && !sa.setupTargets()) {
-                        if (sa.isSpell()) {
-                            getGame().getAction().ceaseToExist(sa.getHostCard(), false);
-                        }
-                        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

@@ -47,6 +47,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)
@@ -71,6 +72,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)
@@ -169,6 +171,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 +187,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,7 +42,6 @@ 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.trigger.Trigger;
@@ -78,9 +76,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 +121,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 +614,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,8 +661,14 @@ public class AttachAi extends SpellAbilityAi {
             if (card.hasKeyword(Keyword.HORSEMANSHIP)) {
                 cardPriority += 40;
             }
-            if (card.hasKeyword("Unblockable")) {
+            //check if card is generally unblockable
+            for (final Card ca : card.getGame().getCardsIn(ZoneType.STATIC_ABILITIES_SOURCE_ZONES)) {
+                for (final StaticAbility stAb : ca.getStaticAbilities()) {
+                    if (stAb.applyAbility("CantBlockBy", card, null)) {
                         cardPriority += 50;
+                        break;
+                    }
+                }
             }
             // Prefer "tap to deal damage"
             // TODO : Skip this one if triggers on combat damage only?
@@ -1307,16 +1309,20 @@ 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")) {
+            attachSource = AbilityUtils.getDefinedCards(attachSource, sa.getParam("Object"), sa).get(0);
+        }
 
         // Don't equip if DontEquip SVar is set
         if (attachSource.hasSVar("DontEquip")) {
             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));
@@ -1354,7 +1360,7 @@ public class AttachAi extends SpellAbilityAi {
         if (tgt == null) {
             list = AbilityUtils.getDefinedCards(attachSource, sa.getParam("Defined"), sa);
         } else {
-            list = CardLists.filter(CardUtil.getValidCardsToTarget(tgt, sa), CardPredicates.canBeAttached(attachSource));
+            list = CardLists.filter(CardUtil.getValidCardsToTarget(tgt, sa), CardPredicates.canBeAttached(attachSource, sa));
         }
 
         if (list.isEmpty()) {
@@ -1555,7 +1561,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 +1569,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 +1580,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 +1616,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 +1632,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;
         }
@@ -1736,7 +1740,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/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;
@@ -124,8 +123,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,14 +271,10 @@ 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()))) {
+            if (sa.isNinjutsu()) {
+                if (!source.ignoreLegendRule() && ai.isCardInPlay(source.getName())) {
                     return false;
                 }
-                }
                 if (ai.getGame().getPhaseHandler().getPhase().isAfter(PhaseType.COMBAT_DAMAGE)) {
                     return false;
                 }
@@ -732,10 +725,9 @@ 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()))) {
+                    if (!(!c.ignoreLegendRule() && ai.isCardInPlay(c.getName()))) {
                         nothingWillReturn = false;
                         break;
                     }
@@ -745,7 +737,6 @@ public class ChangeZoneAi extends SpellAbilityAi {
                 }
             }
         }
-        }
 
         final AbilitySub subAb = sa.getSubAbility();
         return subAb == null || SpellApiToAi.Converter.get(subAb.getApi()).chkDrawbackWithSubs(ai, subAb);
@@ -1009,6 +1000,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 +1046,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)) {
@@ -1275,7 +1275,7 @@ 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()) {
@@ -1283,9 +1283,7 @@ public class ChangeZoneAi extends SpellAbilityAi {
                         toRemove.add(t);
                     }
                 }
-                for (Card dontTarget : toRemove) {
-                   sa.getTargets().remove(dontTarget);
-                }
+                sa.getTargets().removeAll(toRemove);
             }
         }
 
@@ -1746,7 +1744,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;
     }
@@ -1862,80 +1860,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,6 +1,7 @@
 package forge.ai.ability;
 
 import java.util.Collections;
+import java.util.Map;
 
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
@@ -70,7 +71,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
@@ -277,7 +278,7 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
         }
 
         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) {
@@ -334,7 +335,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);
@@ -373,7 +374,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);

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

@@ -88,8 +88,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 +100,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 +111,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 +219,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 +249,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)) {
@@ -294,6 +302,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/CloneAi.java

@@ -154,11 +154,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 +229,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/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

@@ -131,7 +131,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 +224,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;
     }

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

@@ -134,7 +134,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,7 +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
+            if ((topSA.isSpell() && !CardFactoryUtil.isCounterableBy(topSA.getHostCard(), sa)) || topSA.getActivatingPlayer() == ai
                     || ai.getAllies().contains(topSA.getActivatingPlayer())) {
                 // might as well check for player's friendliness
                 return false;
@@ -326,7 +326,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

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

@@ -214,7 +214,7 @@ public class CountersMoveAi extends SpellAbilityAi {
     private static int calcAmount(final SpellAbility sa, final CounterType cType) {
         final Card host = sa.getHostCard();
 
-        final String amountStr = sa.getParam("CounterNum");
+        final String amountStr = sa.getParamOrDefault("CounterNum", "1");
 
         // TODO handle proper calculation of X values based on Cost
         int amount = 0;
@@ -349,6 +349,9 @@ public class CountersMoveAi extends SpellAbilityAi {
                 }
             }
 
+            return false;
+        } else if (sa.getMaxTargets() == 2) {
+            // TODO
             return false;
         } else {
             // SA uses target for Defined
@@ -361,20 +364,24 @@ public class CountersMoveAi extends SpellAbilityAi {
             }
 
             final Card src = srcCards.get(0);
-            if (cType != null) {
-                if (src.getCounters(cType) <= 0) {
+            if (cType != null && src.getCounters(cType) <= 0) {
                 return false;
             }
+
+            Card lkiWithCounters = CardUtil.getLKICopy(src);
+            Card lkiWithoutCounters = CardUtil.getLKICopy(src);
+            if (cType == null) {
+                lkiWithoutCounters.clearCounters();
+            } else {
+                lkiWithoutCounters.setCounters(cType, 0);
             }
 
-            Card lki = CardUtil.getLKICopy(src);
-            if (cType == null) {
-                lki.clearCounters();
-            } else {
-                lki.setCounters(cType, 0);
-            }
+            // need to fake animate it for P/T
+            lkiWithCounters.addType("Creature");
+            lkiWithoutCounters.addType("Creature");
+
             // go for opponent when higher value implies debuff
-            if (ComputerUtilCard.evaluateCreature(src) > ComputerUtilCard.evaluateCreature(lki)) {
+            if (ComputerUtilCard.evaluateCreature(lkiWithCounters) > ComputerUtilCard.evaluateCreature(lkiWithoutCounters)) {
                 List<Card> aiList = CardLists.filterControlledBy(tgtCards, ai);
                 if (!aiList.isEmpty()) {
                     List<Card> best = CardLists.filter(aiList, new Predicate<Card>() {

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

@@ -5,6 +5,8 @@ import java.util.List;
 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.ComputerUtil;
@@ -97,7 +99,21 @@ public class CountersMultiplyAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        return !sa.usesTargeting() || setTargets(ai, sa) || mandatory;
+        if (!sa.usesTargeting()) {
+            return true;
+        }
+        if (setTargets(ai, sa)) {
+            return true;
+        } else if (mandatory) {
+            CardCollection list = CardLists.getTargetableCards(ai.getGame().getCardsIn(ZoneType.Battlefield), sa);
+            if (list.isEmpty()) {
+                return false;
+            }
+            Card safeMatch = Iterables.getFirst(Iterables.filter(list, Predicates.not(CardPredicates.hasCounters())), null);
+            sa.getTargets().add(safeMatch == null ? list.getFirst() : safeMatch);
+            return true;
+        }
+        return mandatory;
     }
 
     private CounterType getCounterType(SpellAbility sa) {

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

@@ -302,8 +302,8 @@ public class CountersPutAi extends CountersAi {
             }
 
             CardCollection oppCreats = CardLists.filter(ai.getOpponents().getCreaturesInPlay(),
-                    Predicates.and(Predicates.not(CardPredicates.hasCounter(CounterType.getType(type))),
-                            CardPredicates.isTargetableBy(sa)));
+                    Predicates.not(CardPredicates.hasCounter(CounterType.getType(type))),
+                            CardPredicates.isTargetableBy(sa));
 
             if (!oppCreats.isEmpty()) {
                 Card bestCreat = ComputerUtilCard.getBestCreatureAI(oppCreats);
@@ -341,7 +341,7 @@ public class CountersPutAi extends CountersAi {
 
         if (sa.hasParam("Bolster")) {
             CardCollection creatsYouCtrl = ai.getCreaturesInPlay();
-            CardCollection leastToughness = new CardCollection(Aggregates.listWithMin(creatsYouCtrl, CardPredicates.Accessors.fnGetDefense));
+            CardCollection leastToughness = new CardCollection(Aggregates.listWithMin(creatsYouCtrl, CardPredicates.Accessors.fnGetNetToughness));
             if (leastToughness.isEmpty()) {
                 return false;
             }
@@ -427,7 +427,7 @@ public class CountersPutAi extends CountersAi {
                 }
 
                 // need to set Activating player
-                oa.setActivatingPlayer(ai);
+                oa.setActivatingPlayer(ai, true);
                 CardCollection targets = CardLists.getTargetableCards(ai.getOpponents().getCreaturesInPlay(), oa);
 
                 if (!targets.isEmpty()) {
@@ -460,12 +460,12 @@ public class CountersPutAi extends CountersAi {
             // only evaluates case where all tokens are placed on a single target
             if (sa.usesTargeting() && sa.getMinTargets() < 2) {
                 if (ComputerUtilCard.canPumpAgainstRemoval(ai, sa)) {
-                    Card c = sa.getTargets().getFirstTargetedCard();
+                    Card c = sa.getTargetCard();
                     if (sa.getTargets().size() > 1) {
                         sa.resetTargets();
                         sa.getTargets().add(c);
                     }
-                    sa.addDividedAllocation(sa.getTargetCard(), amount);
+                    sa.addDividedAllocation(c, amount);
                     return true;
                 } else {
                     return false;
@@ -680,7 +680,7 @@ public class CountersPutAi extends CountersAi {
             CardCollection list = null;
 
             if (sa.isCurse()) {
-                list = CardLists.filterControlledBy(game.getCardsIn(ZoneType.Battlefield), ai.getOpponents());
+                list = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
             } else {
                 list = new CardCollection(ai.getCardsIn(ZoneType.Battlefield));
             }
@@ -752,22 +752,25 @@ public class CountersPutAi extends CountersAi {
         final int amount = AbilityUtils.calculateAmount(source, amountStr, sa);
         int left = amount;
         final String[] types;
+        String type = "";
         if (sa.hasParam("CounterType")) {
             // TODO some cards let you choose types, should check each
             types = sa.getParam("CounterType").split(",");
-        } else {
+            type = types[0];
+        } else if (sa.hasParam("CounterTypes")) {
             // all types will be added
             types = sa.getParam("CounterTypes").split(",");
+            type = types[0];
         }
-        final String type = types[0];
 
         if (!sa.usesTargeting()) {
             // No target. So must be defined
             list = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
 
             if (amountStr.equals("X")
-                    && root.getXManaCostPaid() != null /* SubAbility on something that already had set PayX, e.g. Endless One ETB counters */
-                    && sa.hasParam(amountStr) && sa.getSVar(amountStr).equals("Count$xPaid")) {
+                    && root.getXManaCostPaid() == null
+                    && source.getXManaCostPaid() == 0 /* SubAbility on something that already had set PayX, e.g. Endless One ETB counters */
+                    && sa.hasSVar(amountStr) && sa.getSVar(amountStr).equals("Count$xPaid")) {
 
                 // detect if there's more than one X in the cost (Hangarback Walker, Walking Ballista, etc.)
                 SpellAbility testSa = sa;
@@ -911,7 +914,7 @@ public class CountersPutAi extends CountersAi {
     }
 
     @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) {
         final Card source = sa.getHostCard();
         if (mode == PlayerActionConfirmMode.Tribute) {
             // add counter if that opponent has a giant creature

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

@@ -1,6 +1,7 @@
 package forge.ai.ability;
 
 import java.util.List;
+import java.util.Map;
 
 import com.google.common.base.Predicate;
 import com.google.common.collect.Lists;
@@ -151,7 +152,7 @@ public class CountersPutAllAi 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) {
         return player.getCreaturesInPlay().size() >= player.getWeakestOpponent().getCreaturesInPlay().size();
     }
 

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

@@ -20,11 +20,13 @@ 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 forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
-import forge.game.GlobalRuleChange;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardCollectionView;
@@ -37,6 +39,7 @@ import forge.game.player.Player;
 import forge.game.player.PlayerController.BinaryChoiceType;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
+import forge.game.zone.ZoneType;
 
 /**
  * <p>
@@ -97,13 +100,19 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
             return true;
         } else {
             // currently only Clockspinning
-            boolean noLegendary = game.getStaticEffects().getGlobalRuleChange(GlobalRuleChange.noLegendRule);
 
             // logic to remove some counter
             CardCollection countersList = CardLists.filter(list, CardPredicates.hasCounters());
 
             if (!countersList.isEmpty()) {
-                if (!ai.isCardInPlay("Marit Lage") || noLegendary) {
+                CardCollectionView marit = ai.getCardsIn(ZoneType.Battlefield, "Marit Lage");
+                boolean maritEmpty = marit.isEmpty() || Iterables.contains(marit, new Predicate<Card>() {
+                    @Override
+                    public boolean apply(Card input) {
+                        return input.ignoreLegendRule();
+                    }
+                });
+                if (maritEmpty) {
                     CardCollectionView depthsList = CardLists.filter(countersList,
                             CardPredicates.nameEquals("Dark Depths"), CardPredicates.hasCounter(CounterEnumType.ICE));
 
@@ -197,11 +206,7 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
      */
     @Override
     public CounterType chooseCounterType(List<CounterType> options, SpellAbility sa, Map<String, Object> params) {
-        if (options.size() > 1) {
         final Player ai = sa.getActivatingPlayer();
-            final Game game = ai.getGame();
-
-            boolean noLegendary = game.getStaticEffects().getGlobalRuleChange(GlobalRuleChange.noLegendRule);
 
         Card tgt = (Card) params.get("Target");
 
@@ -230,7 +235,15 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
         } else {
             // this counters are treat first to be removed
             if ("Dark Depths".equals(tgt.getName()) && options.contains(CounterType.get(CounterEnumType.ICE))) {
-                    if (!ai.isCardInPlay("Marit Lage") || noLegendary) {
+                CardCollectionView marit = ai.getCardsIn(ZoneType.Battlefield, "Marit Lage");
+                boolean maritEmpty = marit.isEmpty() || Iterables.contains(marit, new Predicate<Card>() {
+                    @Override
+                    public boolean apply(Card input) {
+                        return input.ignoreLegendRule();
+                    }
+                });
+
+                if (maritEmpty) {
                     return CounterType.get(CounterEnumType.ICE);
                 }
             } else if (tgt.hasKeyword(Keyword.UNDYING) && options.contains(CounterType.get(CounterEnumType.P1P1))) {
@@ -246,7 +259,6 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
                 }
             }
         }
-        }
 
         return super.chooseCounterType(options, sa, params);
     }
@@ -262,12 +274,10 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
     public boolean chooseBinary(BinaryChoiceType kindOfChoice, SpellAbility sa, Map<String, Object> params) {
         if (kindOfChoice.equals(BinaryChoiceType.AddOrRemove)) {
             final Player ai = sa.getActivatingPlayer();
-            final Game game = ai.getGame();
+
             Card tgt = (Card) params.get("Target");
             CounterType type = (CounterType) params.get("CounterType");
 
-            boolean noLegendary = game.getStaticEffects().getGlobalRuleChange(GlobalRuleChange.noLegendRule);
-
             if (tgt.getController().isOpponentOf(ai)) {
                 if (type.is(CounterEnumType.LOYALTY) && tgt.isPlaneswalker()) {
                     return false;
@@ -276,7 +286,15 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
                 return ComputerUtil.isNegativeCounter(type, tgt);
             } else {
                 if (type.is(CounterEnumType.ICE) && "Dark Depths".equals(tgt.getName())) {
-                    if (!ai.isCardInPlay("Marit Lage") || noLegendary) {
+                    CardCollectionView marit = ai.getCardsIn(ZoneType.Battlefield, "Marit Lage");
+                    boolean maritEmpty = marit.isEmpty() || Iterables.contains(marit, new Predicate<Card>() {
+                        @Override
+                        public boolean apply(Card input) {
+                            return input.ignoreLegendRule();
+                        }
+                    });
+
+                    if (maritEmpty) {
                         return false;
                     }
                 } else if (type.is(CounterEnumType.M1M1) && tgt.hasKeyword(Keyword.PERSIST)) {

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

@@ -3,7 +3,9 @@ package forge.ai.ability;
 import java.util.List;
 import java.util.Map;
 
+import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
+import com.google.common.collect.Iterables;
 
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
@@ -11,7 +13,6 @@ import forge.ai.ComputerUtilCost;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.GameEntity;
-import forge.game.GlobalRuleChange;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
@@ -102,13 +103,12 @@ public class CountersRemoveAi extends SpellAbilityAi {
         final Game game = ai.getGame();
 
         final String type = sa.getParam("CounterType");
-        final String amountStr = sa.getParam("CounterNum");
+        final String amountStr = sa.getParamOrDefault("CounterNum", "1");
 
         // remove counter with Time might use Exile Zone too
         final TargetRestrictions tgt = sa.getTargetRestrictions();
-        CardCollection list = new CardCollection(game.getCardsIn(tgt.getZone()));
         // need to targetable
-        list = CardLists.getTargetableCards(list, sa);
+        CardCollection list = CardLists.getTargetableCards(game.getCardsIn(tgt.getZone()), sa);
 
         if (list.isEmpty()) {
             return false;
@@ -117,16 +117,21 @@ public class CountersRemoveAi extends SpellAbilityAi {
         // Filter AI-specific targets if provided
         list = ComputerUtil.filterAITgts(sa, ai, list, false);
 
-        boolean noLegendary = game.getStaticEffects().getGlobalRuleChange(GlobalRuleChange.noLegendRule);
+        CardCollectionView marit = ai.getCardsIn(ZoneType.Battlefield, "Marit Lage");
+        boolean maritEmpty = marit.isEmpty() || Iterables.contains(marit, new Predicate<Card>() {
+            @Override
+            public boolean apply(Card input) {
+                return input.ignoreLegendRule();
+            }
+        });
 
         if (type.matches("All")) {
             // Logic Part for Vampire Hexmage
             // Break Dark Depths
-            if (!ai.isCardInPlay("Marit Lage") || noLegendary) {
+            if (maritEmpty) {
                 CardCollectionView depthsList = ai.getCardsIn(ZoneType.Battlefield, "Dark Depths");
                 depthsList = CardLists.filter(depthsList, CardPredicates.isTargetableBy(sa),
                         CardPredicates.hasCounter(CounterEnumType.ICE, 3));
-
                 if (!depthsList.isEmpty()) {
                     sa.getTargets().add(depthsList.getFirst());
                     return true;
@@ -161,7 +166,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
             }
             // try to remove them from Dark Depths and Planeswalkers too
 
-            if (!ai.isCardInPlay("Marit Lage") || noLegendary) {
+            if (maritEmpty) {
                 CardCollectionView depthsList = ai.getCardsIn(ZoneType.Battlefield, "Dark Depths");
                 depthsList = CardLists.filter(depthsList, CardPredicates.isTargetableBy(sa),
                         CardPredicates.hasCounter(CounterEnumType.ICE));
@@ -407,9 +412,6 @@ public class CountersRemoveAi extends SpellAbilityAi {
      */
     @Override
     public CounterType chooseCounterType(List<CounterType> options, SpellAbility sa, Map<String, Object> params) {
-        if (options.size() <= 1) {
-            return super.chooseCounterType(options, sa, params);
-        }
         Player ai = sa.getActivatingPlayer();
         GameEntity target = (GameEntity) params.get("Target");
 

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

@@ -2,6 +2,7 @@ package forge.ai.ability;
 
 import com.google.common.collect.Iterables;
 
+import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCombat;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
@@ -54,13 +55,14 @@ public abstract class DamageAiBase extends SpellAbilityAi {
         final Game game = comp.getGame();
         Player enemy = comp.getWeakestOpponent();
         boolean dmgByCardsInHand = false;
+        Card hostcard = sa.getHostCard();
 
-        if ("X".equals(sa.getParam("NumDmg")) && sa.getHostCard() != null && sa.hasSVar(sa.getParam("NumDmg")) &&
+        if ("X".equals(sa.getParam("NumDmg")) && hostcard != null && sa.hasSVar(sa.getParam("NumDmg")) &&
                 sa.getSVar(sa.getParam("NumDmg")).equals("TargetedPlayer$CardsInHand")) {
             dmgByCardsInHand = true;
         }
         // Not sure if type choice implemented for the AI yet but it should at least recognize this spell hits harder on larger enemy hand size
-        if ("Blood Oath".equals(sa.getHostCard().getName())) {
+        if ("Blood Oath".equals(hostcard.getName())) {
             dmgByCardsInHand = true;
         }
 
@@ -71,9 +73,13 @@ public abstract class DamageAiBase extends SpellAbilityAi {
             return false;
         }
 
+        // If the opponent will gain life (ex. Fiery Justice), not beneficial unless life gain is harmful or ignored
+        if ("OpponentGainLife".equals(sa.getParam("AILogic")) && ComputerUtil.lifegainPositive(enemy, hostcard)) {
+            return false;
+        }
+
         // Benefits hitting players?
         // If has triggered ability on dealing damage to an opponent, go for it!
-        Card hostcard = sa.getHostCard();
         for (Trigger trig : hostcard.getTriggers()) {
             if (trig.getMode() == TriggerType.DamageDone) {
                 if ("Opponent".equals(trig.getParam("ValidTarget"))
@@ -94,17 +100,16 @@ public abstract class DamageAiBase extends SpellAbilityAi {
             return false;
         }
 
-        if (!noPrevention) {
-            restDamage = ComputerUtilCombat.predictDamageTo(enemy, restDamage, sa.getHostCard(), false);
-        } else {
-            restDamage = enemy.staticReplaceDamage(restDamage, sa.getHostCard(), false);
-        }
-
-        if (restDamage == 0) {
+        if (!enemy.canLoseLife()) {
             return false;
         }
 
-        if (!enemy.canLoseLife()) {
+        if (!noPrevention) {
+            restDamage = ComputerUtilCombat.predictDamageTo(enemy, restDamage, hostcard, false);
+        } else {
+            restDamage = enemy.staticReplaceDamage(restDamage, hostcard, false);
+        }
+        if (restDamage == 0) {
             return false;
         }
 

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

@@ -25,6 +25,7 @@ import forge.ai.SpecialCardAi;
 import forge.ai.SpellAbilityAi;
 import forge.card.mana.ManaCost;
 import forge.game.Game;
+import forge.game.GameEntity;
 import forge.game.GameObject;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
@@ -53,6 +54,7 @@ import forge.util.MyRandom;
 public class DamageDealAi extends DamageAiBase {
     @Override
     public boolean chkAIDrawback(SpellAbility sa, Player ai) {
+        final SpellAbility root = sa.getRootAbility();
         final String damage = sa.getParam("NumDmg");
         Card source = sa.getHostCard();
         int dmg = AbilityUtils.calculateAmount(source, damage, sa);
@@ -76,7 +78,7 @@ public class DamageDealAi extends DamageAiBase {
                     if (dmg > energy || dmg < 1) {
                         continue; // in case the calculation gets messed up somewhere
                     }
-                    source.setSVar("EnergyToPay", "Number$" + dmg);
+                    root.setSVar("EnergyToPay", "Number$" + dmg);
                     return true;
                 }
             }
@@ -208,7 +210,7 @@ public class DamageDealAi extends DamageAiBase {
             if (ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN)) {
                 boolean doTarget = damageTargetAI(ai, sa, dmg, true);
                 if (doTarget) {
-                    Card tgt = sa.getTargets().getFirstTargetedCard();
+                    Card tgt = sa.getTargetCard();
                     if (tgt != null) {
                         return ai.getGame().getPhaseHandler().getPlayerTurn() == tgt.getController();
                     }
@@ -671,7 +673,7 @@ public class DamageDealAi extends DamageAiBase {
                 c = dealDamageChooseTgtC(ai, sa, dmg, noPrevention, enemy, false);
                 if (c != null) {
                     //option to hold removal instead only applies for single targeted removal
-                    if (sa.isSpell() && !divided && !immediately && tgt.getMaxTargets(sa.getHostCard(), sa) == 1) {
+                    if (sa.isSpell() && !divided && !immediately && tgt.getMaxTargets(source, sa) == 1) {
                         if (!ComputerUtilCard.useRemovalNow(sa, c, dmg, ZoneType.Graveyard)) {
                             return false;
                         }
@@ -722,7 +724,7 @@ public class DamageDealAi extends DamageAiBase {
                 final Card c = dealDamageChooseTgtC(ai, sa, dmg, noPrevention, enemy, mandatory);
                 if (c != null) {
                     //option to hold removal instead only applies for single targeted removal
-                    if (!immediately && tgt.getMaxTargets(sa.getHostCard(), sa) == 1 && !divided) {
+                    if (!immediately && tgt.getMaxTargets(source, sa) == 1 && !divided) {
                         if (!ComputerUtilCard.useRemovalNow(sa, c, dmg, ZoneType.Graveyard)) {
                             return false;
                         }
@@ -780,6 +782,13 @@ public class DamageDealAi extends DamageAiBase {
             sa.resetTargets();
             return false;
         }
+
+        // if opponent will gain life (ex. Fiery Justice), don't target only enemy player unless life gain is harmful or ignored
+        if ("OpponentGainLife".equals(logic) && tcs.size() == 1 && tcs.contains(enemy) && ComputerUtil.lifegainPositive(enemy, source)) {
+            sa.resetTargets();
+            return false;
+        }
+
         return true;
     }
 
@@ -797,11 +806,11 @@ public class DamageDealAi extends DamageAiBase {
      */
     private boolean damageChooseNontargeted(Player ai, final SpellAbility saMe, final int dmg) {
         // TODO: Improve circumstances where the Defined Damage is unwanted
-        final List<GameObject> objects = AbilityUtils.getDefinedObjects(saMe.getHostCard(), saMe.getParam("Defined"), saMe);
+        final List<GameEntity> objects = AbilityUtils.getDefinedEntities(saMe.getHostCard(), saMe.getParam("Defined"), saMe);
         boolean urgent = false; // can it wait?
         boolean positive = false;
 
-        for (final Object o : objects) {
+        for (final GameEntity o : objects) {
             if (o instanceof Card) {
                 Card c = (Card) o;
                 final int restDamage = ComputerUtilCombat.predictDamageTo(c, dmg, saMe.getHostCard(), false);
@@ -1075,6 +1084,11 @@ public class DamageDealAi extends DamageAiBase {
             return null;
         }
 
+        // chaining to this could miscalculate
+        if (sa.isDividedAsYouChoose()) {
+            return null;
+        }
+
         // Try to chain damage/debuff effects
         if (StringUtils.isNumeric(damage) || (damage.startsWith("-") && StringUtils.isNumeric(damage.substring(1)))) {
             // currently only works for predictable numeric damage

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

@@ -1,5 +1,7 @@
 package forge.ai.ability;
 
+import java.util.Map;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -30,7 +32,7 @@ public class DayTimeAi 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/DebuffAi.java

@@ -68,7 +68,6 @@ public class DebuffAi extends SpellAbilityAi {
         if (!sa.usesTargeting()) {
             List<Card> cards = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
 
-
             final Combat combat = game.getCombat();
             return Iterables.any(cards, new Predicate<Card>() {
                 @Override
@@ -121,7 +120,6 @@ public class DebuffAi extends SpellAbilityAi {
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         sa.resetTargets();
         CardCollection list = getCurseCreatures(ai, sa, kws == null ? Lists.newArrayList() : kws);
-        list = CardLists.getValidCards(list, tgt.getValidTgts(), sa.getActivatingPlayer(), sa.getHostCard(), sa);
 
         // several uses here:
         // 1. make human creatures lose evasion when they are attacking
@@ -205,9 +203,7 @@ public class DebuffAi extends SpellAbilityAi {
         }
 
         // Remove anything that's already been targeted
-        for (final Card c : sa.getTargets().getTargetCards()) {
-            list.remove(c);
-        }
+        list.removeAll(sa.getTargets().getTargetCards());
 
         final CardCollection pref = CardLists.filterControlledBy(list, ai.getOpponents());
         final CardCollection forced = CardLists.filterControlledBy(list, ai);

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

@@ -26,7 +26,7 @@ public class DelayedTriggerAi extends SpellAbilityAi {
         if (trigsa == null) {
             return false;
         }
-        trigsa.setActivatingPlayer(ai);
+        trigsa.setActivatingPlayer(ai, true);
 
         if (trigsa instanceof AbilitySub) {
             return SpellApiToAi.Converter.get(trigsa.getApi()).chkDrawbackWithSubs(ai, (AbilitySub)trigsa);
@@ -43,7 +43,7 @@ public class DelayedTriggerAi extends SpellAbilityAi {
         }
 
         AiController aic = ((PlayerControllerAi)ai.getController()).getAi();
-        trigsa.setActivatingPlayer(ai);
+        trigsa.setActivatingPlayer(ai, true);
 
         if (!sa.hasParam("OptionalDecider")) {
             return aic.doTrigger(trigsa, true);
@@ -164,7 +164,7 @@ public class DelayedTriggerAi extends SpellAbilityAi {
         if (trigsa == null) {
             return false;
         }
-        trigsa.setActivatingPlayer(ai);
+        trigsa.setActivatingPlayer(ai, true);
         return AiPlayDecision.WillPlay == ((PlayerControllerAi)ai.getController()).getAi().canPlaySa(trigsa);
     }
 

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

@@ -353,9 +353,7 @@ public class DestroyAi extends SpellAbilityAi {
             // Filter AI-specific targets if provided
             preferred = ComputerUtil.filterAITgts(sa, ai, preferred, true);
 
-            for (final Card c : preferred) {
-                list.remove(c);
-            }
+            list.removeAll(preferred);
 
             if (preferred.isEmpty() && !mandatory) {
                 return false;

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

@@ -209,7 +209,7 @@ public class DigAi extends SpellAbilityAi {
      * @see forge.card.ability.SpellAbilityAi#confirmAction(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) {
         Card topc = player.getZone(ZoneType.Library).get(0);
 
         // AI actions for individual cards (until this AI can be generalized)

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

@@ -1,5 +1,7 @@
 package forge.ai.ability;
 
+import java.util.Map;
+
 import forge.ai.AiAttackController;
 import forge.ai.ComputerUtil;
 import forge.ai.SpellAbilityAi;
@@ -94,7 +96,7 @@ public class DigMultipleAi extends SpellAbilityAi {
      * @see forge.card.ability.SpellAbilityAi#confirmAction(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) {
         return true;
     }
 }

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

@@ -1,6 +1,7 @@
 package forge.ai.ability;
 
 import java.util.List;
+import java.util.Map;
 
 import forge.ai.AiAttackController;
 import forge.ai.ComputerUtilCost;
@@ -122,7 +123,7 @@ public class DigUntilAi extends SpellAbilityAi {
      * @see forge.card.ability.SpellAbilityAi#confirmAction(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")) {
             final String logic = sa.getParam("AILogic");
             if ("OathOfDruids".equals(logic)) {

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

@@ -2,6 +2,7 @@ package forge.ai.ability;
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilAbility;
@@ -211,11 +212,11 @@ public class DiscardAi extends SpellAbilityAi {
         return true;
     }
 
-    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 (mode == PlayerActionConfirmMode.Random) {
             // TODO For now AI will always discard Random used currently with: Balduvian Horde and similar cards
             return true;
         }
-        return super.confirmAction(player, sa, mode, message);
+        return super.confirmAction(player, sa, mode, message, params);
     }
 }

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

@@ -18,6 +18,8 @@
  */
 package forge.ai.ability;
 
+import java.util.Map;
+
 import forge.ai.AiCostDecision;
 import forge.ai.AiProps;
 import forge.ai.ComputerUtil;
@@ -508,7 +510,7 @@ public class DrawAi extends SpellAbilityAi {
             }
 
             if (numCards >= computerLibrarySize - 3) {
-                if (ai.isCardInPlay("Laboratory Maniac")) {
+                if (ai.isCardInPlay("Laboratory Maniac") && !ai.cantWin()) {
                     return true;
                 }
                 // Don't deck yourself
@@ -541,7 +543,7 @@ public class DrawAi 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) {
         int numCards = sa.hasParam("NumCards") ? AbilityUtils.calculateAmount(sa.getHostCard(), sa.getParam("NumCards"), sa) : 1;
         // AI shouldn't mill itself
         if (numCards < player.getZone(ZoneType.Library).size())

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

@@ -22,6 +22,7 @@ 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.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.phase.PhaseHandler;
@@ -69,10 +70,10 @@ public class EffectAi extends SpellAbilityAi {
                     randomReturn = true;
                 }
             } else if (logic.equals("Fog")) {
-                if (game.getPhaseHandler().isPlayerTurn(sa.getActivatingPlayer())) {
+                if (phase.isPlayerTurn(sa.getActivatingPlayer())) {
                     return false;
                 }
-                if (!game.getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
+                if (!phase.is(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
                     return false;
                 }
                 if (!game.getStack().isEmpty()) {
@@ -114,8 +115,7 @@ public class EffectAi extends SpellAbilityAi {
                 }
                 randomReturn = true;
             } else if (logic.equals("ChainVeil")) {
-                if (!phase.isPlayerTurn(ai) || !phase.getPhase().equals(PhaseType.MAIN2)
-                        || CardLists.getType(ai.getCardsIn(ZoneType.Battlefield), "Planeswalker").isEmpty()) {
+                if (!phase.isPlayerTurn(ai) || !phase.getPhase().equals(PhaseType.MAIN2) || ai.getPlaneswalkersInPlay().isEmpty()) {
                     return false;
                 }
                 randomReturn = true;
@@ -215,6 +215,17 @@ public class EffectAi extends SpellAbilityAi {
                 return topStack.getActivatingPlayer().isOpponentOf(ai) && topStack.getApi() == ApiType.GainLife;
             } else if (logic.equals("Fight")) {
                 return FightAi.canFightAi(ai, sa, 0, 0);
+            } else if (logic.equals("Pump")) {
+                List<Card> options = CardUtil.getValidCardsToTarget(sa.getTargetRestrictions(), sa);
+                options = CardLists.filterControlledBy(options, ai);
+                if (sa.getPayCosts().hasTapCost()) {
+                    options.remove(sa.getHostCard());
+                }
+                if (!options.isEmpty() && phase.isPlayerTurn(ai) && phase.getPhase().isBefore(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
+                    sa.getTargets().add(ComputerUtilCard.getBestCreatureAI(options));
+                    return true;
+                }
+                return false;
             } else if (logic.equals("Burn")) {
                 // for DamageDeal sub-abilities (eg. Wild Slash, Skullcrack)
                 SpellAbility burn = sa.getSubAbility();
@@ -232,8 +243,7 @@ public class EffectAi extends SpellAbilityAi {
                 }
                 return true;
             } else if (logic.equals("ReplaySpell")) {
-                CardCollection list = new CardCollection(game.getCardsIn(ZoneType.Graveyard));
-                list = CardLists.getValidCards(list, sa.getTargetRestrictions().getValidTgts(), ai, sa.getHostCard(), sa);
+                CardCollection list = CardLists.getValidCards(game.getCardsIn(ZoneType.Graveyard), sa.getTargetRestrictions().getValidTgts(), ai, sa.getHostCard(), sa);
                 if (!ComputerUtil.targetPlayableSpellCard(ai, list, sa, false, false)) {
                     return false;
                 }
@@ -241,7 +251,7 @@ public class EffectAi extends SpellAbilityAi {
                 Card host = sa.getHostCard();
                 Combat combat = game.getCombat();
                 if (combat != null && combat.isAttacking(host, ai) && !combat.isBlocked(host)
-                        && game.getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS)
+                        && phase.is(PhaseType.COMBAT_DECLARE_BLOCKERS)
                         && !AiCardMemory.isRememberedCard(ai, host, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN)) {
                     AiCardMemory.rememberCard(ai, host, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN); // ideally needs once per combat or something
                     return true;
@@ -285,12 +295,10 @@ public class EffectAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
-        String aiLogic = sa.getParamOrDefault("AILogic", "");
-
         // E.g. Nova Pentacle
-        if (aiLogic.equals("RedirectFromOppToCreature")) {
+        if (sa.usesTargeting() && !sa.getTargetRestrictions().canTgtPlayer()) {
             // try to target the opponent's best targetable permanent, if able
-            CardCollection oppPerms = CardLists.getValidCards(aiPlayer.getOpponents().getCardsIn(ZoneType.Battlefield), sa.getTargetRestrictions().getValidTgts(), aiPlayer, sa.getHostCard(), sa);
+            CardCollection oppPerms = CardLists.getValidCards(aiPlayer.getOpponents().getCardsIn(sa.getTargetRestrictions().getZone()), sa.getTargetRestrictions().getValidTgts(), aiPlayer, sa.getHostCard(), sa);
             if (!oppPerms.isEmpty()) {
                 sa.resetTargets();
                 sa.getTargets().add(ComputerUtilCard.getBestAI(oppPerms));
@@ -299,7 +307,7 @@ public class EffectAi extends SpellAbilityAi {
 
             if (mandatory) {
                 // try to target the AI's worst targetable permanent, if able
-                CardCollection aiPerms = CardLists.getValidCards(aiPlayer.getCardsIn(ZoneType.Battlefield), sa.getTargetRestrictions().getValidTgts(), aiPlayer, sa.getHostCard(), sa);
+                CardCollection aiPerms = CardLists.getValidCards(aiPlayer.getCardsIn(sa.getTargetRestrictions().getZone()), sa.getTargetRestrictions().getValidTgts(), aiPlayer, sa.getHostCard(), sa);
                 if (!aiPerms.isEmpty()) {
                     sa.resetTargets();
                     sa.getTargets().add(ComputerUtilCard.getWorstAI(aiPerms));

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

@@ -70,7 +70,7 @@ public final class EncodeAi extends SpellAbilityAi {
      * 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) {
         // only try to encode if there is a creature it can be used on
         return chooseCard(player, player.getCreaturesInPlay(), true) != null;
     }
@@ -102,7 +102,7 @@ public final class EncodeAi extends SpellAbilityAi {
             public boolean apply(final Card c) {
                 boolean canAttackOpponent = false;
                 for (Player opp : ai.getOpponents()) {
-                    if (CombatUtil.canAttack(c, opp) && !CombatUtil.canBeBlocked(c, opp)) {
+                    if (CombatUtil.canAttack(c, opp) && !CombatUtil.canBeBlocked(c, null, opp)) {
                         canAttackOpponent = true;
                         break;
                     }

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

@@ -1,5 +1,7 @@
 package forge.ai.ability;
 
+import java.util.Map;
+
 import com.google.common.base.Predicate;
 import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
@@ -42,7 +44,7 @@ public class FlipOntoBattlefieldAi 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/ImmediateTriggerAi.java

@@ -20,7 +20,7 @@ public class ImmediateTriggerAi extends SpellAbilityAi {
             return false;
         }
 
-        trigsa.setActivatingPlayer(ai);
+        trigsa.setActivatingPlayer(ai, true);
 
         if (trigsa instanceof AbilitySub) {
             return SpellApiToAi.Converter.get(trigsa.getApi()).chkDrawbackWithSubs(ai, (AbilitySub)trigsa);
@@ -31,6 +31,11 @@ public class ImmediateTriggerAi extends SpellAbilityAi {
 
     @Override
     protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
+        // always add to stack, targeting happens after payment
+        if (mandatory) {
+            return true;
+        }
+
         String logic = sa.getParamOrDefault("AILogic", "");
 
         SpellAbility trigsa = sa.getAdditionalAbility("Execute");
@@ -43,13 +48,9 @@ public class ImmediateTriggerAi extends SpellAbilityAi {
         }
 
         AiController aic = ((PlayerControllerAi)ai.getController()).getAi();
-        trigsa.setActivatingPlayer(ai);
+        trigsa.setActivatingPlayer(ai, true);
 
-        if (!sa.hasParam("OptionalDecider")) {
-            return aic.doTrigger(trigsa, true);
-        } else {
-            return aic.doTrigger(trigsa, !sa.getParam("OptionalDecider").equals("You"));
-        }
+        return aic.doTrigger(trigsa, !"You".equals(sa.getParamOrDefault("OptionalDecider", "You")));
     }
 
     @Override
@@ -64,7 +65,7 @@ public class ImmediateTriggerAi extends SpellAbilityAi {
             return false;
         }
 
-        trigsa.setActivatingPlayer(ai);
+        trigsa.setActivatingPlayer(ai, true);
         return AiPlayDecision.WillPlay == ((PlayerControllerAi)ai.getController()).getAi().canPlaySa(trigsa);
     }
 

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

@@ -1,6 +1,8 @@
 package forge.ai.ability;
 
 
+import java.util.Map;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -20,7 +22,7 @@ public class InvestigateAi 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/LearnAi.java

@@ -1,6 +1,8 @@
 package forge.ai.ability;
 
 
+import java.util.Map;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.PlayerControllerAi;
 import forge.ai.SpellAbilityAi;
@@ -32,7 +34,7 @@ public class LearnAi 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;
     }