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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -4,7 +4,6 @@ about: Create a report to help us improve
 title: ''
 labels: ''
 assignees: ''
-type: 'Bug'
 
 ---
 
@@ -32,6 +31,7 @@ If applicable, add screenshots to help explain your problem.
 **Smartphone (please complete the following information):**
  - Device: [e.g. iPhone6]
  - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
  - Version [e.g. 22]
 
 **Additional context**

.github/ISSUE_TEMPLATE/feature_request.md

@@ -4,7 +4,6 @@ about: Suggest an idea for this project
 title: ''
 labels: ''
 assignees: ''
-type: 'Feature'
 
 ---
 

.github/workflows/maven-publish.yml

@@ -2,21 +2,10 @@ name: Publish Desktop Forge
 
 on:
   workflow_dispatch:
-    inputs:
-      debug_enabled:
-        type: boolean
-        description: 'Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)'
-        required: false
-        default: false
-      release_android:
-        type: boolean
-        description: 'Also try to release android build'
-        required: false
-        default: false
 
 jobs:
   build:
-    if: github.repository_owner == 'Card-Forge'
+
     runs-on: ubuntu-latest
     permissions:
       contents: write
@@ -43,134 +32,10 @@ jobs:
         run: |
           git config user.email "actions@github.com"
           git config user.name "GitHub Actions"
-
-      - name: Install old maven (3.8.1)
-        run: |
-          curl -o apache-maven-3.8.1-bin.tar.gz https://archive.apache.org/dist/maven/maven-3/3.8.1/binaries/apache-maven-3.8.1-bin.tar.gz
-          tar xf apache-maven-3.8.1-bin.tar.gz
-          export PATH=$PWD/apache-maven-3.8.1/bin:$PATH
-          export MAVEN_HOME=$PWD/apache-maven-3.8.1
-          mvn --version    
-
-      - name: Setup tmate session
-        uses: mxschmitt/action-tmate@v3
-        if: ${{ github.event_name == 'workflow_dispatch' && inputs.debug_enabled }}
-
-      - name: Setup android requirements
-        if: ${{ github.event_name == 'workflow_dispatch' && inputs.release_android }}
-        run: |
-          JAVA_HOME=${JAVA_HOME_17_X64} ${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager --sdk_root=$ANDROID_SDK_ROOT --install "build-tools;35.0.0" "platform-tools" "platforms;android-35"
-          cd forge-gui-android
-          echo "${{ secrets.FORGE_KEYSTORE }}" > forge.keystore.asc
-          gpg -d --passphrase "${{ secrets.FORGE_KEYSTORE_PASSPHRASE }}" --batch forge.keystore.asc > forge.keystore
-          cd -
-          mkdir  -p ~/.m2/repository/com/simpligility/maven/plugins/android-maven-plugin/4.6.2
-          cd ~/.m2/repository/com/simpligility/maven/plugins/android-maven-plugin/4.6.2
-          curl -L -o android-maven-plugin-4.6.2.jar https://github.com/Card-Forge/android-maven-plugin/releases/download/4.6.2/android-maven-plugin-4.6.2.jar
-          curl -L -o android-maven-plugin-4.6.2.pom https://github.com/Card-Forge/android-maven-plugin/releases/download/4.6.2/android-maven-plugin-4.6.2.pom
-          cd -
-          mvn install -Dmaven.test.skip=true
-          mvn dependency:tree
-          
-
-      - name: Build/Install/Publish Desktop to GitHub Packages Apache Maven
-        if: ${{ github.event_name == 'workflow_dispatch' && !inputs.release_android }}
+      - name: Build/Install/Publish to GitHub Packages Apache Maven
         run: |
           export DISPLAY=":1"
           Xvfb :1 -screen 0 800x600x8 &
-          export _JAVA_OPTIONS="-Xmx2g"
-          d=$(date +%m.%d)
-          # build only desktop and only try to move desktop files
-          mvn -U -B clean -P windows-linux install -DskipTests -Dskip.flatten=true -e -T 1C release:clean release:prepare release:perform
-          mkdir izpack
-          # move bz2 and jar from work dir to izpack dir
-          mv /home/runner/work/forge/forge/forge-installer/*/*.{bz2,jar} izpack/
-          # move desktop build.txt and version.txt to izpack
-          mv /home/runner/work/forge/forge/forge-gui-desktop/target/classes/*.txt izpack/
-          cd izpack
-          ls
-          echo "GIT_TAG=`echo $(git describe --tags --abbrev=0)`" >> $GITHUB_ENV
+          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 }}
-
-      - name: Build/Install/Publish Desktop+Android to GitHub Packages Apache Maven
-        if: ${{ github.event_name == 'workflow_dispatch' && inputs.release_android }}
-        run: |
-          export DISPLAY=":1"
-          Xvfb :1 -screen 0 800x600x8 &
-          export _JAVA_OPTIONS="-Xmx2g"
-          d=$(date +%m.%d)
-          # build both desktop and android
-          mvn -U -B clean -P windows-linux,android-release-build install -e -Dcardforge-repo.username=${{ secrets.FTP_USERNAME }} -Dcardforge-repo.password=${{ secrets.FTP_PASSWORD }} -Dandroid.sdk.path=/usr/local/lib/android/sdk -Dandroid.buildToolsVersion=35.0.0
-          mkdir izpack
-          # move bz2 and jar from work dir to izpack dir
-          mv /home/runner/work/forge/forge/forge-installer/*/*.{bz2,jar} izpack/
-          # move desktop build.txt and version.txt to izpack
-          mv /home/runner/work/forge/forge/forge-gui-desktop/target/classes/*.txt izpack/
-          # move android apk and assets.zip
-          mv /home/runner/work/forge/forge/forge-gui-android/target/*-signed-aligned.apk izpack/
-          mv /home/runner/work/forge/forge/forge-gui-android/target/assets.zip izpack/
-          cd izpack
-          ls
-          echo "GIT_TAG=`echo $(git describe --tags --abbrev=0)`" >> $GITHUB_ENV
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-
-      - name: Upload snapshot to GitHub Prerelease
-        uses: ncipollo/release-action@v1
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          name: Release ${{ env.GIT_TAG }}
-          tag: ${{ env.GIT_TAG }}
-          artifacts: izpack/*
-          allowUpdates: true
-          removeArtifacts: true
-          makeLatest: true
-
-      - name: 🔧 Install XML tools
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libxml2-utils
-
-      - name: 🔼 Bump versionCode in root POM
-        id: bump_version
-        run: |
-          cd /home/runner/work/forge/forge/
-          
-          current_version=$(xmllint --xpath "//*[local-name()='versionCode']/text()" pom.xml)
-          echo "Current versionCode: $current_version"
-
-          IFS='.' read -r major minor patch <<< "${current_version}"
-          new_patch=$(printf "%02d" $((10#$patch + 1)))
-          new_version="${major}.${minor}.${new_patch}"
-
-          sed -i -E "s|<versionCode>.*</versionCode>|<versionCode>${new_version}</versionCode>|" pom.xml
-
-          echo "version_code=${new_version}" >> $GITHUB_OUTPUT
-          
-      - name: ♻️ Restore {revision} in child POMs
-        run: |
-          find . -name pom.xml ! -path "./pom.xml" | while read -r pom; do
-            sed -i -E 's|<version>2\.0+\.[0-9]+(-SNAPSHOT)?</version>|<version>${revision}</version>|' "$pom"
-          done
-
-      - name: 💾 Commit restored {revision}
-        run: |
-          # Add only pom.xml files
-          find . -name pom.xml -exec git add {} \;
-
-          # Commit if there are changes
-          if git diff --cached --quiet; then
-            echo "No pom.xml changes to commit."
-          else
-            git commit -m "Restore POM files for preparation of next release" || echo "No changes to commit"
-            git push
-          fi
-
-      - name: Send failure notification to Discord
-        if: failure() # This step runs only if the job fails
-        run: |
-          curl -X POST -H "Content-Type: application/json" \
-          -d "{\"content\": \"🔴 Release Build Failed in branch: \`${{ github.ref_name }}\` by \`${{ github.actor }}\`.\nCheck logs: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\"}" \
-          ${{ secrets.DISCORD_AUTOMATION_WEBHOOK }}

.github/workflows/remove-stale-branches.yml

@@ -1,19 +1,12 @@
-name: Remove stale branches
-
 on:
-  workflow_dispatch:
   schedule:
     - cron: "0 0 * * *" # Everday at midnight
 
 jobs:
   remove-stale-branches:
-    if: github.repository_owner == 'Card-Forge'
     name: Remove Stale Branches
     runs-on: ubuntu-latest
     steps:
-      - uses: fpicalausa/remove-stale-branches@v2.1.0
+      - uses: fpicalausa/remove-stale-branches@v1.6.0
         with:
-          dry-run: false # Check out the console output before setting this to false
-          ignore-unknown-authors: true
-          ignore-branches-with-open-prs: true
-          default-recipient: tehdiplomat
+          dry-run: true # Check out the console output before setting this to false

.github/workflows/snapshot-both-pc-android.yml

@@ -8,9 +8,6 @@ on:
         description: 'Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)'
         required: false
         default: false
-  schedule:
-    # * is a special character in YAML so you have to quote this string
-    - cron:  '00 18 * * *'
 
 jobs:
   build:
@@ -112,21 +109,16 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ github.token }}
 
-      - name: Upload snapshot to GitHub Prerelease
-        uses: ncipollo/release-action@v1
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: 📂 Sync files
+        uses: SamKirkland/FTP-Deploy-Action@v4.3.4
         with:
-          name: Daily Snapshot
-          tag: daily-snapshots
-          prerelease: true
-          artifacts: izpack/*
-          allowUpdates: true
-          removeArtifacts: true
-
-      - name: Send failure notification to Discord
-        if: failure() # This step runs only if the job fails
-        run: |
-          curl -X POST -H "Content-Type: application/json" \
-          -d "{\"content\": \"🔴 Snapshot Build Failed in branch: \`${{ github.ref_name }}\` by \`${{ github.actor }}\`.\nCheck logs: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}\"}" \
-          ${{ secrets.DISCORD_AUTOMATION_WEBHOOK }}
+          server: ftp.cardforge.org
+          username: ${{ secrets.FTP_USERNAME }}
+          password: ${{ secrets.FTP_PASSWORD }}
+          local-dir: izpack/
+          server-dir: downloads/dailysnapshots/
+          state-name: .ftp-deploy-both-sync-state.json
+          exclude: |
+            *.pom
+            *.repositories
+            *.xml

.github/workflows/snapshots-android.yml

@@ -13,6 +13,10 @@ on:
         #  description: 'Upload the completed Android package'
         #  required: false
         #  default: true
+  schedule:
+    # * is a special character in YAML so you have to quote this string
+    - cron:  '00 19 * * *'
+          
 
 jobs:
   build:
@@ -105,10 +109,3 @@ jobs:
           local-dir: upload/
           server-dir: downloads/dailysnapshots/
           state-name: .ftp-deploy-android-sync-state.json
-
-      - name: Send failure notification to Discord
-        if: failure() # This step runs only if the job fails
-        run: |
-          curl -X POST -H "Content-Type: application/json" \
-          -d "{\"content\": \"🔴 Android Snapshot Build Failed in branch: \`${{ github.ref_name }}\` by \`${{ github.actor }}\`.\nCheck logs: ${{ github.run_url }}\"}" \
-          ${{ secrets.DISCORD_AUTOMATION_WEBHOOK }}

.github/workflows/snapshots-pc.yml

@@ -8,6 +8,9 @@ on:
         description: 'Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)'
         required: false
         default: false
+  schedule:
+    # * is a special character in YAML so you have to quote this string
+    - cron:  '30 18 * * *'
 
 jobs:
   build:
@@ -86,10 +89,3 @@ jobs:
             *.pom
             *.repositories
             *.xml
-
-      - name: Send failure notification to Discord
-        if: failure() # This step runs only if the job fails
-        run: |
-          curl -X POST -H "Content-Type: application/json" \
-          -d "{\"content\": \"🔴 Desktop Snapshot Build Failed in branch: \`${{ github.ref_name }}\` by \`${{ github.actor }}\`.\nCheck logs: ${{ github.run_url }}\"}" \
-          ${{ secrets.DISCORD_AUTOMATION_WEBHOOK }}

.github/workflows/test-build.yaml

@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        java: ['17', '21']
+        java: [ '17' ]
     name: Test with Java ${{ matrix.Java }}
     steps:
       - uses: actions/checkout@v3

.gitignore

@@ -12,7 +12,6 @@
 .settings
 .classpath
 .project
-.checkstyle
 
 # Ignore VS Code config files
 
@@ -25,8 +24,6 @@
 
 nbactions.xml
 
-# Ignore flattened pom
-.flattened-pom.xml
 
 # Ignore binaries, temp files and test output, everywhere
 
@@ -66,9 +63,6 @@ forge-gui-mobile-dev/testAssets
 
 forge-gui/res/cardsfolder/*.bat
 
-# Generated changelog file
-forge-gui/release-files/CHANGES.txt
-
 forge-gui/res/PerSetTrackingResults
 forge-gui/res/decks
 forge-gui/res/layouts
@@ -90,7 +84,3 @@ forge-gui/tools/PerSetTrackingResults
 *.tiled-session
 /forge-gui/res/adventure/*.tiled-project
 /forge-gui/res/adventure/*.tiled-session
-
-# Ignore python temporaries
-__pycache__
-*.pyc

.gitlab/issue_templates/Bug.md

@@ -0,0 +1,33 @@
+Summary
+
+(Summarize the bug encountered concisely)
+
+
+Steps to reproduce
+
+(How one can reproduce the issue - this is very important. Specific cards and specific actions especially)
+
+
+Which version of Forge are you on (Release, Snapshot? Desktop, Android?)
+
+
+What is the current bug behavior?
+
+(What actually happens)
+
+
+What is the expected correct behavior?
+
+(What you should see instead)
+
+
+Relevant logs and/or screenshots
+
+(Paste/Attach your game.log from the crash - please use code blocks (```)) Also, provide screenshots of the current state.
+
+
+Possible fixes
+
+(If you can, link to the line of code that might be responsible for the problem)
+
+/label ~needs-investigation

.gitlab/issue_templates/Feature.md

@@ -0,0 +1,15 @@
+Summary
+
+(Summarize the feature you wish concisely)
+
+
+Example screenshots
+
+(If this is a UI change, please provide an example screenshot of how this feature might work)
+
+
+Feature type
+
+(Where in Forge does this belong? e.g. Quest Mode, Deck Editor, Limited, Constructed, etc.)
+
+/label ~feature request

.mvn/local-settings.xml

@@ -1,6 +1,18 @@
+<!--
+    Derived from: https://stackoverflow.com/a/67002852
+-->
 <settings xmlns="http://maven.apache.org/SETTINGS/1.2.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.2.0 http://maven.apache.org/xsd/settings-1.2.0.xsd">
+    <mirrors>
+        <mirror>
+            <id>4thline-repo-http-unblocker</id>
+            <mirrorOf>4thline-repo</mirrorOf>
+            <name></name>
+            <url>http://4thline.org/m2</url>
+        </mirror>
+    </mirrors>
+
     <servers>
         <server>
             <id>cardforge-repo</id>
@@ -8,4 +20,4 @@
             <password>${cardforge-repo.password}</password>
         </server>
     </servers>
-</settings>
+</settings>

CONTRIBUTING.md

@@ -6,7 +6,7 @@ Dev instructions here: [Getting Started](https://github.com/Card-Forge/forge/wik
 
 ## Requirements / Tools
 
-- your favourite Java IDE (IntelliJ, Eclipse, VSCodium, Emacs, Vi...)
+- you favourite Java IDE (IntelliJ, Eclipse, VSCodium, Emacs, Vi...)
 - Java JDK 17 or later
 - Git
 - Git client (optional)
@@ -22,41 +22,42 @@ Dev instructions here: [Getting Started](https://github.com/Card-Forge/forge/wik
 
 - Clone your forked project to your local machine
 
-- Go to the project location on your machine. Run Maven to download all dependencies and build a snapshot. Example for Windows & Linux: `mvn -U -B clean -P windows-linux install`
+- Go to the project location on your machine.  Run Maven to download all dependencies and build a snapshot.  Example for Windows & Linux: `mvn -U -B clean -P windows-linux install`
 
 ## IntelliJ
 
 IntelliJ is the recommended IDE for Forge development. Quick start guide for [setting up the Forge project within IntelliJ](https://github.com/Card-Forge/forge/wiki/IntelliJ-setup).
 
+
 ## Eclipse
 
-Eclipse includes Maven integration so a separate install is not necessary. For other IDEs, your mileage may vary.
+Eclipse includes Maven integration so a separate install is not necessary.  For other IDEs, your mileage may vary.
 At this time, Eclipse is not the recommended IDE for Forge development.
 
 ### Project Setup
 
-- Follow the instructions for cloning from GitHub. You'll need to setup an account and your SSH key.
+- Follow the instructions for cloning from GitHub.  You'll need to setup an account and your SSH key.
 
-  If you are on a Windows machine you can use Putty with TortoiseGit for SSH keys. Run puttygen.exe to generate the key -- save the private key and export
-  the OpenSSH public key. If you just leave the dialog open, you can copy and paste the key from it to your GitHub profile under
-  "SSH keys". Run pageant.exe and add the private key generated earlier. TortoiseGit will use this for accessing GitHub.
+  If you are on a Windows machine you can use Putty with TortoiseGit for SSH keys.  Run puttygen.exe to generate the key -- save the private key and export
+  the OpenSSH public key.  If you just leave the dialog open, you can copy and paste the key from it to your GitHub profile under
+  "SSH keys".  Run pageant.exe and add the private key generated earlier.  TortoiseGit will use this for accessing GitHub.
 
 - Fork the Forge git repo to your GitHub account.
 
 - Clone your forked repo to your local machine.
 
-- Make sure the Java SDK is installed -- not just the JRE. Java 17 or newer required. If you execute `java -version` at the shell or command prompt, it should report version 17 or later.
+- Make sure the Java SDK is installed -- not just the JRE.  Java 17 or newer required.  If you execute `java -version` at the shell or command prompt, it should report version 17 or later.
 
-- Install Eclipse 2021-12 or later for Java. Launch it.
+- Install Eclipse 2021-12 or later for Java.  Launch it.
 
-- Create a workspace. Go to the workbench. Right-click inside of Package Explorer > Import... > Maven > Existing Maven Projects > Navigate to root path of the local forge repo and
+- Create a workspace.  Go to the workbench.  Right-click inside of Package Explorer > Import... > Maven > Existing Maven Projects > Navigate to root path of the local forge repo and
   ensure everything is checked > Finish.
 
-- Let Eclipse run through building the project. You may be prompted for resolving any missing Maven plugins -- accept the ones offered. You may see errors appear in the "Problems" tab. These should
-  be automatically resolved as plug-ins are installed and Eclipse continues the build process. If this is the first time for some plug-in installs, Eclipse may prompt you to restart. Do so. Be patient
+- Let Eclipse run through building the project.  You may be prompted for resolving any missing Maven plugins -- accept the ones offered.  You may see errors appear in the "Problems" tab.  These should
+  be automatically resolved as plug-ins are installed and Eclipse continues the build process.  If this is the first time for some plug-in installs, Eclipse may prompt you to restart.  Do so.  Be patient
   for this first time through.
 
-- Once everything builds, all errors should disappear. You can now advance to Project launch.
+- Once everything builds, all errors should disappear.  You can now advance to Project launch.
 
 ### Project Launch
 
@@ -66,15 +67,15 @@ This is the standard configuration used for releasing to Windows / Linux / MacOS
 
 - Right-click on forge-gui-desktop > Run As... > Java Application > "Main - forge.view" > Ok
 
-- The familiar Forge splash screen, etc. should appear. Enjoy!
+- The familiar Forge splash screen, etc. should appear.  Enjoy!
 
 #### Mobile (Desktop dev)
 
-This is the configuration used for doing mobile development using the Windows / Linux / MacOS front-end. Knowledge of libgdx is helpful here.
+This is the configuration used for doing mobile development using the Windows / Linux / MacOS front-end.  Knowledge of libgdx is helpful here.
 
 - Right-click on forge-gui-mobile-dev > Run As... > Java Application > "Main - forge.app" > Ok.
 
-- A view similar to a mobile phone should appear. Enjoy!
+- A view similar to a mobile phone should appear.  Enjoy!
 
 ### Eclipse / Android SDK Integration
 
@@ -98,7 +99,7 @@ TBD
 
 #### Android Platform
 
-In Intellij, if the SDK Manager is not already running, go to Tools > Android > Android SDK Manager. Install the following options / versions:
+In Intellij, if the SDK Manager is not already running, go to Tools > Android > Android SDK Manager.  Install the following options / versions:
 
 - Android SDK Build-tools 35.0.0
 - Android 15 (API 35) SDK Platform
@@ -123,11 +124,10 @@ TBD
 
 SNAPSHOT builds can be built via the Maven integration in Eclipse.
 
-1. Create a Maven build for the forge top-level project. Right-click on the forge project. Run as.. > Maven build...
-
+1) Create a Maven build for the forge top-level project.  Right-click on the forge project.  Run as.. > Maven build...
    - On the Main tab, set Goals: clean install, set Profiles: windows-linux
 
-2. Run forge Maven build. If everything built, you should see "BUILD SUCCESS" in the Console View.
+2) Run forge Maven build.  If everything built, you should see "BUILD SUCCESS" in the Console View.
 
 The resulting snapshot will be found at: forge-gui-desktop/target/forge-gui-desktop-[version]-SNAPSHOT
 
@@ -141,7 +141,7 @@ Card scripting resources are found in the forge-gui/res/ path.
 
 ### Project Hierarchy
 
-Forge is divided into 4 primary projects with additional projects that target specific platform releases. The primary projects are:
+Forge is divided into 4 primary projects with additional projects that target specific platform releases.  The primary projects are:
 
 - forge-ai
 - forge-core
@@ -158,38 +158,32 @@ The platform-specific projects are:
 
 #### forge-ai
 
-The forge-ai project contains the computer opponent logic for gameplay. It includes decision-making algorithms for specific abilities, cards and turn phases.
-
 #### forge-core
 
-The forge-core project contains the core game engine, card mechanics, rules engine, and fundamental game logic. It includes the implementation of Magic: The Gathering rules, card interactions, and the game state management system.
-
 #### forge-game
 
-The forge-game project handles the game session management, player interactions, and game flow control. It includes implementations for multiplayer support, game modes, matchmaking, and game state persistence. This module bridges the core game engine with the user interface and networking components.
-
 #### forge-gui
 
-The forge-gui project contains the user interface components and rendering logic for the game. It includes the main game window, card displays, player interactions, and the scripting resource definitions in the res/ path.
+The forge-gui project includes the scripting resource definitions in the res/ path.
 
 #### forge-gui-android
 
-Libgdx-based backend targeting Android. Requires Android SDK and relies on forge-gui-mobile for GUI logic.
+Libgdx-based backend targeting Android.  Requires Android SDK and relies on forge-gui-mobile for GUI logic.
 
 #### forge-gui-desktop
 
 Java Swing based GUI targeting desktop machines.
 
-Screen layout and game logic revolving around the GUI is found here. For example, the overlay arrows (when enabled) that indicate attackers and blockers, or the targets of the stack are defined and drawn by this.
+Screen layout and game logic revolving around the GUI is found here.  For example, the overlay arrows (when enabled) that indicate attackers and blockers, or the targets of the stack are defined and drawn by this.
 
 #### forge-gui-ios
 
-Libgdx-based backend targeting iOS. Relies on forge-gui-mobile for GUI logic.
+Libgdx-based backend targeting iOS.  Relies on forge-gui-mobile for GUI logic.
 
 #### forge-gui-mobile
 
-Mobile GUI game logic utilizing [libgdx](https://libgdx.badlogicgames.com/) library. Screen layout and game logic revolving around the GUI for the mobile platforms is found here.
+Mobile GUI game logic utilizing [libgdx](https://libgdx.badlogicgames.com/) library.  Screen layout and game logic revolving around the GUI for the mobile platforms is found here.
 
 #### forge-gui-mobile-dev
 
-Libgdx backend for desktop development for mobile backends. Utilizes LWJGL. Relies on forge-gui-mobile for GUI logic.
+Libgdx backend for desktop development for mobile backends.  Utilizes LWJGL.  Relies on forge-gui-mobile for GUI logic.

README.md

@@ -1,4 +1,4 @@
-# ⚔️  Forge: The Magic: The Gathering Rules Engine
+# ⚔️ Forge: The Magic: The Gathering Rules Engine
 
 Join the **Forge community** on [Discord](https://discord.gg/HcPJNyD66a)!
 
@@ -26,14 +26,13 @@ Join the **Forge community** on [Discord](https://discord.gg/HcPJNyD66a)!
 
 ### 📥 Desktop Installation
 1. **Latest Releases:** Download the latest version [here](https://github.com/Card-Forge/forge/releases/latest).
-2. **Snapshot Build:** For the latest development version, grab the `forge-gui-desktop` tarball from our [Snapshot Build](https://github.com/Card-Forge/forge/releases/tag/daily-snapshots).
+2. **Snapshot Build:** For the latest development version, grab the `forge-gui-desktop` tarball from our [Snapshot Build](https://downloads.cardforge.org/dailysnapshots/).
    - **Tip:** Extract to a new folder to prevent version conflicts.
 3. **User Data Management:** Previous players’ data is preserved during upgrades.
 4. **Java Requirement:** Ensure you have **Java 17 or later** installed.
 
 ### 📱 Android Installation
-- _(Note: **Android 11** is the minimum requirements with at least **6GB RAM** to run smoothly. You need to enable **"Install unknown apps"** for Forge to initialize and update itself)_
-- Download the **APK** from the [Snapshot Build](https://github.com/Card-Forge/forge/releases/tag/daily-snapshots). On the first launch, Forge will automatically download all necessary assets.
+- Download the **APK** from the [Snapshot Build](https://downloads.cardforge.org/dailysnapshots/). On the first launch, Forge will automatically download all necessary assets.
 
 ---
 
@@ -47,13 +46,11 @@ Embark on a thrilling single-player journey where you can:
 - Challenge diverse AI opponents.
 - Collect cards and items to boost your abilities.
 
-<img width="1282" height="752" alt="Shandalar World" src="https://github.com/user-attachments/assets/9af31471-d688-442f-9418-9807d8635b72" />
+![Adventure Mode](https://downloads.cardforge.org/images/site/adventure-mode.png "Adventure Mode")
 
 ### 🔍 Quest Modes
 Engage in focused gameplay without the overworld exploration—perfect for quick sessions!
 
-<img width="1282" height="752" alt="Quest Duels" src="https://github.com/user-attachments/assets/b9613b1c-e8c3-4320-8044-6922c519aad4" />
-
 ### 🤖 AI Formats
 Test your skills against AI in multiple formats:
 - **Sealed**
@@ -63,8 +60,6 @@ Test your skills against AI in multiple formats:
 
 For comprehensive gameplay instructions, visit our [Gameplay Guide](https://github.com/Card-Forge/forge/wiki/Gameplay-Guide).
 
-<img width="1282" height="752" alt="Sealed" src="https://github.com/user-attachments/assets/ae603dbd-4421-4753-a333-87cb0a28d772" />
-
 ---
 
 ## 💬 Support & Community

adventure-editor/pom.xml

@@ -3,7 +3,7 @@
     <parent>
         <artifactId>forge</artifactId>
         <groupId>forge</groupId>
-        <version>${revision}</version>
+        <version>2.0.00</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 

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

@@ -15,7 +15,7 @@ public class Main {
 
     public static void main(String[] args) {
         GuiBase.setInterface(new GuiMobile(Files.exists(Paths.get("./res"))?"./":"../forge-gui/"));
-        GuiBase.setDeviceInfo(null, 0, 0, System.getProperty("user.home") + "/Downloads/");
+        GuiBase.setDeviceInfo("", "", 0, 0);
         new EditorMainWindow(Config.instance());
     }
 }

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

@@ -45,16 +45,17 @@ public class BiomeStructureDataMappingEditor extends JComponent {
                 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 biomeData))
+            if(!(value instanceof BiomeStructureData.BiomeStructureDataMapping))
                 return label;
+            BiomeStructureData.BiomeStructureDataMapping data=(BiomeStructureData.BiomeStructureDataMapping) value;
             // Get the renderer component from parent class
 
-            label.setText(biomeData.name);
+            label.setText(data.name);
             if(editor.data!=null)
             {
                 SwingAtlas itemAtlas=new SwingAtlas(Config.instance().getFile(editor.data.structureAtlasPath));
-                if(itemAtlas.has(biomeData.name))
-                    label.setIcon(itemAtlas.get(biomeData.name));
+                if(itemAtlas.has(data.name))
+                    label.setIcon(itemAtlas.get(data.name));
                 else
                 {
                     ImageIcon img=itemAtlas.getAny();

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

@@ -25,8 +25,9 @@ public class DialogOptionEditor extends JComponent{
                 JList list, Object value, int index,
                 boolean isSelected, boolean cellHasFocus) {
             JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
-            if(!(value instanceof DialogData dialog))
+            if(!(value instanceof DialogData))
                 return label;
+            DialogData dialog=(DialogData) value;
             StringBuilder builder=new StringBuilder();
             if(dialog.name==null||dialog.name.isEmpty())
                 builder.append("[[Blank Option]]");

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

@@ -27,16 +27,17 @@ public class ItemsEditor extends JComponent {
                 JList list, Object value, int index,
                 boolean isSelected, boolean cellHasFocus) {
             JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
-            if(!(value instanceof ItemData item))
+            if(!(value instanceof ItemData))
                 return label;
+            ItemData Item=(ItemData) value;
             // Get the renderer component from parent class
 
-            label.setText(item.name);
+            label.setText(Item.name);
             if(itemAtlas==null)
                 itemAtlas=new SwingAtlas(Config.instance().getFile(Paths.ITEMS_ATLAS));
             
-            if(itemAtlas.has(item.iconName))
-                label.setIcon(itemAtlas.get(item.iconName));
+            if(itemAtlas.has(Item.iconName))
+                label.setIcon(itemAtlas.get(Item.iconName));
             else
             {
                 ImageIcon img=itemAtlas.getAny();

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

@@ -26,8 +26,9 @@ public class QuestEditor extends JComponent {
                 JList list, Object value, int index,
                 boolean isSelected, boolean cellHasFocus) {
             JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
-            if(!(value instanceof AdventureQuestData quest))
+            if(!(value instanceof AdventureQuestData))
                 return label;
+            AdventureQuestData quest=(AdventureQuestData) value;
             // Get the renderer component from parent class
 
             label.setText(quest.name);

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

@@ -26,8 +26,9 @@ public class QuestStageEditor extends JComponent{
                 JList list, Object value, int index,
                 boolean isSelected, boolean cellHasFocus) {
             JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
-            if(!(value instanceof AdventureQuestStage stageData))
+            if(!(value instanceof AdventureQuestStage))
                 return label;
+            AdventureQuestStage stageData=(AdventureQuestStage) value;
             label.setText(stageData.name);
             //label.setIcon(new ImageIcon(Config.instance().getFilePath(stageData.sourcePath))); //Type icon eventually?
             return label;

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

@@ -25,10 +25,10 @@ public class RewardEdit extends FormPanel {
     TextListEdit colors =new TextListEdit(new String[] { "White", "Blue", "Black", "Red", "Green" });
     TextListEdit rarity =new TextListEdit(new String[] { "Basic Land", "Common", "Uncommon", "Rare", "Mythic Rare" });
     TextListEdit subTypes =new TextListEdit();
-    TextListEdit cardTypes =new TextListEdit(Arrays.stream(CardType.CoreType.values()).map(CardType.CoreType::toString).toArray(String[]::new));
-    TextListEdit superTypes =new TextListEdit(Arrays.stream(CardType.Supertype.values()).map(CardType.Supertype::toString).toArray(String[]::new));
+    TextListEdit cardTypes =new TextListEdit(Arrays.asList(CardType.CoreType.values()).stream().map(CardType.CoreType::toString).toArray(String[]::new));
+    TextListEdit superTypes =new TextListEdit(Arrays.asList(CardType.Supertype.values()).stream().map(CardType.Supertype::toString).toArray(String[]::new));
     TextListEdit manaCosts =new TextListEdit();
-    TextListEdit keyWords =new TextListEdit(Arrays.stream(Keyword.values()).map(Keyword::toString).toArray(String[]::new));
+    TextListEdit keyWords =new TextListEdit(Arrays.asList(Keyword.values()).stream().map(Keyword::toString).toArray(String[]::new));
     JComboBox colorType =new JComboBox(new String[] { "Any", "Colorless", "MultiColor", "MonoColor"});
     JTextField cardText =new JTextField();
     private boolean updating=false;

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

@@ -43,8 +43,9 @@ public class WorldEditor extends JComponent {
                 JList list, Object value, int index,
                 boolean isSelected, boolean cellHasFocus) {
             JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
-            if(!(value instanceof BiomeData biome))
+            if(!(value instanceof BiomeData))
                 return label;
+            BiomeData biome=(BiomeData) value;
             // Get the renderer component from parent class
 
             label.setText(biome.name);

forge-ai/pom.xml

@@ -6,7 +6,7 @@
     <parent>
         <artifactId>forge</artifactId>
         <groupId>forge</groupId>
-        <version>${revision}</version>
+        <version>2.0.00</version>
     </parent>
 
     <artifactId>forge-ai</artifactId>

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

@@ -13,7 +13,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
-public class AiDeckStatistics {
+public class AIDeckStatistics {
 
     public float averageCMC = 0;
     // TODO implement this. Use a numerically stable algorithm from
@@ -24,9 +24,9 @@ public class AiDeckStatistics {
 
     // in WUBRGC order from ManaCost.getColorShardCounts()
     public int[] maxPips = null;
-    // public int[] numSources = new int[6];
+//    public int[] numSources = new int[6];
     public int numLands = 0;
-    public AiDeckStatistics(float averageCMC, float stddevCMC, int maxCost, int maxColoredCost, int[] maxPips, int numLands) {
+    public AIDeckStatistics(float averageCMC, float stddevCMC, int maxCost, int maxColoredCost, int[] maxPips, int numLands) {
         this.averageCMC = averageCMC;
         this.stddevCMC = stddevCMC;
         this.maxCost = maxCost;
@@ -35,7 +35,7 @@ public class AiDeckStatistics {
         this.numLands = numLands;
     }
 
-    public static AiDeckStatistics fromCards(List<Card> cards) {
+    public static AIDeckStatistics fromCards(List<Card> cards) {
         int totalCMC = 0;
         int totalCount = 0;
         int numLands = 0;
@@ -75,7 +75,7 @@ public class AiDeckStatistics {
 
         }
 
-        return new AiDeckStatistics(totalCount == 0 ? 0 : totalCMC / (float)totalCount,
+        return new AIDeckStatistics(totalCount == 0 ? 0 : totalCMC / (float)totalCount,
                 0, // TODO use https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
                 maxCost,
                 maxColoredCost,
@@ -85,7 +85,7 @@ public class AiDeckStatistics {
     }
 
 
-    public static AiDeckStatistics fromDeck(Deck deck, Player player) {
+    public static AIDeckStatistics fromDeck(Deck deck, Player player) {
         List<Card> cardlist = new ArrayList<>();
         for (final Map.Entry<DeckSection, CardPool> deckEntry : deck) {
             switch (deckEntry.getKey()) {
@@ -104,7 +104,7 @@ public class AiDeckStatistics {
         return fromCards(cardlist);
     }
 
-    public static AiDeckStatistics fromPlayer(Player player) {
+    public static AIDeckStatistics fromPlayer(Player player) {
         Deck deck = player.getRegisteredPlayer().getDeck();
         if (deck.isEmpty()) {
             // we're in a test or some weird match, search through the hand and library and build the decklist
@@ -120,6 +120,7 @@ public class AiDeckStatistics {
         }
 
         return fromDeck(deck, player);
+
     }
 
 }

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

@@ -1,9 +0,0 @@
-package forge.ai;
-
-public record AiAbilityDecision(int rating, AiPlayDecision decision) {
-    private static int MIN_RATING = 30;
-
-    public boolean willingToPlay() {
-        return rating > MIN_RATING && decision.willingToPlay();
-    }
-}

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

@@ -17,6 +17,8 @@
  */
 package forge.ai;
 
+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;
@@ -37,21 +39,17 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityPredicates;
 import forge.game.staticability.StaticAbility;
 import forge.game.staticability.StaticAbilityAssignCombatDamageAsUnblocked;
-import forge.game.staticability.StaticAbilityMode;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
 import forge.game.zone.ZoneType;
-import forge.util.*;
+import forge.util.Aggregates;
+import forge.util.Expressions;
+import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 import forge.util.collect.FCollectionView;
 import org.apache.commons.lang3.tuple.Pair;
 
 import java.util.*;
-import java.util.function.Predicate;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
 
 
 /**
@@ -76,9 +74,6 @@ public class AiAttackController {
 
     private int aiAggression = 0; // how aggressive the ai is attack will be depending on circumstances
     private final boolean nextTurn; // include creature that can only attack/block next turn
-    private final int timeOut;
-    private final boolean canUseTimeout;
-    private List<CompletableFuture<Integer>> futures = new ArrayList<>();
 
     /**
      * <p>
@@ -96,8 +91,6 @@ public class AiAttackController {
         myList = ai.getCreaturesInPlay();
         this.nextTurn = nextTurn;
         refreshCombatants(defendingOpponent);
-        this.timeOut = ai.getGame().getAITimeout();
-        this.canUseTimeout = ai.getGame().canUseTimeout();
     } // overloaded constructor to evaluate attackers that should attack next turn
 
     public AiAttackController(final Player ai, Card attacker) {
@@ -111,13 +104,11 @@ public class AiAttackController {
             attackers.add(attacker);
         }
         this.blockers = getPossibleBlockers(oppList, this.attackers, this.nextTurn);
-        this.timeOut = ai.getGame().getAITimeout();
-        this.canUseTimeout = ai.getGame().canUseTimeout();
     } // overloaded constructor to evaluate single specified attacker
 
     private void refreshCombatants(GameEntity defender) {
-        if (defender instanceof Card card && card.isBattle()) {
-            this.oppList = getOpponentCreatures(card.getProtectingPlayer());
+        if (defender instanceof Card && ((Card) defender).isBattle()) {
+            this.oppList = getOpponentCreatures(((Card) defender).getProtectingPlayer());
         } else {
             this.oppList = getOpponentCreatures(defendingOpponent);
         }
@@ -138,22 +129,20 @@ public class AiAttackController {
 
         CardCollection tappedDefenders = new CardCollection();
         for (Card c : CardLists.filter(defender.getCardsIn(ZoneType.Battlefield), canAnimate)) {
-            for (SpellAbility sa : IterableUtil.filter(c.getSpellAbilities(), SpellAbilityPredicates.isApi(ApiType.Animate))) {
+            for (SpellAbility sa : Iterables.filter(c.getSpellAbilities(), SpellAbilityPredicates.isApi(ApiType.Animate))) {
                 if (sa.usesTargeting() || !sa.getParamOrDefault("Defined", "Self").equals("Self")) {
                     continue;
                 }
                 sa.setActivatingPlayer(defender);
                 if (sa.isCrew() && !ComputerUtilCost.checkTapTypeCost(defender, sa.getPayCosts(), c, sa, tappedDefenders)) {
                     continue;
-                }
-                if (!ComputerUtilCost.canPayCost(sa, defender, false) || !sa.getRestrictions().checkOtherRestrictions(c, sa, defender)) {
+                } else if (!ComputerUtilCost.canPayCost(sa, defender, false) || !sa.getRestrictions().checkOtherRestrictions(c, sa, defender)) {
                     continue;
                 }
                 Card animatedCopy = AnimateAi.becomeAnimated(c, sa);
                 if (animatedCopy.isCreature()) {
-                    // TODO imprecise, only works 100% for colorless mana
                     int saCMC = sa.getPayCosts() != null && sa.getPayCosts().hasManaCost() ?
-                            sa.getPayCosts().getTotalMana().getCMC() : 0;
+                            sa.getPayCosts().getTotalMana().getCMC() : 0; // FIXME: imprecise, only works 100% for colorless mana
                     if (totalMana - manaReserved >= saCMC) {
                         manaReserved += saCMC;
                         defenders.add(animatedCopy);
@@ -164,7 +153,7 @@ public class AiAttackController {
             defenders.removeAll(tappedDefenders);
 
             // Transform (e.g. Incubator tokens)
-            for (SpellAbility sa : IterableUtil.filter(c.getSpellAbilities(), SpellAbilityPredicates.isApi(ApiType.SetState))) {
+            for (SpellAbility sa : Iterables.filter(c.getSpellAbilities(), SpellAbilityPredicates.isApi(ApiType.SetState))) {
                 Card transformedCopy = ComputerUtilCombat.canTransform(c);
                 if (transformedCopy.isCreature()) {
                     int saCMC = sa.getPayCosts() != null && sa.getPayCosts().hasManaCost() ?
@@ -180,7 +169,7 @@ public class AiAttackController {
     }
 
     public void removeBlocker(Card blocker) {
-        this.oppList.remove(blocker);
+    	this.oppList.remove(blocker);
         this.blockers.remove(blocker);
     }
 
@@ -297,7 +286,7 @@ public class AiAttackController {
         }
 
         if ("TRUE".equals(attacker.getSVar("HasAttackEffect"))) {
-            return true;
+        	return true;
         }
 
         // Damage opponent if unblocked
@@ -315,8 +304,7 @@ public class AiAttackController {
             }
         }
         // Poison opponent if unblocked
-        if (defender instanceof Player player
-                && ComputerUtilCombat.poisonIfUnblocked(attacker, player) > 0) {
+        if (defender instanceof Player && ComputerUtilCombat.poisonIfUnblocked(attacker, (Player) defender) > 0) {
             return true;
         }
 
@@ -400,7 +388,7 @@ public class AiAttackController {
         // reduce the search space
         final List<Card> opponentsAttackers = CardLists.filter(ai.getOpponents().getCreaturesInPlay(), c -> !c.hasSVar("EndOfTurnLeavePlay")
                 && (c.toughnessAssignsDamage() || c.getNetCombatDamage() > 0 // performance shortcuts
-                || c.getNetCombatDamage() + ComputerUtilCombat.predictPowerBonusOfAttacker(c, null, null, true) > 0)
+                        || c.getNetCombatDamage() + ComputerUtilCombat.predictPowerBonusOfAttacker(c, null, null, true) > 0)
                 && ComputerUtilCombat.canAttackNextTurn(c));
 
         // don't hold back creatures that can't block any of the human creatures
@@ -627,9 +615,9 @@ public class AiAttackController {
             // TODO: the AI should ideally predict how many times it can activate
             // for now, unless the opponent is tapped out, break at this point
             // and do not predict the blocker limit (which is safer)
-            if (defendingOpponent.getLandsInPlay().anyMatch(CardPredicates.UNTAPPED)) {
+            if (Iterables.any(defendingOpponent.getLandsInPlay(), CardPredicates.Presets.UNTAPPED)) {
                 maxBlockersAfterCrew += CardLists.count(CardLists.getNotType(defendingOpponent.getCardsIn(ZoneType.Battlefield), "Creature"),
-                        CardPredicates.isType("Vehicle").and(CardPredicates.UNTAPPED));
+                        Predicates.and(CardPredicates.isType("Vehicle"), CardPredicates.Presets.UNTAPPED));
             }
         }
 
@@ -853,9 +841,10 @@ public class AiAttackController {
         // 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) {
-            if (defender instanceof Player p) {
-                defendingOpponent = p;
-            } else if (defender instanceof Card defCard) {
+            if (defender instanceof Player) {
+                defendingOpponent = (Player) defender;
+            } else if (defender instanceof Card) {
+                Card defCard = (Card) defender;
                 if (defCard.isBattle()) {
                     defendingOpponent = defCard.getProtectingPlayer();
                 } else {
@@ -895,7 +884,7 @@ public class AiAttackController {
         // TODO: detect Season of the Witch by presence of a card with a specific trigger
         final boolean seasonOfTheWitch = ai.getGame().isCardInPlay("Season of the Witch");
 
-        final Queue<Card> attackersLeft = new ConcurrentLinkedQueue<>(this.attackers);
+        List<Card> attackersLeft = new ArrayList<>(this.attackers);
 
         // TODO probably use AttackConstraints instead of only GlobalAttackRestrictions?
         GlobalAttackRestrictions restrict = GlobalAttackRestrictions.getGlobalRestrictions(ai, combat.getDefenders());
@@ -911,76 +900,63 @@ public class AiAttackController {
         }
 
         // Attackers that don't really have a choice
-        final AtomicInteger numForcedAttackers = new AtomicInteger(0);
+        int numForcedAttackers = 0;
         // nextTurn is now only used by effect from Oracle en-Vec, which can skip check must attack,
         // because creatures not chosen can't attack.
         if (!nextTurn) {
             for (final Card attacker : this.attackers) {
-                final GameEntity finalDefender = defender;
-                futures.add(CompletableFuture.supplyAsync(()-> {
-                    GameEntity mustAttackDef = null;
-                    if (attacker.getSVar("MustAttack").equals("True")) {
-                        mustAttackDef = finalDefender;
-                    } else if (attacker.hasSVar("EndOfTurnLeavePlay")
-                            && isEffectiveAttacker(ai, attacker, combat, finalDefender)) {
-                        mustAttackDef = finalDefender;
-                    } else if (seasonOfTheWitch) {
-                        //TODO: if there are other ways to tap this creature (like mana creature), then don't need to attack
-                        mustAttackDef = finalDefender;
-                    } else {
-                        if (combat.getAttackConstraints().getRequirements().get(attacker) == null) return 0;
-                        // check defenders in order of maximum requirements
-                        List<Pair<GameEntity, Integer>> reqs = combat.getAttackConstraints().getRequirements().get(attacker).getSortedRequirements();
-                        final GameEntity def = finalDefender;
-                        reqs.sort((r1, r2) -> {
-                            if (r1.getValue() == r2.getValue()) {
-                                // try to attack the designated defender
-                                if (r1.getKey().equals(def) && !r2.getKey().equals(def)) {
-                                    return -1;
-                                }
-                                if (r2.getKey().equals(def) && !r1.getKey().equals(def)) {
-                                    return 1;
-                                }
-                                // otherwise PW
-                                if (r1.getKey() instanceof Card && r2.getKey() instanceof Player) {
-                                    return -1;
-                                }
-                                if (r2.getKey() instanceof Card && r1.getKey() instanceof Player) {
-                                    return 1;
-                                }
-                                // or weakest player
-                                if (r1.getKey() instanceof Player p1 && r2.getKey() instanceof Player p2) {
-                                    return p1.getLife() - p2.getLife();
-                                }
+                GameEntity mustAttackDef = null;
+                if (attacker.getSVar("MustAttack").equals("True")) {
+                    mustAttackDef = defender;
+                } else if (attacker.hasSVar("EndOfTurnLeavePlay")
+                        && isEffectiveAttacker(ai, attacker, combat, defender)) {
+                    mustAttackDef = defender;
+                } else if (seasonOfTheWitch) {
+                    //TODO: if there are other ways to tap this creature (like mana creature), then don't need to attack
+                    mustAttackDef = defender;
+                } else {
+                    if (combat.getAttackConstraints().getRequirements().get(attacker) == null) continue;
+                    // check defenders in order of maximum requirements
+                    List<Pair<GameEntity, Integer>> reqs = combat.getAttackConstraints().getRequirements().get(attacker).getSortedRequirements();
+                    final GameEntity def = defender;
+                    reqs.sort((r1, r2) -> {
+                        if (r1.getValue() == r2.getValue()) {
+                            // try to attack the designated defender
+                            if (r1.getKey().equals(def) && !r2.getKey().equals(def)) {
+                                return -1;
                             }
-                            return r2.getValue() - r1.getValue();
-                        });
-                        for (Pair<GameEntity, Integer> e : reqs) {
-                            if (e.getRight() == 0) continue;
-                            GameEntity mustAttackDefMaybe = e.getLeft();
-                            if (canAttackWrapper(attacker, mustAttackDefMaybe) && CombatUtil.getAttackCost(ai.getGame(), attacker, mustAttackDefMaybe) == null) {
-                                mustAttackDef = mustAttackDefMaybe;
-                                break;
+                            if (r2.getKey().equals(def) && !r1.getKey().equals(def)) {
+                                return 1;
+                            }
+                            // otherwise PW
+                            if (r1.getKey() instanceof Card && r2.getKey() instanceof Player) {
+                                return -1;
+                            }
+                            if (r2.getKey() instanceof Card && r1.getKey() instanceof Player) {
+                                return 1;
+                            }
+                            // or weakest player
+                            if (r1.getKey() instanceof Player && r2.getKey() instanceof Player) {
+                                return ((Player) r1.getKey()).getLife() - ((Player) r2.getKey()).getLife();
                             }
                         }
+                        return r2.getValue() - r1.getValue();
+                    });
+                    for (Pair<GameEntity, Integer> e : reqs) {
+                        if (e.getRight() == 0) continue;
+                        GameEntity mustAttackDefMaybe = e.getLeft();
+                        if (canAttackWrapper(attacker, mustAttackDefMaybe) && CombatUtil.getAttackCost(ai.getGame(), attacker, mustAttackDefMaybe) == null) {
+                            mustAttackDef = mustAttackDefMaybe;
+                            break;
+                        }
                     }
-                    if (mustAttackDef != null) {
-                        combat.addAttacker(attacker, mustAttackDef);
-                        attackersLeft.remove(attacker);
-                        numForcedAttackers.incrementAndGet();
-                    }
-                    return 0;
-                }).exceptionally(ex -> {
-                    ex.printStackTrace();
-                    return 0;
-                }));
+                }
+                if (mustAttackDef != null) {
+                    combat.addAttacker(attacker, mustAttackDef);
+                    attackersLeft.remove(attacker);
+                    numForcedAttackers++;
+                }
             }
-            CompletableFuture<?>[] futuresArray = futures.toArray(new CompletableFuture<?>[0]);
-            if (canUseTimeout)
-                CompletableFuture.allOf(futuresArray).completeOnTimeout(null, timeOut, TimeUnit.SECONDS).join();
-            else
-                CompletableFuture.allOf(futuresArray).join();
-            futures.clear();
             if (attackersLeft.isEmpty()) {
                 return aiAggression;
             }
@@ -988,19 +964,18 @@ public class AiAttackController {
 
         // Lightmine Field: make sure the AI doesn't wipe out its own creatures
         if (lightmineField) {
-            doLightmineFieldAttackLogic(attackersLeft, numForcedAttackers.get(), playAggro);
+            doLightmineFieldAttackLogic(attackersLeft, numForcedAttackers, playAggro);
         }
         // Revenge of Ravens: make sure the AI doesn't kill itself and doesn't damage itself unnecessarily
-        if (!doRevengeOfRavensAttackLogic(defender, attackersLeft, numForcedAttackers.get(), attackMax)) {
+        if (!doRevengeOfRavensAttackLogic(defender, attackersLeft, numForcedAttackers, attackMax)) {
             return aiAggression;
         }
 
         if (bAssault && defender == defendingOpponent) { // in case we are forced to attack someone else
             if (LOG_AI_ATTACKS)
                 System.out.println("Assault");
-            List<Card> left = new ArrayList<>(attackersLeft);
-            CardLists.sortByPowerDesc(left);
-            for (Card attacker : left) {
+            CardLists.sortByPowerDesc(attackersLeft);
+            for (Card attacker : attackersLeft) {
                 // reached max, breakup
                 if (attackMax != -1 && combat.getAttackers().size() >= attackMax)
                     return aiAggression;
@@ -1252,7 +1227,7 @@ public class AiAttackController {
         if (ratioDiff > 0 && doAttritionalAttack) {
             aiAggression = 5; // attack at all costs
         } else if ((ratioDiff >= 1 && this.attackers.size() > 1 && (humanLifeToDamageRatio < 2 || outNumber > 0))
-                || (playAggro && MyRandom.percentTrue(chanceToAttackToTrade) && humanLifeToDamageRatio > 1)) {
+        		|| (playAggro && MyRandom.percentTrue(chanceToAttackToTrade) && humanLifeToDamageRatio > 1)) {
             aiAggression = 4; // attack expecting to trade or damage player.
         } else if (MyRandom.percentTrue(chanceToAttackToTrade) && humanLifeToDamageRatio > 1
                 && defendingOpponent != null
@@ -1262,7 +1237,7 @@ public class AiAttackController {
                 && (ComputerUtilMana.getAvailableManaEstimate(ai) > 0) || tradeIfTappedOut
                 && (ComputerUtilMana.getAvailableManaEstimate(defendingOpponent) == 0) || MyRandom.percentTrue(extraChanceIfOppHasMana)
                 && (!tradeIfLowerLifePressure || (ai.getLifeLostLastTurn() + ai.getLifeLostThisTurn() <
-                defendingOpponent.getLifeLostThisTurn() + defendingOpponent.getLifeLostThisTurn()))) {
+                        defendingOpponent.getLifeLostThisTurn() + defendingOpponent.getLifeLostThisTurn()))) {
             aiAggression = 4; // random (chance-based) attack expecting to trade or damage player.
         } else if (ratioDiff >= 0 && this.attackers.size() > 1) {
             aiAggression = 3; // attack expecting to make good trades or damage player.
@@ -1290,20 +1265,19 @@ public class AiAttackController {
         if ( LOG_AI_ATTACKS )
             System.out.println("Normal attack");
 
-        List<Card> left = new ArrayList<>(attackersLeft);
-        left = notNeededAsBlockers(combat.getAttackers(), left);
-        left = sortAttackers(left);
+        attackersLeft = notNeededAsBlockers(combat.getAttackers(), attackersLeft);
+        attackersLeft = sortAttackers(attackersLeft);
 
         if ( LOG_AI_ATTACKS )
-            System.out.println("attackersLeft = " + left);
+            System.out.println("attackersLeft = " + attackersLeft);
 
         FCollection<GameEntity> possibleDefenders = new FCollection<>(defendingOpponent);
         possibleDefenders.addAll(defendingOpponent.getPlaneswalkersInPlay());
 
-        while (!left.isEmpty()) {
+        while (!attackersLeft.isEmpty()) {
             CardCollection attackersAssigned = new CardCollection();
-            for (int i = 0; i < left.size(); i++) {
-                final Card attacker = left.get(i);
+            for (int i = 0; i < attackersLeft.size(); i++) {
+                final Card attacker = attackersLeft.get(i);
                 if (aiAggression < 5 && !attacker.hasFirstStrike() && !attacker.hasDoubleStrike()
                         && ComputerUtilCombat.getTotalFirstStrikeBlockPower(attacker, defendingOpponent)
                         >= ComputerUtilCombat.getDamageToKill(attacker, false)) {
@@ -1317,7 +1291,7 @@ public class AiAttackController {
                     attackersAssigned.add(attacker);
 
                     // check if attackers are enough to finish the attacked planeswalker
-                    if (i < left.size() - 1 && defender instanceof Card card) {
+                    if (i < attackersLeft.size() - 1 && defender instanceof Card) {
                         final int blockNum = this.blockers.size();
                         int attackNum = 0;
                         int damage = 0;
@@ -1331,19 +1305,19 @@ public class AiAttackController {
                             }
                         }
                         // if enough damage: switch to next planeswalker
-                        if (damage >= ComputerUtilCombat.getDamageToKill(card, true)) {
+                        if (damage >= ComputerUtilCombat.getDamageToKill((Card) defender, true)) {
                             break;
                         }
                     }
                 }
             }
 
-            left.removeAll(attackersAssigned);
+            attackersLeft.removeAll(attackersAssigned);
             possibleDefenders.remove(defender);
-            if (left.isEmpty() || possibleDefenders.isEmpty()) {
+            if (attackersLeft.isEmpty() || possibleDefenders.isEmpty()) {
                 break;
             }
-            CardCollection pwDefending = new CardCollection(IterableUtil.filter(possibleDefenders, Card.class));
+            CardCollection pwDefending = new CardCollection(Iterables.filter(possibleDefenders, Card.class));
             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());
@@ -1393,13 +1367,12 @@ public class AiAttackController {
             canTrampleOverDefenders = attacker.hasKeyword(Keyword.TRAMPLE) && attacker.getNetCombatDamage() > Aggregates.sum(validBlockers, Card::getNetToughness);
 
             // used to check that CanKillAllDangerous check makes sense in context where creatures with dangerous abilities are present
-            dangerousBlockersPresent = validBlockers.anyMatch(
-                    CardPredicates.hasKeyword(Keyword.LIFELINK)
-                    .or(Card::isWitherDamage)
-            );
+            dangerousBlockersPresent = Iterables.any(validBlockers, Predicates.or(
+                    CardPredicates.hasKeyword(Keyword.WITHER), CardPredicates.hasKeyword(Keyword.INFECT),
+                    CardPredicates.hasKeyword(Keyword.LIFELINK)));
 
             // total power of the defending creatures, used in predicting whether a gang block can kill the attacker
-            defPower = CardLists.getTotalPower(validBlockers, null);
+            defPower = CardLists.getTotalPower(validBlockers, true, false);
 
             // look at the attacker in relation to the blockers to establish a
             // number of factors about the attacking context that will be relevant
@@ -1424,7 +1397,7 @@ public class AiAttackController {
                         canKillAll = false;
 
                         if (blocker.getSVar("HasCombatEffect").equals("TRUE") || blocker.getSVar("HasBlockEffect").equals("TRUE")
-                                || blocker.isWitherDamage() || blocker.hasKeyword(Keyword.LIFELINK)) {
+                                || blocker.hasKeyword(Keyword.WITHER) || blocker.hasKeyword(Keyword.INFECT) || blocker.hasKeyword(Keyword.LIFELINK)) {
                             canKillAllDangerous = false;
                             // there is a creature that can survive an attack from this creature
                             // and combat will have negative effects
@@ -1523,51 +1496,51 @@ public class AiAttackController {
 
         // decide if the creature should attack based on the prevailing strategy choice in aiAggression
         switch (aiAggression) {
-            case 6: // Exalted: expecting to at least kill a creature of equal value or not be blocked
-                if ((saf.canKillAll && saf.isWorthLessThanAllKillers) || !saf.canBeBlocked()) {
-                    if (LOG_AI_ATTACKS)
-                        System.out.println(attacker.getName() + " = attacking expecting to kill creature, or is unblockable");
-                    return true;
-                }
-                break;
-            case 5: // all out attacking
+        case 6: // Exalted: expecting to at least kill a creature of equal value or not be blocked
+            if ((saf.canKillAll && saf.isWorthLessThanAllKillers) || !saf.canBeBlocked()) {
                 if (LOG_AI_ATTACKS)
-                    System.out.println(attacker.getName() + " = all out attacking");
+                    System.out.println(attacker.getName() + " = attacking expecting to kill creature, or is unblockable");
                 return true;
-            case 4: // expecting to at least trade with something, or can attack "for free", expecting no counterattack
-                if (saf.canKillAll || (saf.dangerousBlockersPresent && saf.canKillAllDangerous && !saf.canBeKilledByOne) || !saf.canBeBlocked()
-                        || saf.defPower == 0) {
-                    if (LOG_AI_ATTACKS)
-                        System.out.println(attacker.getName() + " = attacking expecting to at least trade with something");
-                    return true;
-                }
-                break;
-            case 3: // expecting to at least kill a creature of equal value or not be blocked
-                if ((saf.canKillAll && saf.isWorthLessThanAllKillers)
-                        || (((saf.dangerousBlockersPresent && saf.canKillAllDangerous) || saf.hasAttackEffect || saf.hasCombatEffect) && !saf.canBeKilledByOne)
-                        || !saf.canBeBlocked()) {
-                    if (LOG_AI_ATTACKS)
-                        System.out.println(attacker.getName() + " = attacking expecting to kill creature or cause damage, or is unblockable");
-                    return true;
-                }
-                break;
-            case 2: // attack expecting to attract a group block or destroying a single blocker and surviving
-                if (!saf.canBeBlocked() || ((saf.canKillAll || saf.hasAttackEffect || saf.hasCombatEffect) && !saf.canBeKilledByOne &&
-                        ((saf.dangerousBlockersPresent && saf.canKillAllDangerous) || !saf.canBeKilled))) {
-                    if (LOG_AI_ATTACKS)
-                        System.out.println(attacker.getName() + " = attacking expecting to survive or attract group block");
-                    return true;
-                }
-                break;
-            case 1: // unblockable creatures only
-                if (!saf.canBeBlocked() || (saf.numberOfPossibleBlockers == 1 && saf.canKillAll && !saf.canBeKilledByOne)) {
-                    if (LOG_AI_ATTACKS)
-                        System.out.println(attacker.getName() + " = attacking expecting not to be blocked");
-                    return true;
-                }
-                break;
-            default:
-                break;
+            }
+            break;
+        case 5: // all out attacking
+            if (LOG_AI_ATTACKS)
+                System.out.println(attacker.getName() + " = all out attacking");
+            return true;
+        case 4: // expecting to at least trade with something, or can attack "for free", expecting no counterattack
+            if (saf.canKillAll || (saf.dangerousBlockersPresent && saf.canKillAllDangerous && !saf.canBeKilledByOne) || !saf.canBeBlocked()
+                    || saf.defPower == 0) {
+                if (LOG_AI_ATTACKS)
+                    System.out.println(attacker.getName() + " = attacking expecting to at least trade with something");
+                return true;
+            }
+            break;
+        case 3: // expecting to at least kill a creature of equal value or not be blocked
+            if ((saf.canKillAll && saf.isWorthLessThanAllKillers)
+                    || (((saf.dangerousBlockersPresent && saf.canKillAllDangerous) || saf.hasAttackEffect || saf.hasCombatEffect) && !saf.canBeKilledByOne)
+                    || !saf.canBeBlocked()) {
+                if (LOG_AI_ATTACKS)
+                    System.out.println(attacker.getName() + " = attacking expecting to kill creature or cause damage, or is unblockable");
+                return true;
+            }
+            break;
+        case 2: // attack expecting to attract a group block or destroying a single blocker and surviving
+            if (!saf.canBeBlocked() || ((saf.canKillAll || saf.hasAttackEffect || saf.hasCombatEffect) && !saf.canBeKilledByOne &&
+                    ((saf.dangerousBlockersPresent && saf.canKillAllDangerous) || !saf.canBeKilled))) {
+                if (LOG_AI_ATTACKS)
+                    System.out.println(attacker.getName() + " = attacking expecting to survive or attract group block");
+                return true;
+            }
+            break;
+        case 1: // unblockable creatures only
+            if (!saf.canBeBlocked() || (saf.numberOfPossibleBlockers == 1 && saf.canKillAll && !saf.canBeKilledByOne)) {
+                if (LOG_AI_ATTACKS)
+                    System.out.println(attacker.getName() + " = attacking expecting not to be blocked");
+                return true;
+            }
+            break;
+        default:
+            break;
         }
         return false; // don't attack
     }
@@ -1590,7 +1563,7 @@ public class AiAttackController {
             // but there are no creatures it can target, no need to exert with it
             boolean missTarget = false;
             for (StaticAbility st : c.getStaticAbilities()) {
-                if (!st.checkMode(StaticAbilityMode.OptionalAttackCost)) {
+                if (!"OptionalAttackCost".equals(st.getParam("Mode"))) {
                     continue;
                 }
                 SpellAbility sa = st.getPayingTrigSA();
@@ -1612,12 +1585,12 @@ public class AiAttackController {
                     break;
                 }
                 if (sa.usesTargeting()) {
-                    sa.setActivatingPlayer(c.getController());
+                    sa.setActivatingPlayer(c.getController(), true);
                     List<Card> validTargets = CardUtil.getValidCardsToTarget(sa);
                     if (validTargets.isEmpty()) {
                         missTarget = true;
                         break;
-                    } else if (sa.isCurse() && validTargets.stream().noneMatch(
+                    } else if (sa.isCurse() && !Iterables.any(validTargets,
                             CardPredicates.isControlledByAnyOf(c.getController().getOpponents()))) {
                         // e.g. Ahn-Crop Crasher - the effect is only good when aimed at opponent's creatures
                         missTarget = true;
@@ -1684,31 +1657,31 @@ public class AiAttackController {
             }
             if (color != null) {
                 switch (color) {
-                    case "black":
-                        if (!c.isBlack()) {
-                            color = null;
-                        }
-                        break;
-                    case "blue":
-                        if (!c.isBlue()) {
-                            color = null;
-                        }
-                        break;
-                    case "green":
-                        if (!c.isGreen()) {
-                            color = null;
-                        }
-                        break;
-                    case "red":
-                        if (!c.isRed()) {
-                            color = null;
-                        }
-                        break;
-                    case "white":
-                        if (!c.isWhite()) {
-                            color = null;
-                        }
-                        break;
+                case "black":
+                    if (!c.isBlack()) {
+                        color = null;
+                    }
+                    break;
+                case "blue":
+                    if (!c.isBlue()) {
+                        color = null;
+                    }
+                    break;
+                case "green":
+                    if (!c.isGreen()) {
+                        color = null;
+                    }
+                    break;
+                case "red":
+                    if (!c.isRed()) {
+                        color = null;
+                    }
+                    break;
+                case "white":
+                    if (!c.isWhite()) {
+                        color = null;
+                    }
+                    break;
                 }
             }
             if (color == null && artifact == null) { //nothing can make the attacker unblockable
@@ -1724,7 +1697,7 @@ public class AiAttackController {
         return null; //should never get here
     }
 
-    private void doLightmineFieldAttackLogic(final Queue<Card> attackersLeft, int numForcedAttackers, boolean playAggro) {
+    private void doLightmineFieldAttackLogic(final List<Card> attackersLeft, int numForcedAttackers, boolean playAggro) {
         CardCollection attSorted = new CardCollection(attackersLeft);
         CardCollection attUnsafe = new CardCollection();
         CardLists.sortByToughnessDesc(attSorted);
@@ -1754,15 +1727,13 @@ public class AiAttackController {
         attackersLeft.removeAll(attUnsafe);
     }
 
-    private boolean doRevengeOfRavensAttackLogic(final GameEntity defender, final Queue<Card> attackersLeft, int numForcedAttackers, int maxAttack) {
+    private boolean doRevengeOfRavensAttackLogic(final GameEntity defender, final List<Card> attackersLeft, int numForcedAttackers, int maxAttack) {
         // TODO: detect Revenge of Ravens by the trigger instead of by name
         boolean revengeOfRavens = false;
-        if (defender instanceof Player player) {
-            revengeOfRavens = !CardLists.filter(player.getCardsIn(ZoneType.Battlefield),
-                    CardPredicates.nameEquals("Revenge of Ravens")).isEmpty();
-        } else if (defender instanceof Card card) {
-            revengeOfRavens = !CardLists.filter(card.getController().getCardsIn(ZoneType.Battlefield),
-                    CardPredicates.nameEquals("Revenge of Ravens")).isEmpty();
+        if (defender instanceof Player) {
+            revengeOfRavens = !CardLists.filter(((Player)defender).getCardsIn(ZoneType.Battlefield), CardPredicates.nameEquals("Revenge of Ravens")).isEmpty();
+        } else if (defender instanceof Card) {
+            revengeOfRavens = !CardLists.filter(((Card)defender).getController().getCardsIn(ZoneType.Battlefield), CardPredicates.nameEquals("Revenge of Ravens")).isEmpty();
         }
 
         if (!revengeOfRavens) {

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

@@ -18,7 +18,9 @@
 package forge.ai;
 
 import java.util.*;
-import java.util.function.Predicate;
+
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
 
 import forge.card.CardStateName;
 import forge.game.GameEntity;
@@ -161,12 +163,12 @@ public class AiBlockController {
         // defend battles with fewer defense counters before battles with more defense counters,
         // if planeswalker/battle will be too difficult to defend don't even bother
         for (GameEntity defender : defenders) {
-            if ((defender instanceof Card card1 && card1.getController().equals(ai))
-                    || (defender instanceof Card card2 && card2.isBattle() && card2.getProtectingPlayer().equals(ai))) {
-                final CardCollection ccAttackers = combat.getAttackersOf(defender);
+            if ((defender instanceof Card && ((Card) defender).getController().equals(ai))
+                    || (defender instanceof Card && ((Card) defender).isBattle() && ((Card) defender).getProtectingPlayer().equals(ai))) {
+                final CardCollection attackers = combat.getAttackersOf(defender);
                 // Begin with the attackers that pose the biggest threat
-                CardLists.sortByPowerDesc(ccAttackers);
-                sortedAttackers.addAll(ccAttackers);
+                CardLists.sortByPowerDesc(attackers);
+                sortedAttackers.addAll(attackers);
             } else if (defender instanceof Player && defender.equals(ai)) {
                 firstAttacker = combat.getAttackersOf(defender);
                 CardLists.sortByPowerDesc(firstAttacker);
@@ -325,7 +327,7 @@ public class AiBlockController {
     }
 
     private Predicate<Card> rampagesOrNeedsManyToBlock(final Combat combat) {
-        return CardPredicates.hasKeyword(Keyword.RAMPAGE).or(input -> {
+        return Predicates.or(CardPredicates.hasKeyword(Keyword.RAMPAGE), input -> {
             // select creature that has a max blocker
             return StaticAbilityCantAttackBlock.getMinMaxBlocker(input, combat.getDefenderPlayerByAttacker(input)).getRight() < Integer.MAX_VALUE;
         });
@@ -366,7 +368,7 @@ public class AiBlockController {
      * @param combat a {@link forge.game.combat.Combat} object.
      */
     private void makeGangBlocks(final Combat combat) {
-        List<Card> currentAttackers = CardLists.filter(attackersLeft, rampagesOrNeedsManyToBlock(combat).negate());
+        List<Card> currentAttackers = CardLists.filter(attackersLeft, Predicates.not(rampagesOrNeedsManyToBlock(combat)));
         List<Card> blockers;
 
         // Try to block an attacker without first strike with a gang of first strikers
@@ -738,11 +740,11 @@ public class AiBlockController {
         List<Card> chumpBlockers;
 
         List<Card> tramplingAttackers = CardLists.getKeyword(attackers, Keyword.TRAMPLE);
-        tramplingAttackers = CardLists.filter(tramplingAttackers, rampagesOrNeedsManyToBlock(combat).negate());
+        tramplingAttackers = CardLists.filter(tramplingAttackers, Predicates.not(rampagesOrNeedsManyToBlock(combat)));
 
         // TODO - Instead of filtering out rampage-like and similar triggers, make the AI properly count P/T and
         // reinforce when actually possible without losing material.
-        tramplingAttackers = CardLists.filter(tramplingAttackers, changesPTWhenBlocked(true).negate());
+        tramplingAttackers = CardLists.filter(tramplingAttackers, Predicates.not(changesPTWhenBlocked(true)));
 
         for (final Card attacker : tramplingAttackers) {
             if (CombatUtil.getMinNumBlockersForAttacker(attacker, combat.getDefenderPlayerByAttacker(attacker)) > combat.getBlockers(attacker).size()) {
@@ -793,11 +795,11 @@ public class AiBlockController {
     private void reinforceBlockersToKill(final Combat combat) {
         List<Card> safeBlockers;
         List<Card> blockers;
-        List<Card> targetAttackers = CardLists.filter(blockedButUnkilled, rampagesOrNeedsManyToBlock(combat).negate());
+        List<Card> targetAttackers = CardLists.filter(blockedButUnkilled, Predicates.not(rampagesOrNeedsManyToBlock(combat)));
 
         // TODO - Instead of filtering out rampage-like and similar triggers, make the AI properly count P/T and
         // reinforce when actually possible without losing material.
-        targetAttackers = CardLists.filter(targetAttackers, changesPTWhenBlocked(false).negate());
+        targetAttackers = CardLists.filter(targetAttackers, Predicates.not(changesPTWhenBlocked(false)));
 
         for (final Card attacker : targetAttackers) {
             blockers = getPossibleBlockers(combat, attacker, blockersLeft, false);
@@ -872,9 +874,9 @@ public class AiBlockController {
             CardCollection threatenedPWs = new CardCollection();
             for (final Card attacker : attackers) {
                 GameEntity def = combat.getDefenderByAttacker(attacker);
-                if (def instanceof Card card) {
+                if (def instanceof Card) {
                     if (!onlyIfLethal) {
-                        threatenedPWs.add(card);
+                        threatenedPWs.add((Card) def);
                     } else {
                         int damageToPW = 0;
                         for (final Card pwatkr : combat.getAttackersOf(def)) {
@@ -906,12 +908,12 @@ public class AiBlockController {
                         continue;
                     }
                     GameEntity def = combat.getDefenderByAttacker(attacker);
-                    if (def instanceof Card card && threatenedPWs.contains(def)) {
+                    if (def instanceof Card && threatenedPWs.contains(def)) {
                         Card blockerDecided = null;
                         for (final Card blocker : chumpPWDefenders) {
                             if (CombatUtil.canBlock(attacker, blocker, combat)) {
                                 combat.addBlocker(attacker, blocker);
-                                pwsWithChumpBlocks.add(card);
+                                pwsWithChumpBlocks.add((Card) def);
                                 chosenChumpBlockers.add(blocker);
                                 blockerDecided = blocker;
                                 blockersLeft.remove(blocker);
@@ -1343,11 +1345,11 @@ public class AiBlockController {
         boolean creatureParityOrAllowedDiff = aiCreatureCount
                 + (randomTradeIfBehindOnBoard ? maxCreatDiff : 0) >= oppCreatureCount;
         boolean wantToTradeWithCreatInHand = !checkingOther && randomTradeIfCreatInHand
-                && ai.getZone(ZoneType.Hand).contains(CardPredicates.CREATURES)
+                && ai.getZone(ZoneType.Hand).contains(CardPredicates.Presets.CREATURES)
                 && aiCreatureCount + maxCreatDiffWithRepl >= oppCreatureCount;
         boolean wantToSavePlaneswalker = MyRandom.percentTrue(chanceToSavePW)
-                && combat.getDefenderByAttacker(attacker) instanceof Card card
-                && card.isPlaneswalker();
+                && combat.getDefenderByAttacker(attacker) instanceof Card
+                && ((Card) combat.getDefenderByAttacker(attacker)).isPlaneswalker();
         boolean wantToTradeDownToSavePW = chanceToTradeDownToSaveWalker > 0;
 
         return ((evalBlk <= evalAtk + 1) || (wantToSavePlaneswalker && wantToTradeDownToSavePW)) // "1" accounts for tapped.

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

@@ -18,17 +18,12 @@
 
 package forge.ai;
 
-import java.util.Map;
+import java.util.HashSet;
 import java.util.Set;
 
-import com.google.common.base.Supplier;
-import com.google.common.base.Suppliers;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
 import forge.game.card.Card;
 import forge.game.player.Player;
 
-
 /**
  * <p>
  * AiCardMemory class.
@@ -59,6 +54,7 @@ public class AiCardMemory {
         ATTACHED_THIS_TURN, // These equipments were attached to something already this turn
         ANIMATED_THIS_TURN, // These cards had their AF Animate effect activated this turn
         BOUNCED_THIS_TURN, // These cards were bounced this turn
+        ACTIVATED_THIS_TURN, // These cards had their ability activated this turn
         CHOSEN_FOG_EFFECT, // These cards are marked as the Fog-like effect the AI is planning to cast this turn
         MARKED_TO_AVOID_REENTRY, // These cards may cause a stack smash when processed recursively, and are thus marked to avoid a crash
         PAYS_TAP_COST, // These cards will be tapped as part of a cost and cannot be chosen in another part
@@ -66,13 +62,75 @@ public class AiCardMemory {
         REVEALED_CARDS // These cards were recently revealed to the AI by a call to PlayerControllerAi.reveal
     }
 
-    private final Supplier<Map<MemorySet, Set<Card>>> memoryMap = Suppliers.memoize(Maps::newConcurrentMap);
+    private final Set<Card> memMandatoryAttackers;
+    private final Set<Card> memTrickAttackers;
+    private final Set<Card> memHeldManaSources;
+    private final Set<Card> memHeldManaSourcesForCombat;
+    private final Set<Card> memHeldManaSourcesForEnemyCombat;
+    private final Set<Card> memHeldManaSourcesForNextSpell;
+    private final Set<Card> memAttachedThisTurn;
+    private final Set<Card> memAnimatedThisTurn;
+    private final Set<Card> memBouncedThisTurn;
+    private final Set<Card> memActivatedThisTurn;
+    private final Set<Card> memChosenFogEffect;
+    private final Set<Card> memMarkedToAvoidReentry;
+    private final Set<Card> memPaysTapCost;
+    private final Set<Card> memPaysSacCost;
+    private final Set<Card> memRevealedCards;
 
     public AiCardMemory() {
+        this.memMandatoryAttackers = new HashSet<>();
+        this.memHeldManaSources = new HashSet<>();
+        this.memHeldManaSourcesForCombat = new HashSet<>();
+        this.memHeldManaSourcesForEnemyCombat = new HashSet<>();
+        this.memAttachedThisTurn = new HashSet<>();
+        this.memAnimatedThisTurn = new HashSet<>();
+        this.memBouncedThisTurn = new HashSet<>();
+        this.memActivatedThisTurn = new HashSet<>();
+        this.memTrickAttackers = new HashSet<>();
+        this.memChosenFogEffect = new HashSet<>();
+        this.memMarkedToAvoidReentry = new HashSet<>();
+        this.memHeldManaSourcesForNextSpell = new HashSet<>();
+        this.memPaysTapCost = new HashSet<>();
+        this.memPaysSacCost = new HashSet<>();
+        this.memRevealedCards = new HashSet<>();
     }
 
     private Set<Card> getMemorySet(MemorySet set) {
-        return memoryMap.get().computeIfAbsent(set, value -> Sets.newConcurrentHashSet());
+        switch (set) {
+            case MANDATORY_ATTACKERS:
+                return memMandatoryAttackers;
+            case TRICK_ATTACKERS:
+                return memTrickAttackers;
+            case HELD_MANA_SOURCES_FOR_MAIN2:
+                return memHeldManaSources;
+            case HELD_MANA_SOURCES_FOR_DECLBLK:
+                return memHeldManaSourcesForCombat;
+            case HELD_MANA_SOURCES_FOR_ENEMY_DECLBLK:
+                return memHeldManaSourcesForEnemyCombat;
+            case HELD_MANA_SOURCES_FOR_NEXT_SPELL:
+                return memHeldManaSourcesForNextSpell;
+            case ATTACHED_THIS_TURN:
+                return memAttachedThisTurn;
+            case ANIMATED_THIS_TURN:
+                return memAnimatedThisTurn;
+            case BOUNCED_THIS_TURN:
+                return memBouncedThisTurn;
+            case ACTIVATED_THIS_TURN:
+                return memActivatedThisTurn;
+            case CHOSEN_FOG_EFFECT:
+                return memChosenFogEffect;
+            case MARKED_TO_AVOID_REENTRY:
+                return memMarkedToAvoidReentry;
+            case PAYS_TAP_COST:
+                return memPaysTapCost;
+            case PAYS_SAC_COST:
+                return memPaysSacCost;
+            case REVEALED_CARDS:
+                return memRevealedCards;
+            default:
+                return null;
+        }
     }
 
     /**
@@ -87,7 +145,10 @@ public class AiCardMemory {
         if (c == null) {
             return false;
         }
-        return getMemorySet(set).contains(c);
+
+        Set<Card> memorySet = getMemorySet(set);
+
+        return memorySet != null && memorySet.contains(c);
     }
 
     /**
@@ -99,7 +160,17 @@ public class AiCardMemory {
      * @return true, if at least one card with the given name is remembered in the given memory set
      */
     public boolean isRememberedCardByName(String cardName, MemorySet set) {
-        return getMemorySet(set).stream().anyMatch(c -> c.getName().equals(cardName));
+        Set<Card> memorySet = getMemorySet(set);
+
+        if (memorySet != null) {
+            for (Card c : memorySet) {
+                if (c.getName().equals(cardName)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
     }
 
     /**
@@ -113,7 +184,17 @@ public class AiCardMemory {
      * @return true, if at least one card with the given name is remembered in the given memory set
      */
     public boolean isRememberedCardByName(String cardName, MemorySet set, Player owner) {
-        return getMemorySet(set).stream().anyMatch(c -> c.getName().equals(cardName) && c.getOwner().equals(owner));
+        Set<Card> memorySet = getMemorySet(set);
+
+        if (memorySet != null) {
+            for (Card c : memorySet) {
+                if (c.getName().equals(cardName) && c.getOwner().equals(owner)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
     }
 
     /**
@@ -126,7 +207,14 @@ public class AiCardMemory {
     public boolean rememberCard(Card c, MemorySet set) {
         if (c == null)
             return false;
-        return getMemorySet(set).add(c);
+
+        Set<Card> memorySet = getMemorySet(set);
+
+        if (memorySet != null) {
+            memorySet.add(c);
+        }
+
+        return true;
     }
 
     /**
@@ -143,7 +231,14 @@ public class AiCardMemory {
         if (!isRememberedCard(c, set)) {
             return false;
         }
-        return getMemorySet(set).remove(c);
+
+        Set<Card> memorySet = getMemorySet(set);
+
+        if (memorySet != null) {
+            memorySet.remove(c);
+        }
+
+        return true;
     }
 
     /**
@@ -154,11 +249,16 @@ public class AiCardMemory {
      * @return true, if at least one card with the given name was previously remembered in the given memory set and was successfully forgotten
      */
     public boolean forgetAnyCardWithName(String cardName, MemorySet set) {
-        for (Card c : getMemorySet(set)) {
-            if (c.getName().equals(cardName)) {
-                return forgetCard(c, set);
+        Set<Card> memorySet = getMemorySet(set);
+
+        if (memorySet != null) {
+            for (Card c : memorySet) {
+                if (c.getName().equals(cardName)) {
+                    return forgetCard(c, set);
+                }
             }
         }
+        
         return false;
     }
 
@@ -171,11 +271,16 @@ public class AiCardMemory {
      * @return true, if at least one card with the given name was previously remembered in the given memory set and was successfully forgotten
      */
     public boolean forgetAnyCardWithName(String cardName, MemorySet set, Player owner) {
-        for (Card c : getMemorySet(set)) {
-            if (c.getName().equals(cardName) && c.getOwner().equals(owner)) {
-                return forgetCard(c, set);
+        Set<Card> memorySet = getMemorySet(set);
+
+        if (memorySet != null) {
+            for (Card c : memorySet) {
+                if (c.getName().equals(cardName) && c.getOwner().equals(owner)) {
+                    return forgetCard(c, set);
+                }
             }
         }
+
         return false;
     }
 
@@ -269,4 +374,4 @@ public class AiCardMemory {
     public static boolean isMemorySetEmpty(AiController aic, MemorySet set) {
         return aic.getCardMemory().isMemorySetEmpty(set);
     }
-}
+}

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

@@ -1,5 +1,6 @@
 package forge.ai;
 
+import com.google.common.base.Predicates;
 import com.google.common.collect.Lists;
 
 import forge.ai.AiCardMemory.MemorySet;
@@ -29,15 +30,12 @@ public class AiCostDecision extends CostDecisionMakerBase {
     private final CardCollection tapped;
 
     public AiCostDecision(Player ai0, SpellAbility sa, final boolean effect) {
-        this(ai0, sa, effect, false);
-    }
-    public AiCostDecision(Player ai0, SpellAbility sa, final boolean effect, final boolean payMana) {
         super(ai0, effect, sa, sa.getHostCard());
 
         discarded = new CardCollection();
         tapped = new CardCollection();
         Set<Card> tappedForMana = AiCardMemory.getMemorySet(ai0, MemorySet.PAYS_TAP_COST);
-        if (!payMana && tappedForMana != null) {
+        if (tappedForMana != null) {
             tapped.addAll(tappedForMana);
         }
     }
@@ -49,14 +47,6 @@ public class AiCostDecision extends CostDecisionMakerBase {
         return PaymentDecision.number(c);
     }
 
-    @Override
-    public PaymentDecision visit(CostBehold cost) {
-        final String type = cost.getType();
-        CardCollectionView hand = player.getCardsIn(cost.getRevealFrom());
-        hand = CardLists.getValidCards(hand, type.split(";"), player, source, ability);
-        return hand.isEmpty() ? null : PaymentDecision.card(getBestCreatureAI(hand));
-    }
-
     @Override
     public PaymentDecision visit(CostChooseColor cost) {
         int c = cost.getAbilityAmount(ability);
@@ -67,7 +57,8 @@ public class AiCostDecision extends CostDecisionMakerBase {
 
     @Override
     public PaymentDecision visit(CostChooseCreatureType cost) {
-        String choice = player.getController().chooseSomeType("Creature", ability, CardType.getAllCreatureTypes());
+        String choice = player.getController().chooseSomeType("Creature", ability, CardType.getAllCreatureTypes(),
+                Lists.newArrayList());
         return PaymentDecision.type(choice);
     }
 
@@ -113,20 +104,20 @@ public class AiCostDecision extends CostDecisionMakerBase {
                 randomSubset = ability.getActivatingPlayer().getController().orderMoveToZoneList(randomSubset, ZoneType.Graveyard, ability);
             }
             return PaymentDecision.card(randomSubset);
-        } else if (type.contains("+WithDifferentNames")) {
+        } else if (type.equals("DifferentNames")) {
             CardCollection differentNames = new CardCollection();
             CardCollection discardMe = CardLists.filter(hand, CardPredicates.hasSVar("DiscardMe"));
             while (c > 0) {
                 Card chosen;
                 if (!discardMe.isEmpty()) {
                     chosen = Aggregates.random(discardMe);
-                    discardMe = CardLists.filter(discardMe, CardPredicates.sharesNameWith(chosen).negate());
+                    discardMe = CardLists.filter(discardMe, Predicates.not(CardPredicates.sharesNameWith(chosen)));
                 } else {
                     final Card worst = ComputerUtilCard.getWorstAI(hand);
                     chosen = worst != null ? worst : Aggregates.random(hand);
                 }
                 differentNames.add(chosen);
-                hand = CardLists.filter(hand, CardPredicates.sharesNameWith(chosen).negate());
+                hand = CardLists.filter(hand, Predicates.not(CardPredicates.sharesNameWith(chosen)));
                 c--;
             }
             return PaymentDecision.card(differentNames);
@@ -566,7 +557,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                 int thisRemove = Math.min(prefCard.getCounters(cType), stillToRemove);
                 if (thisRemove > 0) {
                     removed += thisRemove;
-                    table.put(null, prefCard, cType, thisRemove);
+                    table.put(null, prefCard, CounterType.get(cType), thisRemove);
                 }
             }
         }
@@ -576,7 +567,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
     @Override
     public PaymentDecision visit(CostRemoveAnyCounter cost) {
         final int c = cost.getAbilityAmount(ability);
-        final Card originalHost = ObjectUtils.getIfNull(ability.getOriginalHost(), source);
+        final Card originalHost = ObjectUtils.defaultIfNull(ability.getOriginalHost(), source);
 
         if (c <= 0) {
             return null;
@@ -719,7 +710,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
                 int over = Math.min(crd.getCounters(CounterEnumType.QUEST) - e, c - toRemove);
                 if (over > 0) {
                     toRemove += over;
-                    table.put(null, crd, CounterEnumType.QUEST, over);
+                    table.put(null, crd, CounterType.get(CounterEnumType.QUEST), over);
                 }
             }
         }
@@ -770,12 +761,6 @@ public class AiCostDecision extends CostDecisionMakerBase {
     public PaymentDecision visit(CostRemoveCounter cost) {
         final String amount = cost.getAmount();
         final String type = cost.getType();
-        final GameEntityCounterTable counterTable = new GameEntityCounterTable();
-
-        // TODO Help AI filter card with most useless counters and put those counters in countertable for things like
-        //  Moxite Refinery, similar to CostRemoveAnyCounter
-        //  Probably a lot of that decision making can be re-used or pulled out for both PaymentDecisions to use
-        if (cost.counter == null) return null;
 
         int c;
 
@@ -804,8 +789,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
             }
             for (Card card : typeList) {
                 if (card.getCounters(cost.counter) >= c) {
-                    counterTable.put(null, card, cost.counter, c);
-                    return PaymentDecision.counters(counterTable);
+                    return PaymentDecision.card(card, c);
                 }
             }
             return null;
@@ -816,8 +800,7 @@ public class AiCostDecision extends CostDecisionMakerBase {
             return null;
         }
 
-        counterTable.put(null, source, cost.counter, c);
-        return PaymentDecision.counters(counterTable);
+        return PaymentDecision.card(source, c);
     }
 
     @Override

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

@@ -1,52 +1,21 @@
 package forge.ai;
 
 public enum AiPlayDecision {
-    // Play decision reasons
-    WillPlay,
-    MandatoryPlay,
-    PlayToEmptyHand,
-    ImpactCombat,
-    ResponseToStackResolve,
-    AddBoardPresence,
-    Removal,
-    Tempo,
-    CardAdvantage,
-
-    // Play later decisions
-    WaitForCombat,
-    WaitForMain2,
-    WaitForEndOfTurn,
-    StackNotEmpty,
-    AnotherTime,
-
-    // Don't play decision reasons
+    WillPlay, 
     CantPlaySa,
     CantPlayAi,
     CantAfford,
     CantAffordX,
-    DoesntImpactCombat,
-    DoesntImpactGame,
-    MissingLogic,
+    WaitForMain2,
+    AnotherTime,
     MissingNeededCards,
-    TimingRestrictions,
-    MissingPhaseRestrictions,
-    ConditionsNotMet,
     NeedsToPlayCriteriaNotMet,
-    StopRunawayActivations,
     TargetingFailed,
     CostNotAcceptable,
-    LifeInDanger,
     WouldDestroyLegend,
     WouldDestroyOtherPlaneswalker,
     WouldBecomeZeroToughnessCreature,
     WouldDestroyWorldEnchantment,
     BadEtbEffects,
-    CurseEffects;
-
-    public boolean willingToPlay() {
-        return switch (this) {
-            case WillPlay, MandatoryPlay, PlayToEmptyHand, AddBoardPresence, ImpactCombat, ResponseToStackResolve, Removal, Tempo, CardAdvantage -> true;
-            default -> false;
-        };
-    }
+    CurseEffects
 }

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

@@ -17,18 +17,19 @@
  */
 package forge.ai;
 
-import forge.LobbyPlayer;
-import forge.util.Aggregates;
-import forge.util.FileUtil;
-import forge.util.TextUtil;
-import org.apache.commons.lang3.ArrayUtils;
-
 import java.io.File;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import org.apache.commons.lang3.ArrayUtils;
+
+import forge.LobbyPlayer;
+import forge.util.Aggregates;
+import forge.util.FileUtil;
+import forge.util.TextUtil;
+
 /**
  * Holds default AI personality profile values in an enum.
  * Loads profile from the given text file when setProfile is called.

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

@@ -21,7 +21,6 @@ import forge.game.cost.CostRemoveCounter;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
-import forge.game.spellability.OptionalCost;
 import forge.game.spellability.OptionalCostValue;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityStackInstance;
@@ -90,7 +89,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));
         }
 
@@ -117,16 +116,12 @@ 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;
             List<OptionalCostValue> list = GameActionUtil.getOptionalCostValues(sa);
             if (!list.isEmpty()) {
-                // still add base spell in case of Promise Gift
-                if (list.stream().anyMatch(ocv -> ocv.getType().equals(OptionalCost.PromiseGift))) {
-                    result.add(sa);
-                }
                 list = player.getController().chooseOptionalCosts(sa, list);
                 if (!list.isEmpty()) {
                     choseOptCost = true;
@@ -345,10 +340,6 @@ public class ComputerUtilAbility {
                 if (source.hasSVar("AIPriorityModifier")) {
                     p += Integer.parseInt(source.getSVar("AIPriorityModifier"));
                 }
-                // try to use it before it's gone
-                if (source.isInPlay() && source.hasSVar("EndOfTurnLeavePlay")) {
-                    p += 1;
-                }
                 if (ComputerUtilCard.isCardRemAIDeck(sa.getOriginalHost() != null ? sa.getOriginalHost() : source)) {
                     p -= 10;
                 }

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

@@ -2,24 +2,21 @@ package forge.ai;
 
 import java.util.*;
 import java.util.Map.Entry;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.stream.Stream;
 
-import forge.StaticData;
+import com.google.common.base.Function;
 import forge.ai.simulation.GameStateEvaluator;
 import forge.card.mana.ManaCost;
 import forge.game.card.*;
-import forge.util.*;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.MutablePair;
 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 com.google.common.collect.Maps;
 
-import forge.card.CardRules;
 import forge.card.CardStateName;
 import forge.card.CardType;
 import forge.card.ColorSet;
@@ -48,11 +45,14 @@ import forge.game.replacement.ReplacementEffect;
 import forge.game.replacement.ReplacementLayer;
 import forge.game.spellability.SpellAbility;
 import forge.game.staticability.StaticAbility;
-import forge.game.staticability.StaticAbilityMode;
 import forge.game.trigger.Trigger;
 import forge.game.zone.MagicStack;
 import forge.game.zone.ZoneType;
 import forge.item.PaperCard;
+import forge.util.Aggregates;
+import forge.util.Expressions;
+import forge.util.MyRandom;
+import forge.util.TextUtil;
 
 public class ComputerUtilCard {
     public static Card getMostExpensivePermanentAI(final CardCollectionView list, final SpellAbility spell, final boolean targeted) {
@@ -86,11 +86,12 @@ public class ComputerUtilCard {
      * @return a {@link forge.game.card.Card} object.
      */
     public static Card getBestArtifactAI(final List<Card> list) {
+        List<Card> all = CardLists.filter(list, CardPredicates.Presets.ARTIFACTS);
+        if (all.size() == 0) {
+            return null;
+        }
         // get biggest Artifact
-        return list.stream()
-                .filter(CardPredicates.ARTIFACTS)
-                .max(Comparator.comparing(Card::getCMC))
-                .orElse(null);
+        return Aggregates.itemWithMax(all, Card::getCMC);
     }
 
     /**
@@ -100,11 +101,12 @@ public class ComputerUtilCard {
      * @return best Planeswalker
      */
     public static Card getBestPlaneswalkerAI(final List<Card> list) {
+        List<Card> all = CardLists.filter(list, CardPredicates.Presets.PLANESWALKERS);
+        if (all.isEmpty()) {
+            return null;
+        }
         // no AI logic, just return most expensive
-        return list.stream()
-                .filter(CardPredicates.PLANESWALKERS)
-                .max(Comparator.comparing(Card::getCMC))
-                .orElse(null);
+        return Aggregates.itemWithMax(all, Card::getCMC);
     }
 
     /**
@@ -114,11 +116,12 @@ public class ComputerUtilCard {
      * @return best Planeswalker
      */
     public static Card getWorstPlaneswalkerAI(final List<Card> list) {
+        List<Card> all = CardLists.filter(list, CardPredicates.Presets.PLANESWALKERS);
+        if (all.isEmpty()) {
+            return null;
+        }
         // no AI logic, just return least expensive
-        return list.stream()
-                .filter(CardPredicates.PLANESWALKERS)
-                .min(Comparator.comparing(Card::getCMC))
-                .orElse(null);
+        return Aggregates.itemWithMin(all, Card::getCMC);
     }
 
     public static Card getBestPlaneswalkerToDamage(final List<Card> pws) {
@@ -184,13 +187,13 @@ public class ComputerUtilCard {
      * @return a {@link forge.game.card.Card} object.
      */
     public static Card getBestEnchantmentAI(final List<Card> list, final SpellAbility spell, final boolean targeted) {
-        Stream<Card> cardStream = list.stream().filter(CardPredicates.ENCHANTMENTS);
+        List<Card> all = CardLists.filter(list, CardPredicates.Presets.ENCHANTMENTS);
         if (targeted) {
-            cardStream = cardStream.filter(c -> c.canBeTargetedBy(spell));
+            all = CardLists.filter(all, c -> c.canBeTargetedBy(spell));
         }
 
         // get biggest Enchantment
-        return cardStream.max(Comparator.comparing(Card::getCMC)).orElse(null);
+        return Aggregates.itemWithMax(all, Card::getCMC);
     }
 
     /**
@@ -202,30 +205,30 @@ public class ComputerUtilCard {
      * @return a {@link forge.game.card.Card} object.
      */
     public static Card getBestLandAI(final Iterable<Card> list) {
-        final List<Card> land = CardLists.filter(list, CardPredicates.LANDS);
+        final List<Card> land = CardLists.filter(list, CardPredicates.Presets.LANDS);
         if (land.isEmpty()) {
             return null;
         }
 
         // prefer to target non basic lands
-        final List<Card> nbLand = CardLists.filter(land, CardPredicates.NONBASIC_LANDS);
+        final List<Card> nbLand = CardLists.filter(land, Predicates.not(CardPredicates.Presets.BASIC_LANDS));
 
         if (!nbLand.isEmpty()) {
             // TODO - Improve ranking various non-basic lands depending on context
 
             // Urza's Mine/Tower/Power Plant
             final CardCollectionView aiAvailable = nbLand.get(0).getController().getCardsIn(Arrays.asList(ZoneType.Battlefield, ZoneType.Hand));
-            if (IterableUtil.any(list, CardPredicates.nameEquals("Urza's Mine"))) {
+            if (Iterables.any(list, CardPredicates.nameEquals("Urza's Mine"))) {
                 if (CardLists.filter(aiAvailable, CardPredicates.nameEquals("Urza's Mine")).isEmpty()) {
                     return CardLists.filter(nbLand, CardPredicates.nameEquals("Urza's Mine")).getFirst();
                 }
             }
-            if (IterableUtil.any(list, CardPredicates.nameEquals("Urza's Tower"))) {
+            if (Iterables.any(list, CardPredicates.nameEquals("Urza's Tower"))) {
                 if (CardLists.filter(aiAvailable, CardPredicates.nameEquals("Urza's Tower")).isEmpty()) {
                     return CardLists.filter(nbLand, CardPredicates.nameEquals("Urza's Tower")).getFirst();
                 }
             }
-            if (IterableUtil.any(list, CardPredicates.nameEquals("Urza's Power Plant"))) {
+            if (Iterables.any(list, CardPredicates.nameEquals("Urza's Power Plant"))) {
                 if (CardLists.filter(aiAvailable, CardPredicates.nameEquals("Urza's Power Plant")).isEmpty()) {
                     return CardLists.filter(nbLand, CardPredicates.nameEquals("Urza's Power Plant")).getFirst();
                 }
@@ -247,16 +250,17 @@ public class ComputerUtilCard {
         }
         if (iminBL == Integer.MAX_VALUE) {
             // All basic lands have no basic land type. Just return something
-            return land.stream().filter(CardPredicates.UNTAPPED).findFirst().orElse(land.get(0));
+            return Iterables.find(land, CardPredicates.Presets.UNTAPPED, land.get(0));
         }
 
         final List<Card> bLand = CardLists.getType(land, sminBL);
 
-        return bLand.stream()
-                .filter(CardPredicates.UNTAPPED)
-                .findFirst()
-                // TODO potentially risky if simulation mode currently able to reach this from triggers
-                .orElseGet(() -> Aggregates.random(bLand)); // random tapped land of least represented type
+        for (Card ut : Iterables.filter(bLand, CardPredicates.Presets.UNTAPPED)) {
+            return ut;
+        }
+
+        // TODO potentially risky if simulation mode currently able to reach this from triggers
+        return Aggregates.random(bLand); // random tapped land of least represented type
     }
 
     /**
@@ -358,10 +362,10 @@ public class ComputerUtilCard {
      */
     public static Card getBestAI(final Iterable<Card> list) {
         // Get Best will filter by appropriate getBest list if ALL of the list is of that type
-        if (IterableUtil.all(list, CardPredicates.CREATURES)) {
+        if (Iterables.all(list, CardPredicates.Presets.CREATURES)) {
             return getBestCreatureAI(list);
         }
-        if (IterableUtil.all(list, CardPredicates.LANDS)) {
+        if (Iterables.all(list, CardPredicates.Presets.LANDS)) {
             return getBestLandAI(list);
         }
         // TODO - Once we get an EvaluatePermanent this should call getBestPermanent()
@@ -378,7 +382,7 @@ public class ComputerUtilCard {
         if (Iterables.size(list) == 1) {
             return Iterables.get(list, 0);
         }
-        return Aggregates.itemWithMax(IterableUtil.filter(list, CardPredicates.CREATURES), ComputerUtilCard.creatureEvaluator);
+        return Aggregates.itemWithMax(Iterables.filter(list, CardPredicates.Presets.CREATURES), ComputerUtilCard.creatureEvaluator);
     }
 
     /**
@@ -391,7 +395,7 @@ public class ComputerUtilCard {
         if (Iterables.size(list) == 1) {
             return Iterables.get(list, 0);
         }
-        return Aggregates.itemWithMax(IterableUtil.filter(list, Card::hasPlayableLandFace), ComputerUtilCard.landEvaluator);
+        return Aggregates.itemWithMax(Iterables.filter(list, Card::hasPlayableLandFace), ComputerUtilCard.landEvaluator);
     }
 
     /**
@@ -406,7 +410,7 @@ public class ComputerUtilCard {
         if (Iterables.size(list) == 1) {
             return Iterables.get(list, 0);
         }
-        return Aggregates.itemWithMin(IterableUtil.filter(list, CardPredicates.CREATURES), ComputerUtilCard.creatureEvaluator);
+        return Aggregates.itemWithMin(Iterables.filter(list, CardPredicates.Presets.CREATURES), ComputerUtilCard.creatureEvaluator);
     }
 
     // This selection rates tokens higher
@@ -427,7 +431,7 @@ public class ComputerUtilCard {
         Card biggest = null;
         int biggestvalue = -1;
 
-        for (Card card : CardLists.filter(list, CardPredicates.CREATURES)) {
+        for (Card card : CardLists.filter(list, CardPredicates.Presets.CREATURES)) {
             int newvalue = evaluateCreature(card);
             newvalue += card.isToken() ? tokenBonus : 0; // raise the value of tokens
 
@@ -480,40 +484,40 @@ public class ComputerUtilCard {
             return null;
         }
 
-        final boolean hasEnchantmants = IterableUtil.any(list, CardPredicates.ENCHANTMENTS);
+        final boolean hasEnchantmants = Iterables.any(list, CardPredicates.Presets.ENCHANTMENTS);
         if (biasEnch && hasEnchantmants) {
-            return getCheapestPermanentAI(CardLists.filter(list, CardPredicates.ENCHANTMENTS), null, false);
+            return getCheapestPermanentAI(CardLists.filter(list, CardPredicates.Presets.ENCHANTMENTS), null, false);
         }
 
-        final boolean hasArtifacts = IterableUtil.any(list, CardPredicates.ARTIFACTS);
+        final boolean hasArtifacts = Iterables.any(list, CardPredicates.Presets.ARTIFACTS);
         if (biasArt && hasArtifacts) {
-            return getCheapestPermanentAI(CardLists.filter(list, CardPredicates.ARTIFACTS), null, false);
+            return getCheapestPermanentAI(CardLists.filter(list, CardPredicates.Presets.ARTIFACTS), null, false);
         }
 
-        if (biasLand && IterableUtil.any(list, CardPredicates.LANDS)) {
-            return getWorstLand(CardLists.filter(list, CardPredicates.LANDS));
+        if (biasLand && Iterables.any(list, CardPredicates.Presets.LANDS)) {
+            return getWorstLand(CardLists.filter(list, CardPredicates.Presets.LANDS));
         }
 
-        final boolean hasCreatures = IterableUtil.any(list, CardPredicates.CREATURES);
+        final boolean hasCreatures = Iterables.any(list, CardPredicates.Presets.CREATURES);
         if (biasCreature && hasCreatures) {
-            return getWorstCreatureAI(CardLists.filter(list, CardPredicates.CREATURES));
+            return getWorstCreatureAI(CardLists.filter(list, CardPredicates.Presets.CREATURES));
         }
 
-        List<Card> lands = CardLists.filter(list, CardPredicates.LANDS);
+        List<Card> lands = CardLists.filter(list, CardPredicates.Presets.LANDS);
         if (lands.size() > 6) {
             return getWorstLand(lands);
         }
 
         if (hasEnchantmants || hasArtifacts) {
-            final List<Card> ae = CardLists.filter(list,
-                    (CardPredicates.ARTIFACTS.or(CardPredicates.ENCHANTMENTS))
-                    .and(card -> !card.hasSVar("DoNotDiscardIfAble"))
-            );
+            final List<Card> ae = CardLists.filter(list, Predicates.and(
+                    Predicates.or(CardPredicates.Presets.ARTIFACTS, CardPredicates.Presets.ENCHANTMENTS),
+                    card -> !card.hasSVar("DoNotDiscardIfAble")
+            ));
             return getCheapestPermanentAI(ae, null, false);
         }
 
         if (hasCreatures) {
-            return getWorstCreatureAI(CardLists.filter(list, CardPredicates.CREATURES));
+            return getWorstCreatureAI(CardLists.filter(list, CardPredicates.Presets.CREATURES));
         }
 
         // Planeswalkers fall through to here, lands will fall through if there aren't very many
@@ -522,7 +526,8 @@ public class ComputerUtilCard {
 
     public static final Card getCheapestSpellAI(final Iterable<Card> list) {
         if (!Iterables.isEmpty(list)) {
-            CardCollection cc = CardLists.filter(list, CardPredicates.INSTANTS_AND_SORCERIES);
+            CardCollection cc = CardLists.filter(list,
+                    Predicates.or(CardPredicates.isType("Instant"), CardPredicates.isType("Sorcery")));
 
             if (cc.isEmpty()) {
                 return null;
@@ -692,8 +697,6 @@ public class ComputerUtilCard {
     public static boolean canBeBlockedProfitably(final Player ai, Card attacker, boolean checkingOther) {
         AiBlockController aiBlk = new AiBlockController(ai, checkingOther);
         Combat combat = new Combat(ai);
-        // avoid removing original attacker
-        attacker.setCombatLKI(null);
         combat.addAttacker(attacker, ai);
         final List<Card> attackers = Lists.newArrayList(attacker);
         aiBlk.assignBlockersGivenAttackers(combat, attackers);
@@ -711,7 +714,7 @@ public class ComputerUtilCard {
                     if (!ComputerUtilCost.canPayCost(sa, opp, sa.isTrigger())) {
                         continue;
                     }
-                    sa.setActivatingPlayer(opp);
+                    sa.setActivatingPlayer(opp, true);
                     if (sa.canTarget(card)) {
                         continue;
                     }
@@ -788,8 +791,9 @@ public class ComputerUtilCard {
     public static String getMostProminentType(final CardCollectionView list, final Collection<String> valid) {
         return getMostProminentType(list, valid, true);
     }
+
     public static String getMostProminentType(final CardCollectionView list, final Collection<String> valid, boolean includeTokens) {
-        if (list.isEmpty()) {
+        if (list.size() == 0) {
             return "";
         }
 
@@ -830,35 +834,51 @@ public class ComputerUtilCard {
 
             //also take into account abilities that generate tokens
             if (includeTokens) {
-                if (c.getRules() != null) {
-                    for (String token : c.getRules().getTokens()) {
-                        CardRules tokenCR = StaticData.instance().getAllTokens().getToken(token).getRules();
-                        if (tokenCR == null)
-                            continue;
-                        for (String type : tokenCR.getType().getCreatureTypes()) {
-                            Integer count = typesInDeck.getOrDefault(type, 0);
-                            typesInDeck.put(type, count + 1);
+                for (SpellAbility sa : c.getAllSpellAbilities()) {
+                    if (sa.getApi() != ApiType.Token) {
+                        continue;
+                    }
+                    if (sa.hasParam("TokenTypes")) {
+                        for (String var : sa.getParam("TokenTypes").split(",")) {
+                            if (!CardType.isACreatureType(var)) {
+                                continue;
+                            }
+                            Integer count = typesInDeck.getOrDefault(var, 0);
+                            typesInDeck.put(var, count + weight);
+                        }
+                    }
+                }
+                // same for Trigger that does make Tokens
+                for (Trigger t : c.getTriggers()) {
+                    SpellAbility sa = t.ensureAbility();
+                    if (sa != null) {
+                        if (sa.getApi() != ApiType.Token || !sa.hasParam("TokenTypes")) {
+                            continue;
+                        }
+                        for (String var : sa.getParam("TokenTypes").split(",")) {
+                            if (!CardType.isACreatureType(var)) {
+                                continue;
+                            }
+                            Integer count = typesInDeck.getOrDefault(var, 0);
+                            typesInDeck.put(var, count + weight);
                         }
                     }
                 }
-
                 // special rule for Fabricate and Servo
                 if (c.hasKeyword(Keyword.FABRICATE)) {
                     Integer count = typesInDeck.getOrDefault("Servo", 0);
                     typesInDeck.put("Servo", count + weight);
                 }
             }
-        }
+        } // for
 
         int max = 0;
         String maxType = "";
 
-        // Iterate through typesInDeck and consider only valid types
         for (final Entry<String, Integer> entry : typesInDeck.entrySet()) {
             final String type = entry.getKey();
 
-            // consider the types that are in the valid list
-            if ((valid.isEmpty() || valid.contains(type)) && max < entry.getValue()) {
+            if (max < entry.getValue()) {
                 max = entry.getValue();
                 maxType = type;
             }
@@ -919,14 +939,14 @@ public class ComputerUtilCard {
         return MagicColor.Constant.WHITE; // no difference, there was no prominent color
     }
 
-    public static String getMostProminentColor(final CardCollectionView list, final Iterable<String> restrictedToColors) {
+    public static String getMostProminentColor(final CardCollectionView list, final List<String> restrictedToColors) {
         byte colors = CardFactoryUtil.getMostProminentColorsFromList(list, restrictedToColors);
         for (byte c : MagicColor.WUBRG) {
             if ((colors & c) != 0) {
                 return MagicColor.toLongString(c);
             }
         }
-        return Iterables.get(restrictedToColors, 0); // no difference, there was no prominent color
+        return restrictedToColors.get(0); // no difference, there was no prominent color
     }
 
     public static List<String> getColorByProminence(final List<Card> list) {
@@ -987,7 +1007,7 @@ public class ComputerUtilCard {
             } else if (logic.equals("MostProminentHumanCreatures")) {
                 CardCollectionView list = opp.getCreaturesInPlay();
                 if (list.isEmpty()) {
-                    list = CardLists.filter(CardLists.filterControlledBy(game.getCardsInGame(), opp), CardPredicates.CREATURES);
+                    list = CardLists.filter(CardLists.filterControlledBy(game.getCardsInGame(), opp), CardPredicates.Presets.CREATURES);
                 }
                 chosen.add(getMostProminentColor(list, colorChoices));
             } else if (logic.equals("MostProminentComputerControls")) {
@@ -1042,7 +1062,7 @@ public class ComputerUtilCard {
                     String devotionCode = "Count$Devotion." + MagicColor.toLongString(c);
 
                     int devotion = AbilityUtils.calculateAmount(sa.getHostCard(), devotionCode, sa);
-                    if (devotion > curDevotion && hand.anyMatch(CardPredicates.isColor(c))) {
+                    if (devotion > curDevotion && Iterables.any(hand, CardPredicates.isColor(c))) {
                         curDevotion = devotion;
                         chosenColor = MagicColor.toLongString(c);
                     }
@@ -1214,7 +1234,8 @@ public class ComputerUtilCard {
                 // if this thing is both owned and controlled by an opponent and it has a continuous ability,
                 // assume it either benefits the player or disrupts the opponent
                 for (final StaticAbility stAb : c.getStaticAbilities()) {
-                    if (stAb.checkMode(StaticAbilityMode.Continuous) && stAb.isIntrinsic()) {
+                    final Map<String, String> params = stAb.getMapParams();
+                    if (params.get("Mode").equals("Continuous") && stAb.isIntrinsic()) {
                         priority = true;
                         break;
                     }
@@ -1245,16 +1266,17 @@ public class ComputerUtilCard {
             }
         } else {
             for (final StaticAbility stAb : c.getStaticAbilities()) {
+                final Map<String, String> params = stAb.getMapParams();
                 //continuous buffs
-                if (stAb.checkMode(StaticAbilityMode.Continuous) && "Creature.YouCtrl".equals(stAb.getParam("Affected"))) {
+                if (params.get("Mode").equals("Continuous") && "Creature.YouCtrl".equals(params.get("Affected"))) {
                     int bonusPT = 0;
-                    if (stAb.hasParam("AddPower")) {
-                        bonusPT += AbilityUtils.calculateAmount(c, stAb.getParam("AddPower"), stAb);
+                    if (params.containsKey("AddPower")) {
+                        bonusPT += AbilityUtils.calculateAmount(c, params.get("AddPower"), stAb);
                     }
-                    if (stAb.hasParam("AddToughness")) {
-                        bonusPT += AbilityUtils.calculateAmount(c, stAb.getParam("AddPower"), stAb);
+                    if (params.containsKey("AddToughness")) {
+                        bonusPT += AbilityUtils.calculateAmount(c, params.get("AddPower"), stAb);
                     }
-                    String kws = stAb.getParam("AddKeyword");
+                    String kws = params.get("AddKeyword");
                     if (kws != null) {
                         bonusPT += 4 * (1 + StringUtils.countMatches(kws, "&")); //treat each added keyword as a +2/+2 for now
                     }
@@ -1405,7 +1427,7 @@ public class ComputerUtilCard {
             //1. become attacker for whatever reason
             if (!doesCreatureAttackAI(ai, c) && doesSpecifiedCreatureAttackAI(ai, pumped)) {
                 float threat = 1.0f * ComputerUtilCombat.damageIfUnblocked(pumped, opp, combat, true) / opp.getLife();
-                if (oppCreatures.stream().noneMatch(CardPredicates.possibleBlockers(pumped))) {
+                if (!Iterables.any(oppCreatures, CardPredicates.possibleBlockers(pumped))) {
                     threat *= 2;
                 }
                 if (c.getNetPower() == 0 && c == sa.getHostCard() && power > 0) {
@@ -1457,8 +1479,8 @@ public class ComputerUtilCard {
             }
 
             //3. grant evasive
-            if (oppCreatures.stream().anyMatch(CardPredicates.possibleBlockers(c))) {
-                if (oppCreatures.stream().noneMatch(CardPredicates.possibleBlockers(pumped))
+            if (Iterables.any(oppCreatures, CardPredicates.possibleBlockers(c))) {
+                if (!Iterables.any(oppCreatures, CardPredicates.possibleBlockers(pumped))
                         && doesSpecifiedCreatureAttackAI(ai, pumped)) {
                     chance += 0.5f * ComputerUtilCombat.damageIfUnblocked(pumped, opp, combat, true) / opp.getLife();
                 }
@@ -1785,7 +1807,7 @@ public class ComputerUtilCard {
             // remove old boost that might be copied
             for (final StaticAbility stAb : c.getStaticAbilities()) {
                 vCard.removePTBoost(c.getLayerTimestamp(), stAb.getId());
-                if (!stAb.checkMode(StaticAbilityMode.Continuous)) {
+                if (!stAb.checkMode("Continuous")) {
                     continue;
                 }
                 if (!stAb.hasParam("Affected")) {
@@ -1819,18 +1841,18 @@ public class ComputerUtilCard {
      * @param sa Pump* or CounterPut*
      * @return
      */
-    public static AiAbilityDecision canPumpAgainstRemoval(Player ai, SpellAbility sa) {
+    public static boolean canPumpAgainstRemoval(Player ai, SpellAbility sa) {
         final List<GameObject> objects = ComputerUtil.predictThreatenedObjects(sa.getActivatingPlayer(), sa, true);
 
         if (!sa.usesTargeting()) {
             final List<Card> cards = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa);
             for (final Card card : cards) {
                 if (objects.contains(card)) {
-                    return new AiAbilityDecision(100, AiPlayDecision.ResponseToStackResolve);
+                    return true;
                 }
             }
             // For pumps without targeting restrictions, just return immediately until this is fleshed out.
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
         }
 
         CardCollection threatenedTargets = CardLists.getTargetableCards(ai.getCardsIn(ZoneType.Battlefield), sa);
@@ -1849,11 +1871,11 @@ public class ComputerUtilCard {
             }
             if (!sa.isTargetNumberValid()) {
                 sa.resetTargets();
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
-            return new AiAbilityDecision(100, AiPlayDecision.ResponseToStackResolve);
+            return true;
         }
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return false;
     }
 
     public static boolean isUselessCreature(Player ai, Card c) {
@@ -1863,7 +1885,7 @@ public class ComputerUtilCard {
         if (!c.isCreature()) {
             return false;
         }
-        if (c.hasKeyword("CARDNAME can't attack or block.") || (c.isTapped() && !c.canUntap(ai, true)) || (c.getOwner() == ai && ai.getOpponents().contains(c.getController()))) {
+        if (c.hasKeyword("CARDNAME can't attack or block.") || (c.hasKeyword("CARDNAME doesn't untap during your untap step.") && c.isTapped()) || (c.getOwner() == ai && ai.getOpponents().contains(c.getController()))) {
             return true;
         }
         return false;
@@ -1927,7 +1949,7 @@ public class ComputerUtilCard {
         CardCollection aiCreats = ai.getCreaturesInPlay();
         if (temporary) {
             // Pump effects that add "CARDNAME can't attack" and similar things. Only do it if something is untapped.
-            oppCards = CardLists.filter(oppCards, CardPredicates.UNTAPPED);
+            oppCards = CardLists.filter(oppCards, CardPredicates.Presets.UNTAPPED);
         }
 
         CardCollection priorityCards = new CardCollection();
@@ -2080,7 +2102,6 @@ public class ComputerUtilCard {
         return false;
     }
 
-    // use this function to skip expensive calculations on identical cards
     public static CardCollection dedupeCards(CardCollection cc) {
         if (cc.size() <= 1) {
             return cc;
@@ -2088,7 +2109,7 @@ public class ComputerUtilCard {
         CardCollection deduped = new CardCollection();
         for (Card c : cc) {
             boolean unique = true;
-            if (c.isInZone(ZoneType.Hand) && !c.hasPerpetual()) {
+            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;

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

@@ -31,7 +31,7 @@ import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.CostPayment;
 import forge.game.keyword.Keyword;
-import forge.game.phase.PhaseType;
+import forge.game.phase.Untap;
 import forge.game.player.Player;
 import forge.game.replacement.ReplacementEffect;
 import forge.game.replacement.ReplacementLayer;
@@ -39,12 +39,10 @@ import forge.game.replacement.ReplacementType;
 import forge.game.spellability.SpellAbility;
 import forge.game.staticability.StaticAbility;
 import forge.game.staticability.StaticAbilityAssignCombatDamageAsUnblocked;
-import forge.game.staticability.StaticAbilityMode;
 import forge.game.staticability.StaticAbilityMustAttack;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
 import forge.game.zone.ZoneType;
-import forge.util.IterableUtil;
 import forge.util.MyRandom;
 import forge.util.TextUtil;
 import forge.util.collect.FCollection;
@@ -80,7 +78,7 @@ public class ComputerUtilCombat {
      */
     public static boolean canAttackNextTurn(final Card attacker) {
         final Iterable<GameEntity> defenders = CombatUtil.getAllPossibleDefenders(attacker.getController());
-        return IterableUtil.any(defenders, input -> canAttackNextTurn(attacker, input));
+        return Iterables.any(defenders, input -> canAttackNextTurn(attacker, input));
     }
 
     /**
@@ -102,7 +100,7 @@ public class ComputerUtilCombat {
             return false;
         }
 
-        if (attacker.getGame().getReplacementHandler().wouldPhaseBeSkipped(attacker.getController(), PhaseType.COMBAT_BEGIN)) {
+        if (attacker.getGame().getReplacementHandler().wouldPhaseBeSkipped(attacker.getController(), "BeginCombat")) {
             return false;
         }
 
@@ -119,7 +117,7 @@ public class ComputerUtilCombat {
         //        || (attacker.hasKeyword(Keyword.FADING) && attacker.getCounters(CounterEnumType.FADE) == 0)
         //        || attacker.hasSVar("EndOfTurnLeavePlay"));
         // The creature won't untap next turn
-        return !attacker.isTapped() || (attacker.getCounters(CounterEnumType.STUN) == 0 && attacker.canUntap(attacker.getController(), true));
+        return !attacker.isTapped() || (attacker.getCounters(CounterEnumType.STUN) == 0 && Untap.canUntap(attacker));
     }
 
     /**
@@ -177,7 +175,7 @@ public class ComputerUtilCombat {
     public static int damageIfUnblocked(final Card attacker, final GameEntity attacked, final Combat combat, boolean withoutAbilities) {
         int damage = attacker.getNetCombatDamage();
         int sum = 0;
-        if (attacked instanceof Player player && !player.canLoseLife()) {
+        if (attacked instanceof Player && !((Player) attacked).canLoseLife()) {
             return 0;
         }
 
@@ -215,10 +213,10 @@ public class ComputerUtilCombat {
         int damage = attacker.getNetCombatDamage();
         int poison = 0;
         damage += predictPowerBonusOfAttacker(attacker, null, null, false);
-        if (attacker.isInfectDamage(attacked)) {
+        if (attacker.hasKeyword(Keyword.INFECT)) {
             int pd = predictDamageTo(attacked, damage, attacker, true);
             // opponent can always order it so that he gets 0
-            if (pd == 1 && attacker.getController().getOpponents().getCardsIn(ZoneType.Battlefield).anyMatch(CardPredicates.nameEquals("Vorinclex, Monstrous Raider"))) {
+            if (pd == 1 && Iterables.any(attacker.getController().getOpponents().getCardsIn(ZoneType.Battlefield), CardPredicates.nameEquals("Vorinclex, Monstrous Raider"))) {
                 pd = 0;
             }
             poison += pd;
@@ -358,7 +356,7 @@ public class ComputerUtilCombat {
             } else if (attacker.hasKeyword(Keyword.TRAMPLE)) {
                 int trampleDamage = getAttack(attacker) - totalShieldDamage(attacker, blockers);
                 if (trampleDamage > 0) {
-                    if (attacker.isInfectDamage(ai)) {
+                    if (attacker.hasKeyword(Keyword.INFECT)) {
                         poison += trampleDamage;
                     }
                     poison += predictExtraPoisonWithDamage(attacker, ai, trampleDamage);
@@ -406,11 +404,11 @@ public class ComputerUtilCombat {
         CardCollectionView otb = ai.getCardsIn(ZoneType.Battlefield);
         // Special cases:
         // AI can't lose in combat in presence of Worship (with creatures)
-        if (otb.anyMatch(CardPredicates.nameEquals("Worship")) && !ai.getCreaturesInPlay().isEmpty()) {
+        if (Iterables.any(otb, CardPredicates.nameEquals("Worship")) && !ai.getCreaturesInPlay().isEmpty()) {
             return false;
         }
         // AI can't lose in combat in presence of Elderscale Wurm (at 7 life or more)
-        if (otb.anyMatch(CardPredicates.nameEquals("Elderscale Wurm")) && ai.getLife() >= 7) {
+        if (Iterables.any(otb, CardPredicates.nameEquals("Elderscale Wurm")) && ai.getLife() >= 7) {
             return false;
         }
 
@@ -458,11 +456,11 @@ public class ComputerUtilCombat {
             maxTreshold--;
         }
 
-        if (resultingPoison(ai, combat) > Math.max(7, ai.getPoisonCounters())) {
+        if (!ai.cantLoseForZeroOrLessLife() && lifeThatWouldRemain(ai, combat) - payment < Math.min(threshold, ai.getLife())) {
             return true;
         }
 
-        return !ai.cantLoseForZeroOrLessLife() && lifeThatWouldRemain(ai, combat) - payment < Math.min(threshold, ai.getLife());
+        return resultingPoison(ai, combat) > Math.max(7, ai.getPoisonCounters());
     }
 
     /**
@@ -501,11 +499,11 @@ public class ComputerUtilCombat {
             }
         }
 
-        if (resultingPoison(ai, combat) >= ai.getGame().getRules().getPoisonCountersToLose()) {
+        if (!ai.cantLoseForZeroOrLessLife() && lifeThatWouldRemain(ai, combat) - payment < 1) {
             return true;
         }
 
-        return !ai.cantLoseForZeroOrLessLife() && lifeThatWouldRemain(ai, combat) - payment < 1;
+        return resultingPoison(ai, combat) >= ai.getGame().getRules().getPoisonCountersToLose();
     }
 
     // This calculates the amount of damage a blockgang can deal to the attacker
@@ -901,7 +899,7 @@ public class ComputerUtilCombat {
         final CardCollectionView cardList = CardCollection.combine(game.getCardsIn(ZoneType.Battlefield), game.getCardsIn(ZoneType.Command));
         for (final Card card : cardList) {
             for (final StaticAbility stAb : card.getStaticAbilities()) {
-                if (!stAb.checkMode(StaticAbilityMode.Continuous)) {
+                if (!stAb.checkMode("Continuous")) {
                     continue;
                 }
                 if (!stAb.hasParam("Affected") || !stAb.getParam("Affected").contains("blocking")) {
@@ -974,13 +972,17 @@ public class ComputerUtilCombat {
                 continue;
             }
 
-            int pBonus = 0;
             if (ability.getApi() == ApiType.Pump) {
                 if (!ability.hasParam("NumAtt")) {
                     continue;
                 }
 
-                pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumAtt"), ability);
+                if (ComputerUtilCost.canPayCost(ability, blocker.getController(), false)) {
+                    int pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumAtt"), ability);
+                    if (pBonus > 0) {
+                        power += pBonus;
+                    }
+                }
             } else if (ability.getApi() == ApiType.PutCounter) {
                 if (!ability.hasParam("CounterType") || !ability.getParam("CounterType").equals("P1P1")) {
                     continue;
@@ -994,11 +996,12 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
-            }
-
-            if (pBonus > 0 && ComputerUtilCost.canPayCost(ability, blocker.getController(), false)) {
-                power += pBonus;
+                if (ComputerUtilCost.canPayCost(ability, blocker.getController(), false)) {
+                    int pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
+                    if (pBonus > 0) {
+                        power += pBonus;
+                    }
+                }
             }
         }
 
@@ -1102,13 +1105,17 @@ public class ComputerUtilCombat {
                 continue;
             }
 
-            int tBonus = 0;
             if (ability.getApi() == ApiType.Pump) {
                 if (!ability.hasParam("NumDef")) {
                     continue;
                 }
 
-                tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumDef"), ability);
+                if (ComputerUtilCost.canPayCost(ability, blocker.getController(), false)) {
+                    int tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumDef"), ability);
+                    if (tBonus > 0) {
+                        toughness += tBonus;
+                    }
+                }
             } else if (ability.getApi() == ApiType.PutCounter) {
                 if (!ability.hasParam("CounterType") || !ability.getParam("CounterType").equals("P1P1")) {
                     continue;
@@ -1122,11 +1129,12 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
-            }
-
-            if (tBonus > 0 && ComputerUtilCost.canPayCost(ability, blocker.getController(), false)) {
-                toughness += tBonus;
+                if (ComputerUtilCost.canPayCost(ability, blocker.getController(), false)) {
+                    int tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
+                    if (tBonus > 0) {
+                        toughness += tBonus;
+                    }
+                }
             }
         }
         return toughness;
@@ -1187,7 +1195,7 @@ public class ComputerUtilCombat {
             final CardCollectionView cardList = CardCollection.combine(game.getCardsIn(ZoneType.Battlefield), game.getCardsIn(ZoneType.Command));
             for (final Card card : cardList) {
                 for (final StaticAbility stAb : card.getStaticAbilities()) {
-                    if (!stAb.checkMode(StaticAbilityMode.Continuous)) {
+                    if (!stAb.checkMode("Continuous")) {
                         continue;
                     }
                     if (!stAb.hasParam("Affected") || !stAb.getParam("Affected").contains("attacking")) {
@@ -1235,7 +1243,7 @@ public class ComputerUtilCombat {
                 continue;
             }
 
-            sa.setActivatingPlayer(source.getController());
+            sa.setActivatingPlayer(source.getController(), true);
 
             if (sa.hasParam("Cost")) {
                 if (!CostPayment.canPayAdditionalCosts(sa.getPayCosts(), sa, true)) {
@@ -1295,7 +1303,6 @@ public class ComputerUtilCombat {
                 continue;
             }
 
-            int pBonus = 0;
             if (ability.getApi() == ApiType.Pump) {
                 if (!ability.hasParam("NumAtt")) {
                     continue;
@@ -1305,8 +1312,11 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                if (!ability.getPayCosts().hasTapCost()) {
-                    pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumAtt"), ability);
+                if (!ability.getPayCosts().hasTapCost() && ComputerUtilCost.canPayCost(ability, attacker.getController(), false)) {
+                    int pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumAtt"), ability);
+                    if (pBonus > 0) {
+                        power += pBonus;
+                    }
                 }
             } else if (ability.getApi() == ApiType.PutCounter) {
                 if (!ability.hasParam("CounterType") || !ability.getParam("CounterType").equals("P1P1")) {
@@ -1321,14 +1331,13 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                if (!ability.getPayCosts().hasTapCost()) {
-                    pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
+                if (!ability.getPayCosts().hasTapCost() && ComputerUtilCost.canPayCost(ability, attacker.getController(), false)) {
+                    int pBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
+                    if (pBonus > 0) {
+                        power += pBonus;
+                    }
                 }
             }
-
-            if (pBonus > 0 && ComputerUtilCost.canPayCost(ability, attacker.getController(), false)) {
-                power += pBonus;
-            }
         }
         return power;
     }
@@ -1377,7 +1386,7 @@ public class ComputerUtilCombat {
             final CardCollectionView cardList = game.getCardsIn(ZoneType.Battlefield);
             for (final Card card : cardList) {
                 for (final StaticAbility stAb : card.getStaticAbilities()) {
-                    if (!stAb.checkMode(StaticAbilityMode.Continuous)) {
+                    if (!"Continuous".equals(stAb.getParam("Mode"))) {
                         continue;
                     }
                     if (!stAb.hasParam("Affected")) {
@@ -1418,13 +1427,12 @@ public class ComputerUtilCombat {
             if (sa == null) {
                 continue;
             }
+            sa.setActivatingPlayer(source.getController(), true);
 
             if (sa.usesTargeting()) {
                 continue; // targeted pumping not supported
             }
 
-            sa.setActivatingPlayer(source.getController());
-
             // DealDamage triggers
             if (ApiType.DealDamage.equals(sa.getApi())) {
                 if (!sa.hasParam("Defined") || !sa.getParam("Defined").startsWith("TriggeredAttacker")) {
@@ -1519,14 +1527,16 @@ public class ComputerUtilCombat {
             if (ability.getPayCosts().hasTapCost() && !attacker.hasKeyword(Keyword.VIGILANCE)) {
                 continue;
             }
+            if (!ComputerUtilCost.canPayCost(ability, attacker.getController(), false)) {
+                continue;
+            }
 
-            int tBonus = 0;
             if (ability.getApi() == ApiType.Pump) {
                 if (!ability.hasParam("NumDef")) {
                     continue;
                 }
 
-                tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumDef"), ability, true);
+                toughness += AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParam("NumDef"), ability, true);
             } else if (ability.getApi() == ApiType.PutCounter) {
                 if (!ability.hasParam("CounterType") || !ability.getParam("CounterType").equals("P1P1")) {
                     continue;
@@ -1540,11 +1550,10 @@ public class ComputerUtilCombat {
                     continue;
                 }
 
-                tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
-            }
-
-            if (tBonus > 0 && ComputerUtilCost.canPayCost(ability, attacker.getController(), false)) {
-                toughness += tBonus;
+                int tBonus = AbilityUtils.calculateAmount(ability.getHostCard(), ability.getParamOrDefault("CounterNum", "1"), ability);
+                if (tBonus > 0) {
+                    toughness += tBonus;
+                }
             }
         }
         return toughness;
@@ -1723,7 +1732,6 @@ public class ComputerUtilCombat {
         final int attackerLife = getDamageToKill(attacker, false)
                 + predictToughnessBonusOfAttacker(attacker, blocker, combat, withoutAbilities, withoutAttackerStaticAbilities);
 
-        // AI should be less worried about Deathtouch
         if (blocker.hasDoubleStrike()) {
             if (defenderDamage > 0 && (hasKeyword(blocker, "Deathtouch", withoutAbilities, combat) || attacker.hasSVar("DestroyWhenDamaged"))) {
                 return true;
@@ -1953,7 +1961,6 @@ public class ComputerUtilCombat {
         final int attackerLife = getDamageToKill(attacker, false)
                 + predictToughnessBonusOfAttacker(attacker, blocker, combat, withoutAbilities, withoutAttackerStaticAbilities);
 
-        // AI should be less worried about deathtouch
         if (attacker.hasDoubleStrike()) {
             if (attackerDamage >= defenderLife) {
                 return true;
@@ -2530,20 +2537,20 @@ public class ComputerUtilCombat {
         if (combat != null) {
             GameEntity def = combat.getDefenderByAttacker(sa.getHostCard());
             // 1. If the card that spawned the attacker was sent at a card, attack the same. Consider improving.
-            if (def instanceof Card card && Iterables.contains(defenders, def)) {
-                if (card.isPlaneswalker()) {
+            if (def instanceof Card && Iterables.contains(defenders, def)) {
+                if (((Card)def).isPlaneswalker()) {
                     return def;
                 }
-                if (card.isBattle()) {
+                if (((Card)def).isBattle()) {
                     return def;
                 }
             }
             // 2. Otherwise, go through the list of options one by one, choose the first one that can't be blocked profitably.
             for (GameEntity p : defenders) {
-                if (p instanceof Player p1 && !ComputerUtilCard.canBeBlockedProfitably(p1, attacker, true)) {
+                if (p instanceof Player && !ComputerUtilCard.canBeBlockedProfitably((Player)p, attacker, true)) {
                     return p;
                 }
-                if (p instanceof Card card && !ComputerUtilCard.canBeBlockedProfitably(card.getController(), attacker, true)) {
+                if (p instanceof Card && !ComputerUtilCard.canBeBlockedProfitably(((Card)p).getController(), attacker, true)) {
                     return p;
                 }
             }

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

@@ -1,23 +1,20 @@
 package forge.ai;
 
-import java.util.Collection;
-import java.util.List;
-import java.util.Set;
-import java.util.function.Predicate;
-
-import forge.game.GameObject;
-import org.apache.commons.lang3.ObjectUtils;
-import org.apache.commons.lang3.StringUtils;
-
+import com.google.common.base.Predicates;
+import com.google.common.collect.Iterables;
 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;
+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;
@@ -26,9 +23,15 @@ import forge.game.spellability.Spell;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetChoices;
 import forge.game.zone.ZoneType;
-import forge.util.IterableUtil;
 import forge.util.MyRandom;
 import forge.util.TextUtil;
+import forge.util.collect.FCollectionView;
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
 
 
 public class ComputerUtilCost {
@@ -51,7 +54,8 @@ public class ComputerUtilCost {
             return true;
         }
         for (final CostPart part : cost.getCostParts()) {
-            if (part instanceof CostPutCounter addCounter) {
+            if (part instanceof CostPutCounter) {
+                final CostPutCounter addCounter = (CostPutCounter) part;
                 final CounterType type = addCounter.getCounter();
 
                 if (type.is(CounterEnumType.M1M1)) {
@@ -77,7 +81,9 @@ public class ComputerUtilCost {
         }
         final AiCostDecision decision = new AiCostDecision(sa.getActivatingPlayer(), sa, false);
         for (final CostPart part : cost.getCostParts()) {
-            if (part instanceof CostRemoveCounter remCounter) {
+            if (part instanceof CostRemoveCounter) {
+                final CostRemoveCounter remCounter = (CostRemoveCounter) part;
+
                 final CounterType type = remCounter.counter;
                 if (!part.payCostFromSource()) {
                     if (type.is(CounterEnumType.P1P1)) {
@@ -86,7 +92,7 @@ public class ComputerUtilCost {
                     continue;
                 }
 
-                // even if it can be paid, removing zero counters should not be done.
+                // even if it can be paid, removing zero counters should not be done. 
                 if (part.payCostFromSource() && source.getCounters(type) <= 0) {
                     return false;
                 }
@@ -104,7 +110,9 @@ public class ComputerUtilCost {
                         && !source.hasKeyword(Keyword.UNDYING)) {
                     return false;
                 }
-            } else if (part instanceof CostRemoveAnyCounter remCounter) {
+            } else if (part instanceof CostRemoveAnyCounter) {
+                final CostRemoveAnyCounter remCounter = (CostRemoveAnyCounter) part;
+
                 PaymentDecision pay = decision.visit(remCounter);
                 return pay != null;
             }
@@ -129,31 +137,25 @@ public class ComputerUtilCost {
         CardCollection hand = new CardCollection(ai.getCardsIn(ZoneType.Hand));
 
         for (final CostPart part : cost.getCostParts()) {
-            if (part instanceof CostDiscard disc) {
+            if (part instanceof CostDiscard) {
+                final CostDiscard disc = (CostDiscard) part;
+
                 final String type = disc.getType();
-                final CardCollection typeList;
-                int num;
-                if (type.equals("Hand")) {
-                    typeList = hand;
-                    num = hand.size();
-                } else {
-                    if (type.equals("CARDNAME")) {
-                        if (source.getAbilityText().contains("Bloodrush")) {
-                            continue;
-                        }
-                        if (ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN, ai)
-                                && !ai.isUnlimitedHandSize() && ai.getCardsIn(ZoneType.Hand).size() > ai.getMaxHandSize()) {
-                            // Better do something than just discard stuff
-                            return true;
-                        }
-                        return false;
-                    }
-                    typeList = CardLists.getValidCards(hand, type, source.getController(), source, sa);
-                    if (typeList.size() > ai.getMaxHandSize()) {
+                if (type.equals("CARDNAME")) {
+                    if (source.getAbilityText().contains("Bloodrush")) {
                         continue;
+                    } else if (ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN, ai)
+                            && !ai.isUnlimitedHandSize() && ai.getCardsIn(ZoneType.Hand).size() > ai.getMaxHandSize()) {
+                        // Better do something than just discard stuff
+                        return true;
                     }
-                    num = AbilityUtils.calculateAmount(source, disc.getAmount(), sa);
                 }
+                final CardCollection typeList = CardLists.getValidCards(hand, type, source.getController(), source, sa);
+                if (typeList.size() > ai.getMaxHandSize()) {
+                    continue;
+                }
+                int num = AbilityUtils.calculateAmount(source, disc.getAmount(), sa);
+
                 for (int i = 0; i < num; i++) {
                     Card pref = ComputerUtil.getCardPreference(ai, source, "DiscardCost", typeList);
                     if (pref == null) {
@@ -183,7 +185,8 @@ public class ComputerUtilCost {
             return true;
         }
         for (final CostPart part : cost.getCostParts()) {
-            if (part instanceof CostDamage pay) {
+            if (part instanceof CostDamage) {
+                final CostDamage pay = (CostDamage) part;
                 int realDamage = ComputerUtilCombat.predictDamageTo(ai, pay.getAbilityAmount(sa), source, false);
                 if (ai.getLife() - realDamage < remainingLife
                         && realDamage > 0 && !ai.cantLoseForZeroOrLessLife()
@@ -215,8 +218,13 @@ public class ComputerUtilCost {
             return true;
         }
         for (final CostPart part : cost.getCostParts()) {
-            if (part instanceof CostPayLife payLife) {
-                int amount = payLife.getAbilityAmount(sourceAbility);
+            if (part instanceof CostPayLife) {
+                final CostPayLife payLife = (CostPayLife) part;
+
+                Integer amount = payLife.convertAmount();
+                if (amount == null) {
+                    amount = AbilityUtils.calculateAmount(source, payLife.getAmount(), sourceAbility);
+                }
 
                 // check if there's override for the remainingLife threshold
                 if (sourceAbility != null && sourceAbility.hasParam("AILifeThreshold")) {
@@ -251,7 +259,11 @@ public class ComputerUtilCost {
                     // Does the AI want to use Sacrifice All?
                     return false;
                 } else {
-                    int c = part.getAbilityAmount(sourceAbility);
+                    Integer c = part.convertAmount();
+
+                    if (c == null) {
+                        c = part.getAbilityAmount(sourceAbility);
+                    }
                     final AiController aic = ((PlayerControllerAi)ai.getController()).getAi();
                     CardCollectionView choices = aic.chooseSacrificeType(part.getType(), sourceAbility, effect, c, exclude);
                     if (choices != null) {
@@ -285,7 +297,8 @@ public class ComputerUtilCost {
             return true;
         }
         for (final CostPart part : cost.getCostParts()) {
-            if (part instanceof CostSacrifice sac) {
+            if (part instanceof CostSacrifice) {
+                final CostSacrifice sac = (CostSacrifice) part;
                 final int amount = AbilityUtils.calculateAmount(source, sac.getAmount(), sourceAbility);
 
                 if (sac.payCostFromSource() && source.isCreature()) {
@@ -334,11 +347,12 @@ public class ComputerUtilCost {
             return true;
         }
         for (final CostPart part : cost.getCostParts()) {
-            if (part instanceof CostSacrifice sac) {
+            if (part instanceof CostSacrifice) {
                 if (suppressRecursiveSacCostCheck) {
                     return false;
                 }
 
+                final CostSacrifice sac = (CostSacrifice) part;
                 final int amount = AbilityUtils.calculateAmount(source, sac.getAmount(), sourceAbility);
 
                 String type = sac.getType();
@@ -514,102 +528,58 @@ public class ComputerUtilCost {
      * @return a boolean.
      */
     public static boolean canPayCost(final SpellAbility sa, final Player player, final boolean effect) {
-        return canPayCost(sa.getPayCosts(), sa, player, effect);
-    }
-    public static boolean canPayCost(final Cost cost, 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.
         }
 
+        boolean cannotBeCountered = false;
+
         // Check for stuff like Nether Void
         int extraManaNeeded = 0;
-        if (!effect) {
-            boolean cannotBeCountered = !sa.isCounterableBy(null);
-
-            if (sa instanceof Spell) {
-                for (Card c : player.getGame().getCardsIn(ZoneType.Battlefield)) {
-                    final String snem = c.getSVar("AI_SpellsNeedExtraMana");
-                    if (!StringUtils.isBlank(snem)) {
-                        if (cannotBeCountered && c.getName().equals("Nether Void")) {
-                            continue;
-                        }
-                        String[] parts = TextUtil.split(snem, ' ');
-                        boolean meetsRestriction = parts.length == 1 || player.isValid(parts[1], c.getController(), c, sa);
-                        if(!meetsRestriction)
-                            continue;
-
-                        if (StringUtils.isNumeric(parts[0])) {
-                            extraManaNeeded += Integer.parseInt(parts[0]);
-                        } else {
-                            System.out.println("wrong SpellsNeedExtraMana SVar format on " + c);
-                        }
-                    }
-                }
-                for (Card c : player.getCardsIn(ZoneType.Command)) {
-                    if (cannotBeCountered) {
+        if (sa instanceof Spell) {
+            cannotBeCountered = !sa.isCounterableBy(null);
+            for (Card c : player.getGame().getCardsIn(ZoneType.Battlefield)) {
+                final String snem = c.getSVar("AI_SpellsNeedExtraMana");
+                if (!StringUtils.isBlank(snem)) {
+                    if (cannotBeCountered && c.getName().equals("Nether Void")) {
                         continue;
                     }
-                    final String snem = c.getSVar("SpellsNeedExtraManaEffect");
-                    if (!StringUtils.isBlank(snem)) {
-                        if (StringUtils.isNumeric(snem)) {
-                            extraManaNeeded += Integer.parseInt(snem);
-                        } else {
-                            System.out.println("wrong SpellsNeedExtraManaEffect SVar format on " + c);
-                        }
+                    String[] parts = TextUtil.split(snem, ' ');
+                    boolean meetsRestriction = parts.length == 1 || player.isValid(parts[1], c.getController(), c, sa);
+                    if(!meetsRestriction)
+                        continue;
+
+                    if (StringUtils.isNumeric(parts[0])) {
+                        extraManaNeeded += Integer.parseInt(parts[0]);
+                    } else {
+                        System.out.println("wrong SpellsNeedExtraMana SVar format on " + c);
                     }
                 }
             }
-
-            // Try not to lose Planeswalker if not threatened
-            if (sa.isPwAbility()) {
-                for (final CostPart part : cost.getCostParts()) {
-                    if (part instanceof CostRemoveCounter) {
-                        if (part.convertAmount() != null && part.convertAmount() == sa.getHostCard().getCurrentLoyalty()) {
-                            // refuse to pay if opponent has no creature threats or
-                            // 50% chance otherwise
-                            if (player.getOpponents().getCreaturesInPlay().isEmpty()
-                                    || MyRandom.getRandom().nextFloat() < .5f) {
-                                return false;
-                            }
-                        }
+            for (Card c : player.getCardsIn(ZoneType.Command)) {
+                if (cannotBeCountered) {
+                    continue;
+                }
+                final String snem = c.getSVar("SpellsNeedExtraManaEffect");
+                if (!StringUtils.isBlank(snem)) {
+                    if (StringUtils.isNumeric(snem)) {
+                        extraManaNeeded += Integer.parseInt(snem);
+                    } else {
+                        System.out.println("wrong SpellsNeedExtraManaEffect SVar format on " + c);
                     }
                 }
             }
+        }
 
-            // 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. (currently it will be stuck with the target until it could pay)
-            if (!sa.isTrigger() && !cannotBeCountered) {
-                Set<GameObject> distinctObjects = Sets.newHashSet();
-                for (TargetChoices tc : sa.getAllTargetChoices()) {
-                    for (Card tgt : tc.getTargetCards()) {
-                        if (!distinctObjects.add(tgt)) {
-                            continue;
-                        }
-                        // 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())) {
-                            Cost wardCost = ComputerUtilCard.getTotalWardCost(tgt);
-                            // don't use API converter since it might have special part logic not meant for Ward cost
-                            SpellAbilityAi topAI = new SpellAbilityAi() {};
-                            if (!topAI.willPayCosts(player, sa, wardCost, sa.getHostCard())) {
-                                return false;
-                            }
-                            if (wardCost.hasManaCost()) {
-                                extraManaNeeded += wardCost.getTotalMana().getCMC();
-                            }
-                        }
-                    }
-                }
-            }
-
-            // Bail early on Casualty in case there are no cards that would make sense to pay with
-            if (sa.getHostCard().hasKeyword(Keyword.CASUALTY)) {
-                for (final CostPart part : cost.getCostParts()) {
-                    if (part instanceof CostSacrifice) {
-                        CardCollection valid = CardLists.getValidCards(player.getCardsIn(ZoneType.Battlefield), part.getType().split(";"),
-                                sa.getActivatingPlayer(), sa.getHostCard(), sa);
-                        valid = CardLists.filter(valid, CardPredicates.hasSVar("AIDontSacToCasualty").negate());
-                        if (valid.isEmpty()) {
+        // Try not to lose Planeswalker if not threatened
+        if (sa.isPwAbility()) {
+            for (final CostPart part : sa.getPayCosts().getCostParts()) {
+                if (part instanceof CostRemoveCounter) {
+                    if (part.convertAmount() != null && part.convertAmount() == sa.getHostCard().getCurrentLoyalty()) {
+                        // refuse to pay if opponent has no creature threats or
+                        // 50% chance otherwise
+                        if (player.getOpponents().getCreaturesInPlay().isEmpty()
+                                || MyRandom.getRandom().nextFloat() < .5f) {
                             return false;
                         }
                     }
@@ -617,16 +587,227 @@ public class ComputerUtilCost {
             }
         }
 
-        // TODO both of these call CostAdjustment.adjust, try to reuse instead
-        return ComputerUtilMana.canPayManaCost(cost, sa, player, extraManaNeeded, effect)
-                && CostPayment.canPayAdditionalCosts(cost, sa, effect, player);
+        // Ward - will be accounted for when rechecking a targeted ability
+        if (!sa.isTrigger() && (!sa.isSpell() || !cannotBeCountered)) {
+            for (TargetChoices tc : sa.getAllTargetChoices()) {
+                for (Card tgt : tc.getTargetCards()) {
+                    if (tgt.hasKeyword(Keyword.WARD) && tgt.isInPlay() && tgt.getController().isOpponentOf(sa.getHostCard().getController())) {
+                        Cost wardCost = ComputerUtilCard.getTotalWardCost(tgt);
+                        if (wardCost.hasManaCost()) {
+                            extraManaNeeded += wardCost.getTotalMana().getCMC();
+                        }
+                    }
+                }
+            }
+        }
+
+        // Bail early on Casualty in case there are no cards that would make sense to pay with
+        if (sa.getHostCard().hasKeyword(Keyword.CASUALTY)) {
+            for (final CostPart part : sa.getPayCosts().getCostParts()) {
+                if (part instanceof CostSacrifice) {
+                    CardCollection valid = CardLists.getValidCards(player.getCardsIn(ZoneType.Battlefield), part.getType().split(";"),
+                            sa.getActivatingPlayer(), sa.getHostCard(), sa);
+                    valid = CardLists.filter(valid, Predicates.not(CardPredicates.hasSVar("AIDontSacToCasualty")));
+                    if (valid.isEmpty()) {
+                        return false;
+                    }
+                }
+            }
+        }
+
+        return ComputerUtilMana.canPayManaCost(sa, player, extraManaNeeded, effect)
+                && CostPayment.canPayAdditionalCosts(sa.getPayCosts(), sa, effect);
+    }
+
+    public static boolean willPayUnlessCost(SpellAbility sa, Player payer, Cost cost, boolean alreadyPaid, FCollectionView<Player> payers) {
+        final Card source = sa.getHostCard();
+        final String aiLogic = sa.getParam("UnlessAI");
+        boolean payForOwnOnly = "OnlyOwn".equals(aiLogic);
+        boolean payOwner = sa.hasParam("UnlessAI") && aiLogic.startsWith("Defined");
+        boolean payNever = "Never".equals(aiLogic);
+        boolean isMine = sa.getActivatingPlayer().equals(payer);
+
+        if (payNever) { return false; }
+        if (payForOwnOnly && !isMine) { return false; }
+        if (payOwner) {
+            final String defined = aiLogic.substring(7);
+            final Player player = AbilityUtils.getDefinedPlayers(source, defined, sa).get(0);
+            if (!payer.equals(player)) {
+                return false;
+            }
+        } else if ("OnlyDontControl".equals(aiLogic)) {
+            if (source == null || payer.equals(source.getController())) {
+                return false;
+            }
+        } else if ("Paralyze".equals(aiLogic)) {
+            final Card c = source.getEnchantingCard();
+            if (c == null || c.isUntapped()) {
+                return false;
+            }
+        } else if ("RiskFactor".equals(aiLogic)) {
+            final Player activator = sa.getActivatingPlayer();
+            if (!activator.canDraw()) {
+                return false;
+            }
+        } else if ("MorePowerful".equals(aiLogic)) {
+            final int sourceCreatures = sa.getActivatingPlayer().getCreaturesInPlay().size();
+            final int payerCreatures = payer.getCreaturesInPlay().size();
+            if (payerCreatures > sourceCreatures + 1) {
+                return false;
+            }
+        } else if (aiLogic != null && aiLogic.startsWith("LifeLE")) {
+            // if payer can't lose life its no need to pay unless
+            if (!payer.canLoseLife())
+                return false;
+            else if (payer.getLife() <= AbilityUtils.calculateAmount(source, aiLogic.substring(6), sa)) {
+                return true;
+            }
+        } else if ("WillAttack".equals(aiLogic)) {
+            AiAttackController aiAtk = new AiAttackController(payer);
+            Combat combat = new Combat(payer);
+            aiAtk.declareAttackers(combat);
+            if (combat.getAttackers().isEmpty()) {
+                return false;
+            }
+        } else if ("nonToken".equals(aiLogic) && !AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa).isEmpty()
+                && AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa).get(0).isToken()) {
+            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.parseInt(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 = CardCopyService.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;
+        } else if ("Riot".equals(aiLogic)) {
+            return !SpecialAiLogic.preferHasteForRiot(sa, payer);
+        }
+
+        // Check for shocklands and similar ETB replacement effects
+        if (sa.hasParam("ETB") && sa.getApi().equals(ApiType.Tap)) {
+            for (final CostPart part : cost.getCostParts()) {
+                if (part instanceof CostPayLife) {
+                    final CostPayLife lifeCost = (CostPayLife) part;
+                    Integer amount = lifeCost.convertAmount();
+                    if (payer.getLife() > (amount + 1) && payer.canPayLife(amount, true, sa)) {
+                        final int landsize = payer.getLandsInPlay().size() + 1;
+                        for (Card c : payer.getCardsIn(ZoneType.Hand)) {
+                            // Check if the AI has enough lands to play the card
+                            if (landsize != c.getCMC()) {
+                                continue;
+                            }
+                            // 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());
+                            if (canPay && willPlay) {
+                                return true;
+                            }
+                        }
+                    }
+                    return false;
+                }
+            }
+        }
+
+        // AI will only pay when it's not already payed and only opponents abilities
+        if (alreadyPaid || (payers.size() > 1 && (isMine && !payForOwnOnly))) {
+            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.isCounterableBy(sa)) {
+                    return false;
+                }
+                // no reason to pay if we don't plan to confirm
+                if (toBeCountered.isOptionalTrigger() && !SpellApiToAi.Converter.get(toBeCountered.getApi()).doTriggerNoCostWithSubs(payer, toBeCountered, false)) {
+                    return false;
+                }
+                // TODO check hasFizzled
+            }
+        }
+
+        // AI was crashing because the blank ability used to pay costs
+        // Didn't have any of the data on the original SA to pay dependant costs
+
+        return checkLifeCost(payer, cost, source, 4, sa)
+                && checkDamageCost(payer, cost, source, 4, sa)
+                && (isMine || checkSacrificeCost(payer, cost, source, sa))
+                && (isMine || checkDiscardCost(payer, cost, source, sa))
+                && (!source.getName().equals("Tyrannize") || payer.getCardsIn(ZoneType.Hand).size() > 2)
+                && (!source.getName().equals("Perplex") || payer.getCardsIn(ZoneType.Hand).size() < 2)
+                && (!source.getName().equals("Breaking Point") || payer.getCreaturesInPlay().size() > 1)
+                && (!source.getName().equals("Chain of Vapor") || (payer.getWeakestOpponent().getCreaturesInPlay().size() > 0 && payer.getLandsInPlay().size() > 3));
     }
 
     public static Set<String> getAvailableManaColors(Player ai, Card additionalLand) {
         return getAvailableManaColors(ai, Lists.newArrayList(additionalLand));
     }
     public static Set<String> getAvailableManaColors(Player ai, List<Card> additionalLands) {
-        CardCollection cardsToConsider = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.UNTAPPED);
+        CardCollection cardsToConsider = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Presets.UNTAPPED);
         Set<String> colorsAvailable = Sets.newHashSet();
 
         if (additionalLands != null) {
@@ -716,8 +897,8 @@ public class ComputerUtilCost {
 
     public static CardCollection paymentChoicesWithoutTargets(Iterable<Card> choices, SpellAbility source, Player ai) {
         if (source.usesTargeting()) {
-            final CardCollectionView targets = source.getTargets().getTargetCards();
-            choices = IterableUtil.filter(choices, Predicate.not(CardPredicates.isController(ai).and(targets::contains)));
+            final CardCollection targets = new CardCollection(source.getTargets().getTargetCards());
+            choices = Iterables.filter(choices, Predicates.not(Predicates.and(CardPredicates.isController(ai), Predicates.in(targets))));
         }
         return new CardCollection(choices);
     }

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

@@ -1,10 +1,7 @@
 package forge.ai;
 
-import com.google.common.collect.ArrayListMultimap;
-import com.google.common.collect.ListMultimap;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Multimap;
+import com.google.common.base.Predicates;
+import com.google.common.collect.*;
 import forge.ai.AiCardMemory.MemorySet;
 import forge.ai.ability.AnimateAi;
 import forge.card.ColorSet;
@@ -46,7 +43,6 @@ import forge.util.TextUtil;
 import org.apache.commons.lang3.StringUtils;
 
 import java.util.*;
-import java.util.stream.Collectors;
 
 public class ComputerUtilMana {
     private final static boolean DEBUG_MANA_PAYMENT = false;
@@ -56,28 +52,25 @@ public class ComputerUtilMana {
         return payManaCost(cost, sa, ai, true, true, effect);
     }
     public static boolean canPayManaCost(final SpellAbility sa, final Player ai, final int extraMana, final boolean effect) {
-        return canPayManaCost(sa.getPayCosts(), sa, ai, extraMana, effect);
-    }
-    public static boolean canPayManaCost(final Cost cost, final SpellAbility sa, final Player ai, final int extraMana, final boolean effect) {
-        return payManaCost(cost, sa, ai, true, extraMana, true, effect);
+        return payManaCost(sa, ai, true, extraMana, true, effect);
     }
 
     public static boolean payManaCost(ManaCostBeingPaid cost, final SpellAbility sa, final Player ai, final boolean effect) {
         return payManaCost(cost, sa, ai, false, true, effect);
     }
-    public static boolean payManaCost(final Cost cost, final Player ai, final SpellAbility sa, final boolean effect) {
-        return payManaCost(cost, sa, ai, false, 0, true, effect);
+    public static boolean payManaCost(final Player ai, final SpellAbility sa, final boolean effect) {
+        return payManaCost(sa, ai, false, 0, true, effect);
     }
-    private static boolean payManaCost(final Cost cost, final SpellAbility sa, final Player ai, final boolean test, final int extraMana, boolean checkPlayable, final boolean effect) {
-        ManaCostBeingPaid manaCost = calculateManaCost(cost, sa, test, extraMana, effect);
-        return payManaCost(manaCost, sa, ai, test, checkPlayable, effect);
+    private static boolean payManaCost(final SpellAbility sa, final Player ai, final boolean test, final int extraMana, boolean checkPlayable, final boolean effect) {
+        ManaCostBeingPaid cost = calculateManaCost(sa, test, extraMana);
+        return payManaCost(cost, sa, ai, test, checkPlayable, effect);
     }
 
     /**
      * Return the number of colors used for payment for Converge
      */
     public static int getConvergeCount(final SpellAbility sa, final Player ai) {
-        ManaCostBeingPaid cost = calculateManaCost(sa.getPayCosts(), sa, true, 0, false);
+        ManaCostBeingPaid cost = calculateManaCost(sa, true, 0);
         if (payManaCost(cost, sa, ai, true, true, false)) {
             return cost.getSunburst();
         }
@@ -88,15 +81,15 @@ public class ComputerUtilMana {
     public static boolean hasEnoughManaSourcesToCast(final SpellAbility sa, final Player ai) {
         if (ai == null || sa == null)
             return false;
-        sa.setActivatingPlayer(ai);
-        return payManaCost(sa.getPayCosts(), sa, ai, true, 0, false, false);
+        sa.setActivatingPlayer(ai, true);
+        return payManaCost(sa, ai, true, 0, false, false);
     }
 
     private static Integer scoreManaProducingCard(final Card card) {
         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
@@ -158,7 +151,7 @@ public class ComputerUtilMana {
                 }
 
                 // Mana abilities on the same card
-                String shardMana = shard.toShortString();
+                String shardMana = shard.toString().replaceAll("\\{", "").replaceAll("\\}", "");
 
                 boolean payWithAb1 = ability1.getManaPart().mana(ability1).contains(shardMana);
                 boolean payWithAb2 = ability2.getManaPart().mana(ability2).contains(shardMana);
@@ -226,7 +219,7 @@ public class ComputerUtilMana {
     }
 
     public static SpellAbility chooseManaAbility(ManaCostBeingPaid cost, SpellAbility sa, Player ai, ManaCostShard toPay,
-            Collection<SpellAbility> maList, boolean checkCosts) {
+            Collection<SpellAbility> saList, boolean checkCosts) {
         Card saHost = sa.getHostCard();
 
         // CastTotalManaSpent (AIPreference:ManaFrom$Type or AIManaPref$ Type)
@@ -240,12 +233,12 @@ public class ComputerUtilMana {
             manaSourceType = sa.getParam("AIManaPref");
         }
         if (manaSourceType != "") {
-            List<SpellAbility> filteredList = Lists.newArrayList(maList);
+            List<SpellAbility> filteredList = Lists.newArrayList(saList);
             switch (manaSourceType) {
                 case "Snow":
                     filteredList.sort((ab1, ab2) -> ab1.getHostCard() != null && ab1.getHostCard().isSnow()
                             && ab2.getHostCard() != null && !ab2.getHostCard().isSnow() ? -1 : 1);
-                    maList = filteredList;
+                    saList = filteredList;
                     break;
                 case "Treasure":
                     // Try to spend only one Treasure if possible
@@ -253,31 +246,28 @@ public class ComputerUtilMana {
                             && ab2.getHostCard() != null && !ab2.getHostCard().getType().hasSubtype("Treasure") ? -1 : 1);
                     SpellAbility first = filteredList.get(0);
                     if (first.getHostCard() != null && first.getHostCard().getType().hasSubtype("Treasure")) {
-                        maList.remove(first);
+                        saList.remove(first);
                         List<SpellAbility> updatedList = Lists.newArrayList();
                         updatedList.add(first);
-                        updatedList.addAll(maList);
-                        maList = updatedList;
+                        updatedList.addAll(saList);
+                        saList = updatedList;
                     }
                     break;
                 case "TreasureMax":
                     // Ok to spend as many Treasures as possible
                     filteredList.sort((ab1, ab2) -> ab1.getHostCard() != null && ab1.getHostCard().getType().hasSubtype("Treasure")
                             && ab2.getHostCard() != null && !ab2.getHostCard().getType().hasSubtype("Treasure") ? -1 : 1);
-                    maList = filteredList;
+                    saList = filteredList;
                     break;
                 case "NotSameCard":
-                    String hostName = sa.getHostCard().getName();
-                    maList = filteredList.stream()
-                            .filter(saPay -> !saPay.getHostCard().getName().equals(hostName))
-                            .collect(Collectors.toList());
+                    saList = Lists.newArrayList(Iterables.filter(filteredList, saPay -> !saPay.getHostCard().getName().equals(sa.getHostCard().getName())));
                     break;
                 default:
                     break;
             }
         }
 
-        for (final SpellAbility ma : maList) {
+        for (final SpellAbility ma : saList) {
             // this rarely seems like a good idea
             if (ma.getHostCard() == saHost) {
                 continue;
@@ -287,9 +277,7 @@ public class ComputerUtilMana {
                 continue;
             }
 
-            int amount = ma.hasParam("Amount") ? AbilityUtils.calculateAmount(ma.getHostCard(), ma.getParam("Amount"), ma) : 1;
-            if (amount <= 0) {
-                // wrong gamestate for variable amount
+            if (!ComputerUtilCost.checkTapTypeCost(ai, ma.getPayCosts(), ma.getHostCard(), sa, AiCardMemory.getMemorySet(ai, MemorySet.PAYS_TAP_COST))) {
                 continue;
             }
 
@@ -322,7 +310,7 @@ public class ComputerUtilMana {
                 // For cards like Genju of the Cedars, make sure we're not attaching to the same land that will
                 // be tapped to pay its own cost if there's another untapped land like that available
                 if (ma.getHostCard().equals(sa.getTargetCard())) {
-                    if (CardLists.count(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.nameEquals(ma.getHostCard().getName()).and(CardPredicates.UNTAPPED)) > 1) {
+                    if (CardLists.count(ai.getCardsIn(ZoneType.Battlefield), Predicates.and(CardPredicates.nameEquals(ma.getHostCard().getName()), CardPredicates.Presets.UNTAPPED)) > 1) {
                         continue;
                     }
                 }
@@ -338,7 +326,7 @@ public class ComputerUtilMana {
                     // Deprioritize Cavern of Souls, try to pay generic mana with it instead to use the NoCounter ability
                     continue;
                 } else if (toPay == ManaCostShard.GENERIC || toPay == ManaCostShard.X) {
-                    for (SpellAbility ab : maList) {
+                    for (SpellAbility ab : saList) {
                         if (ab.isManaAbility() && ab.getManaPart().isAnyMana() && ab.hasParam("AddsNoCounter")) {
                             if (!ab.getHostCard().isTapped()) {
                                 paymentChoice = ab;
@@ -353,14 +341,9 @@ public class ComputerUtilMana {
                 continue;
             }
 
-            // these should come last since they reserve the paying cards
-            // (this means if a mana ability has both parts it doesn't currently undo reservations if the second part fails)
             if (!ComputerUtilCost.checkForManaSacrificeCost(ai, ma.getPayCosts(), ma, ma.isTrigger())) {
                 continue;
             }
-            if (!ComputerUtilCost.checkTapTypeCost(ai, ma.getPayCosts(), ma.getHostCard(), sa, AiCardMemory.getMemorySet(ai, MemorySet.PAYS_TAP_COST))) {
-                continue;
-            }
 
             return paymentChoice;
         }
@@ -450,6 +433,7 @@ public class ComputerUtilMana {
                         manaProduced = manaProduced.replace(s, color);
                     }
                 } else if (saMana.hasParam("ReplaceColor")) {
+                    // replace color
                     String color = saMana.getParam("ReplaceColor");
                     if ("Chosen".equals(color)) {
                         if (card.hasChosenColor()) {
@@ -483,18 +467,18 @@ public class ComputerUtilMana {
     public static String predictManafromSpellAbility(SpellAbility saPayment, Player ai, ManaCostShard toPay) {
         Card hostCard = saPayment.getHostCard();
 
-        StringBuilder manaProduced = new StringBuilder(predictManaReplacement(saPayment, ai, toPay));
-        String originalProduced = manaProduced.toString();
+        String manaProduced = predictManaReplacement(saPayment, ai, toPay);
+        String originalProduced = manaProduced;
 
         if (originalProduced.isEmpty()) {
-            return manaProduced.toString();
+            return manaProduced;
         }
 
         // Run triggers like Nissa
         final Map<AbilityKey, Object> runParams = AbilityKey.mapFromCard(hostCard);
         runParams.put(AbilityKey.Activator, ai); // assuming AI would only ever gives itself mana
         runParams.put(AbilityKey.AbilityMana, saPayment);
-        runParams.put(AbilityKey.Produced, manaProduced.toString());
+        runParams.put(AbilityKey.Produced, manaProduced);
         for (Trigger tr : ai.getGame().getTriggerHandler().getActiveTrigger(TriggerType.TapsForMana, runParams)) {
             SpellAbility trSA = tr.ensureAbility();
             if (trSA == null) {
@@ -506,7 +490,7 @@ public class ComputerUtilMana {
                 if (produced.equals("Chosen")) {
                     produced = MagicColor.toShortString(trSA.getHostCard().getChosenColor());
                 }
-                manaProduced.append(" ").append(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
@@ -515,11 +499,11 @@ public class ComputerUtilMana {
                 if (reflectProperty.equals("Produced") && !originalProduced.isEmpty()) {
                     // check if a colorless shard can be paid from the trigger
                     if (toPay.equals(ManaCostShard.COLORLESS) && colorOrType.equals("Type") && originalProduced.contains("C")) {
-                        manaProduced.append(" " + "C");
+                        manaProduced += " " + "C";
                     } else if (originalProduced.length() == 1) {
                         // if length is only one, and it either is equal C == Type
                         if (colorOrType.equals("Type") || !originalProduced.equals("C")) {
-                            manaProduced.append(" ").append(originalProduced);
+                            manaProduced += " " + originalProduced;
                         }
                     } else {
                         // should it look for other shards too?
@@ -527,7 +511,7 @@ public class ComputerUtilMana {
                         for (String s : originalProduced.split(" ")) {
                             if (colorOrType.equals("Type") || !s.equals("C") && toPay.canBePaidWithManaOfColor(MagicColor.fromName(s))) {
                                 found = true;
-                                manaProduced.append(" ").append(s);
+                                manaProduced += " " + s;
                                 break;
                             }
                         }
@@ -535,7 +519,7 @@ public class ComputerUtilMana {
                         if (!found) {
                             for (String s : originalProduced.split(" ")) {
                                 if (colorOrType.equals("Type") || !s.equals("C")) {
-                                    manaProduced.append(" ").append(s);
+                                    manaProduced += " " + s;
                                     break;
                                 }
                             }
@@ -544,7 +528,7 @@ public class ComputerUtilMana {
                 }
             }
         }
-        return manaProduced.toString();
+        return manaProduced;
     }
 
     public static CardCollection getManaSourcesToPayCost(final ManaCostBeingPaid cost, final SpellAbility sa, final Player ai) {
@@ -596,12 +580,12 @@ public class ComputerUtilMana {
         while (!cost.isPaid()) {
             toPay = getNextShardToPay(cost, sourcesForShards);
 
-            Collection<SpellAbility> maList = sourcesForShards.get(toPay);
-            if (maList == null) {
+            Collection<SpellAbility> saList = sourcesForShards.get(toPay);
+            if (saList == null) {
                 break;
             }
 
-            SpellAbility saPayment = chooseManaAbility(cost, sa, ai, toPay, maList, true);
+            SpellAbility saPayment = chooseManaAbility(cost, sa, ai, toPay, saList, true);
             if (saPayment == null) {
                 boolean lifeInsteadOfBlack = toPay.isBlack() && ai.hasKeyword("PayLifeInsteadOf:B");
                 if ((!toPay.isPhyrexian() && !lifeInsteadOfBlack) || !ai.canPayLife(2, false, sa)) {
@@ -625,7 +609,7 @@ public class ComputerUtilMana {
             payMultipleMana(cost, manaProduced, ai);
 
             // remove from available lists
-            sourcesForShards.values().removeIf(CardTraitPredicates.isHostCard(saPayment.getHostCard()));
+            Iterables.removeIf(sourcesForShards.values(), CardTraitPredicates.isHostCard(saPayment.getHostCard()));
         }
 
         CostPayment.handleOfferings(sa, true, cost.isPaid());
@@ -648,31 +632,26 @@ public class ComputerUtilMana {
         List<SpellAbility> paymentList = Lists.newArrayList();
         final ManaPool manapool = ai.getManaPool();
 
-        // Apply color/type conversion matrix if necessary (already done via autopay)
-        if (ai.getControllingPlayer() == null) {
-            manapool.restoreColorReplacements();
-            CardPlayOption mayPlay = sa.getMayPlayOption();
-            if (!effect) {
-                if (sa.isSpell() && mayPlay != null) {
-                    mayPlay.applyManaConvert(manapool);
-                } else if (sa.isActivatedAbility() && sa.getGrantorStatic() != null && sa.getGrantorStatic().hasParam("ManaConversion")) {
-                    AbilityUtils.applyManaColorConversion(manapool, sa.getGrantorStatic().getParam("ManaConversion"));
-                }
+        // Apply the color/type conversion matrix if necessary
+        manapool.restoreColorReplacements();
+        CardPlayOption mayPlay = sa.getMayPlayOption();
+        if (!effect) {
+            if (sa.isSpell() && mayPlay != null) {
+                mayPlay.applyManaConvert(manapool);
+            } else if (sa.isActivatedAbility() && sa.getGrantorStatic() != null && sa.getGrantorStatic().hasParam("ManaConversion")) {
+                AbilityUtils.applyManaColorConversion(manapool, sa.getGrantorStatic().getParam("ManaConversion"));
             }
-            if (sa.hasParam("ManaConversion")) {
-                AbilityUtils.applyManaColorConversion(manapool, sa.getParam("ManaConversion"));
-            }
-            StaticAbilityManaConvert.manaConvert(manapool, ai, sa.getHostCard(), effect && !sa.isCastFromPlayEffect() ? null : sa);
         }
+        if (sa.hasParam("ManaConversion")) {
+            AbilityUtils.applyManaColorConversion(manapool, sa.getParam("ManaConversion"));
+        }
+        StaticAbilityManaConvert.manaConvert(manapool, ai, sa.getHostCard(), effect && !sa.isCastFromPlayEffect() ? null : sa);
 
-        // not worth checking if it makes sense to not spend floating first
         if (manapool.payManaCostFromPool(cost, sa, test, manaSpentToPay)) {
             CostPayment.handleOfferings(sa, test, cost.isPaid());
-            // paid all from floating mana
-            return true;
+            return true;    // paid all from floating mana
         }
 
-        int phyLifeToPay = 2;
         boolean purePhyrexian = cost.containsOnlyPhyrexianMana();
         boolean hasConverge = sa.getHostCard().hasConverge();
         ListMultimap<ManaCostShard, SpellAbility> sourcesForShards = getSourcesForShards(cost, sa, ai, test, checkPlayable, hasConverge);
@@ -700,12 +679,13 @@ public class ComputerUtilMana {
             }
 
             if (sourcesForShards == null && !purePhyrexian) {
-                // no mana abilities to use for paying
-                break;
+                break;    // no mana abilities to use for paying
             }
 
             toPay = getNextShardToPay(cost, sourcesForShards);
 
+            boolean lifeInsteadOfBlack = toPay.isBlack() && ai.hasKeyword("PayLifeInsteadOf:B");
+
             Collection<SpellAbility> saList = null;
             if (hasConverge &&
                     (toPay == ManaCostShard.GENERIC || toPay == ManaCostShard.X)) {
@@ -741,8 +721,7 @@ public class ComputerUtilMana {
 
             if (saPayment != null && ComputerUtilCost.isSacrificeSelfCost(saPayment.getPayCosts())) {
                 if (sa.getTargets() != null && sa.getTargets().contains(saPayment.getHostCard())) {
-                    // not a good idea to sac a card that you're targeting with the SA you're paying for
-                    saExcludeList.add(saPayment);
+                    saExcludeList.add(saPayment); // not a good idea to sac a card that you're targeting with the SA you're paying for
                     continue;
                 }
             }
@@ -759,14 +738,9 @@ public class ComputerUtilMana {
             }
 
             if (saPayment == null) {
-                boolean lifeInsteadOfBlack = toPay.isBlack() && ai.hasKeyword("PayLifeInsteadOf:B");
-                if ((!toPay.isPhyrexian() && !lifeInsteadOfBlack) || !ai.canPayLife(phyLifeToPay, false, sa)
-                        || (ai.getLife() <= phyLifeToPay && !ai.cantLoseForZeroOrLessLife())) {
-                    // cannot pay
-                    break;
-                }
-                if (test) {
-                    phyLifeToPay += 2;
+                if ((!toPay.isPhyrexian() && !lifeInsteadOfBlack) || !ai.canPayLife(2, false, sa)
+                        || (ai.getLife() <= 2 && !ai.cantLoseForZeroOrLessLife())) {
+                    break; // cannot pay
                 }
 
                 if (sa.hasParam("AIPhyrexianPayment")) {
@@ -774,7 +748,7 @@ public class ComputerUtilMana {
                         break; // unwise to pay
                     } else if (sa.getParam("AIPhyrexianPayment").startsWith("OnFatalDamage.")) {
                         int dmg = Integer.parseInt(sa.getParam("AIPhyrexianPayment").substring(14));
-                        if (ai.getOpponents().stream().noneMatch(PlayerPredicates.lifeLessOrEqualTo(dmg))) {
+                        if (!Iterables.any(ai.getOpponents(), PlayerPredicates.lifeLessOrEqualTo(dmg))) {
                             break; // no one to finish with the gut shot
                         }
                     }
@@ -816,11 +790,11 @@ public class ComputerUtilMana {
                 String manaProduced = predictManafromSpellAbility(saPayment, ai, toPay);
                 payMultipleMana(cost, manaProduced, ai);
 
-                // remove to prevent re-usage since resources don't get consumed
-                sourcesForShards.values().removeIf(CardTraitPredicates.isHostCard(saPayment.getHostCard()));
+                // remove from available lists
+                Iterables.removeIf(sourcesForShards.values(), CardTraitPredicates.isHostCard(saPayment.getHostCard()));
             } else {
                 final CostPayment pay = new CostPayment(saPayment.getPayCosts(), saPayment);
-                if (!pay.payComputerCosts(new AiCostDecision(ai, saPayment, effect, true))) {
+                if (!pay.payComputerCosts(new AiCostDecision(ai, saPayment, effect))) {
                     saList.remove(saPayment);
                     continue;
                 }
@@ -829,14 +803,12 @@ public class ComputerUtilMana {
                 // subtract mana from mana pool
                 manapool.payManaFromAbility(sa, cost, saPayment);
 
-                // need to consider if another use is now prevented
-                if (!cost.isPaid() && saPayment.isActivatedAbility() && !saPayment.getRestrictions().canPlay(saPayment.getHostCard(), saPayment)) {
-                    sourcesForShards.values().removeIf(s -> s == saPayment);
-                }
+                // no need to remove abilities from resource map,
+                // once their costs are paid and consume resources, they can not be used again
 
                 if (hasConverge) {
                     // hack to prevent converge re-using sources
-                    sourcesForShards.values().removeIf(CardTraitPredicates.isHostCard(saPayment.getHostCard()));
+                    Iterables.removeIf(sourcesForShards.values(), CardTraitPredicates.isHostCard(saPayment.getHostCard()));
                 }
             }
         }
@@ -855,8 +827,7 @@ public class ComputerUtilMana {
             if (test) {
                 resetPayment(paymentList);
             } else {
-                System.out.println("ComputerUtilMana: payManaCost() cost was not paid for " + sa + " (" +  sa.getHostCard().getName() + "). Didn't find what to pay for " + toPay);
-                sa.setSkip(true);
+                System.out.println("ComputerUtilMana: payManaCost() cost was not paid for " + sa.toString() + " (" +  sa.getHostCard().getName() + "). Didn't find what to pay for " + toPay);
             }
             return false;
         }
@@ -971,7 +942,8 @@ 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, false)) {
                 return false;
             } else if (ma.getRestrictions() != null && ma.getRestrictions().isInstantSpeed()) {
@@ -989,9 +961,8 @@ public class ComputerUtilMana {
                     continue;
                 }
 
-                if ("Any".equals(s) || ai.getManaPool().canPayForShardWithColor(toPay, ManaAtom.fromName(s))){
+                if ("Any".equals(s) || ai.getManaPool().canPayForShardWithColor(toPay, ManaAtom.fromName(s)))
                     return true;
-                }
             }
             return false;
         }
@@ -1290,7 +1261,7 @@ public class ComputerUtilMana {
      * @param extraMana extraMana
      * @return ManaCost
      */
-    public static ManaCostBeingPaid calculateManaCost(final Cost cost, final SpellAbility sa, final boolean test, final int extraMana, final boolean effect) {
+    public static ManaCostBeingPaid calculateManaCost(final SpellAbility sa, final boolean test, final int extraMana) {
         Card card = sa.getHostCard();
         Zone castFromBackup = null;
         if (test && sa.isSpell() && !card.isInZone(ZoneType.Stack)) {
@@ -1298,22 +1269,16 @@ public class ComputerUtilMana {
             card.setCastFrom(card.getZone() != null ? card.getZone() : null);
         }
 
-        Cost payCosts;
-        if (test) {
-            payCosts = CostAdjustment.adjust(cost, sa, effect);
-        } else {
-            // when not testing CostPayment already handled raise
-            payCosts = cost;
-        }
+        Cost payCosts = CostAdjustment.adjust(sa.getPayCosts(), sa);
         CostPartMana manapart = payCosts != null ? payCosts.getCostMana() : null;
         final ManaCost mana = payCosts != null ? ( manapart == null ? ManaCost.ZERO : manapart.getManaCostFor(sa) ) : ManaCost.NO_COST;
 
-        ManaCostBeingPaid manaCost = new ManaCostBeingPaid(mana);
+        ManaCostBeingPaid cost = new ManaCostBeingPaid(mana);
 
         // Tack xMana Payments into mana here if X is a set value
-        if (manaCost.getXcounter() > 0 || extraMana > 0) {
+        if (cost.getXcounter() > 0 || extraMana > 0) {
             int manaToAdd = 0;
-            int xCounter = manaCost.getXcounter();
+            int xCounter = cost.getXcounter();
             if (test && extraMana > 0) {
                 final int multiplicator = Math.max(xCounter, 1);
                 manaToAdd = extraMana * multiplicator;
@@ -1334,9 +1299,9 @@ public class ComputerUtilMana {
                 xColor = "WUBRGX";
             }
             if (xCounter > 0) {
-                manaCost.setXManaCostPaid(manaToAdd / xCounter, xColor);
+                cost.setXManaCostPaid(manaToAdd / xCounter, xColor);
             } else {
-                manaCost.increaseShard(ManaCostShard.parseNonGeneric(xColor), manaToAdd);
+                cost.increaseShard(ManaCostShard.parseNonGeneric(xColor), manaToAdd);
             }
 
             if (!test) {
@@ -1344,9 +1309,7 @@ public class ComputerUtilMana {
             }
         }
 
-        if (!effect) {
-            CostAdjustment.adjust(manaCost, sa, null, test);
-        }
+        CostAdjustment.adjust(cost, sa, null, test);
 
         if ("NumTimes".equals(sa.getParam("Announce"))) { // e.g. the Adversary cycle
             ManaCost mkCost = sa.getPayCosts().getTotalMana();
@@ -1365,7 +1328,7 @@ public class ComputerUtilMana {
             sa.getHostCard().setCastFrom(castFromBackup);
         }
 
-        return manaCost;
+        return cost;
     }
 
     // This method can be used to estimate the total amount of mana available to the player,
@@ -1386,7 +1349,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;
@@ -1423,7 +1386,7 @@ public class ComputerUtilMana {
         final CardCollectionView list = CardCollection.combine(ai.getCardsIn(ZoneType.Battlefield), ai.getCardsIn(ZoneType.Hand));
         final List<Card> manaSources = CardLists.filter(list, c -> {
             for (final SpellAbility am : getAIPlayableMana(c)) {
-                am.setActivatingPlayer(ai);
+                am.setActivatingPlayer(ai, true);
                 if (!checkPlayable || (am.canPlay() && am.checkRestrictions(ai))) {
                     return true;
                 }
@@ -1499,13 +1462,13 @@ public class ComputerUtilMana {
 
                 if (cost != null) {
                     // 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, false)) {
                         continue;
                     }
 
                     if (!cost.isReusuableResource()) {
-                        for (CostPart part : cost.getCostParts()) {
+                        for(CostPart part : cost.getCostParts()) {
                             if (part instanceof CostSacrifice && !part.payCostFromSource()) {
                                 unpreferredCost = true;
                             }
@@ -1517,7 +1480,7 @@ public class ComputerUtilMana {
                 AbilitySub sub = m.getSubAbility();
                 // We really shouldn't be hardcoding names here. ChkDrawback should just return true for them
                 if (sub != null && !card.getName().equals("Pristine Talisman") && !card.getName().equals("Zhur-Taa Druid")) {
-                    if (!SpellApiToAi.Converter.get(sub).chkDrawbackWithSubs(ai, sub).willingToPlay()) {
+                    if (!SpellApiToAi.Converter.get(sub.getApi()).chkDrawbackWithSubs(ai, sub)) {
                         continue;
                     }
                     needsLimitedResources = true; // TODO: check for good drawbacks (gainLife)
@@ -1583,7 +1546,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;
                 }
@@ -1596,8 +1559,10 @@ public class ComputerUtilMana {
 
                 // don't use abilities with dangerous drawbacks
                 AbilitySub sub = m.getSubAbility();
-                if (sub != null && !SpellApiToAi.Converter.get(sub).chkDrawbackWithSubs(ai, sub).willingToPlay()) {
-                    continue;
+                if (sub != null) {
+                    if (!SpellApiToAi.Converter.get(sub.getApi()).chkDrawbackWithSubs(ai, sub)) {
+                        continue;
+                    }
                 }
 
                 manaMap.get(ManaAtom.GENERIC).add(m); // add to generic source list
@@ -1665,6 +1630,7 @@ public class ComputerUtilMana {
                                 if (replaced.contains("C")) {
                                     manaMap.put(ManaAtom.COLORLESS, m);
                                 }
+
                             }
                         }
                     }

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

@@ -1,5 +1,7 @@
 package forge.ai;
 
+import com.google.common.base.Function;
+
 import forge.game.GameEntity;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
@@ -11,11 +13,8 @@ import forge.game.spellability.SpellAbility;
 import forge.game.staticability.StaticAbilityAssignCombatDamageAsUnblocked;
 import forge.game.staticability.StaticAbilityCantAttackBlock;
 import forge.game.staticability.StaticAbilityMustAttack;
-import forge.game.trigger.Trigger;
-import forge.game.trigger.TriggerType;
 
 import java.util.List;
-import java.util.function.Function;
 
 public class CreatureEvaluator implements Function<Card, Integer> {
     @Override
@@ -160,6 +159,12 @@ public class CreatureEvaluator implements Function<Card, Integer> {
             value += addValue(20, "protection");
         }
 
+        for (final SpellAbility sa : c.getSpellAbilities()) {
+            if (sa.isAbility()) {
+                value += addValue(evaluateSpellAbility(sa), "sa: " + sa);
+            }
+        }
+
         // paired creatures are more valuable because they grant a bonus to the other creature
         if (c.isPaired()) {
             value += addValue(14, "paired");
@@ -207,7 +212,11 @@ public class CreatureEvaluator implements Function<Card, Integer> {
             value += addValue(1, "untapped");
         }
 
-        if (!c.canUntap(c.getController(), true)) {
+        if (!c.getManaAbilities().isEmpty()) {
+            value += addValue(10, "manadork");
+        }
+
+        if (c.hasKeyword("CARDNAME doesn't untap during your untap step.")) {
             if (c.isTapped()) {
                 value = addValue(50 + (c.getCMC() * 5), "tapped-useless"); // reset everything - useless
             } else {
@@ -216,64 +225,30 @@ public class CreatureEvaluator implements Function<Card, Integer> {
         } else {
             value -= subValue(10 * c.getCounters(CounterEnumType.STUN), "stunned");
         }
-
-        for (final SpellAbility sa : c.getSpellAbilities()) {
-            if (sa.isAbility()) {
-                value += addValue(evaluateSpellAbility(sa), "sa: " + sa);
-            }
+        if (c.hasSVar("EndOfTurnLeavePlay")) {
+            value -= subValue(50, "eot-leaves");
+        } else if (c.hasKeyword(Keyword.CUMULATIVE_UPKEEP)) {
+            value -= subValue(30, "cupkeep");
+        } else if (c.hasStartOfKeyword("UpkeepCost")) {
+            value -= subValue(20, "sac-unless");
+        } else if (c.hasKeyword(Keyword.ECHO) && c.cameUnderControlSinceLastUpkeep()) {
+            value -= subValue(10, "echo-unpaid");
         }
-
-        if (!c.getManaAbilities().isEmpty()) {
-            value += addValue(10, "manadork");
+        if (c.hasKeyword(Keyword.FADING)) {
+            value -= subValue(20 / (Math.max(1, c.getCounters(CounterEnumType.FADE))), "fading");
+        }
+        if (c.hasKeyword(Keyword.VANISHING)) {
+            value -= subValue(20 / (Math.max(1, c.getCounters(CounterEnumType.TIME))), "vanishing");
         }
-
         // use scaling because the creature is only available halfway
         if (c.hasKeyword(Keyword.PHASING)) {
             value -= subValue(Math.max(20, value / 2), "phasing");
         }
 
-        if (c.hasSVar("EndOfTurnLeavePlay")) {
-            value -= subValue(50, "eot-leaves");
-        } else {
-            for (Trigger t : c.getTriggers()) {
-                if (!TriggerType.Phase.equals(t.getMode())) {
-                    continue;
-                }
-                if (!"Upkeep".equals(t.getParam("Phase"))) {
-                    continue;
-                }
-
-                if (t.isKeyword(Keyword.CUMULATIVE_UPKEEP)) {
-                    value -= subValue(30, "cupkeep");
-                } else if (t.isKeyword(Keyword.ECHO) && c.cameUnderControlSinceLastUpkeep()) {
-                    value -= subValue(10, "echo-unpaid");
-                }
-                if (t.isKeyword(Keyword.FADING)) {
-                    value -= subValue(20 / (Math.max(1, c.isInPlay() ? c.getCounters(CounterEnumType.FADE) : c.getKeywordMagnitude(Keyword.FADING))), "fading");
-                }
-                if (t.isKeyword(Keyword.VANISHING)) {
-                    value -= subValue(20 / (Math.max(1, c.isInPlay() ? c.getCounters(CounterEnumType.TIME) : c.getKeywordMagnitude(Keyword.VANISHING))), "vanishing");
-                }
-
-                SpellAbility ab = t.ensureAbility();
-                if (ab == null) {
-                    continue;
-                }
-                if (ApiType.DealDamage.equals(ab.getApi())) {
-                    if (!"You".equals(ab.getParamOrDefault("Defined", "You"))) {
-                        continue;
-                    }
-                    if (c.getController().canLoseLife()) {
-                        value -= subValue(20, "upkeep-dmg");
-                    }
-                } else if (ApiType.Sacrifice.equals(ab.getApi())) {
-                    if (!ab.hasParam("UnlessCost")) {
-                        continue;
-                    }
-                    value -= subValue(20, "sac-unless");
-                }
-            }
-        }
+        // TODO no longer a KW
+        if (c.hasStartOfKeyword("At the beginning of your upkeep, CARDNAME deals")) {
+            value -= subValue(20, "upkeep-dmg");
+        } 
 
         // card-specific evaluation modifier
         if (c.hasSVar("AIEvaluationModifier")) {
@@ -305,9 +280,8 @@ public class CreatureEvaluator implements Function<Card, Integer> {
                     }
                 }
             }
-        } else if (ComputerUtilCost.isSacrificeSelfCost(sa.getPayCosts())) {
-            return -10; // can be sacrificed in response to ability or spell, thus, less prioritable
         }
+
         // default value
         return 10;
     }

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

@@ -13,7 +13,6 @@ import forge.card.mana.ManaAtom;
 import forge.game.Game;
 import forge.game.GameEntity;
 import forge.game.ability.AbilityFactory;
-import forge.game.ability.ApiType;
 import forge.game.ability.effects.DetachedCardEffect;
 import forge.game.card.*;
 import forge.game.card.token.TokenInfo;
@@ -62,7 +61,6 @@ public abstract class GameState {
         private int landsPlayed = 0;
         private int landsPlayedLastTurn = 0;
         private int numRingTemptedYou = 0;
-        private int speed = 0;
         private String precast = null;
         private String putOnStack = null;
         private final Map<ZoneType, String> cardTexts = new EnumMap<>(ZoneType.class);
@@ -139,7 +137,6 @@ public abstract class GameState {
             sb.append(TextUtil.concatNoSpace(prefix + "landsplayed=", String.valueOf(p.landsPlayed), "\n"));
             sb.append(TextUtil.concatNoSpace(prefix + "landsplayedlastturn=", String.valueOf(p.landsPlayedLastTurn), "\n"));
             sb.append(TextUtil.concatNoSpace(prefix + "numringtemptedyou=", String.valueOf(p.numRingTemptedYou), "\n"));
-            sb.append(TextUtil.concatNoSpace(prefix + "speed=", String.valueOf(p.speed), "\n"));
             if (!p.counters.isEmpty()) {
                 sb.append(TextUtil.concatNoSpace(prefix + "counters=", p.counters, "\n"));
             }
@@ -170,7 +167,6 @@ public abstract class GameState {
             p.counters = countersToString(player.getCounters());
             p.manaPool = processManaPool(player.getManaPool());
             p.numRingTemptedYou = player.getNumRingTemptedYou();
-            p.speed = player.getSpeed();
             playerStates.add(p);
         }
 
@@ -229,7 +225,7 @@ public abstract class GameState {
                 if (card instanceof DetachedCardEffect) {
                     continue;
                 }
-                int playerIndex = game.getPlayers().indexOf(card.getZone().getPlayer());
+                int playerIndex = game.getPlayers().indexOf(card.getController());
                 addCard(zone, playerStates.get(playerIndex).cardTexts, card);
             }
         }
@@ -264,14 +260,12 @@ public abstract class GameState {
             }
 
             if (c.hasMergedCard()) {
-                String suffix = c.getTopMergedCard().hasPaperFoil() ? "+" : "";
                 // we have to go by the current top card name here
-                newText.append(c.getTopMergedCard().getPaperCard().getName()).append(suffix).append("|Set:")
+                newText.append(c.getTopMergedCard().getPaperCard().getName()).append("|Set:")
                         .append(c.getTopMergedCard().getPaperCard().getEdition()).append("|Art:")
                         .append(c.getTopMergedCard().getPaperCard().getArtIndex());
             } else {
-                String suffix = c.hasPaperFoil() ? "+" : "";
-                newText.append(c.getPaperCard().getName()).append(suffix).append("|Set:").append(c.getPaperCard().getEdition())
+                newText.append(c.getPaperCard().getName()).append("|Set:").append(c.getPaperCard().getEdition())
                         .append("|Art:").append(c.getPaperCard().getArtIndex());
             }
         }
@@ -321,21 +315,18 @@ public abstract class GameState {
                     newText.append(":Cloaked");
                 }
             }
-            if (c.getCurrentStateName().equals(CardStateName.Flipped)) {
+            if (c.getCurrentStateName().equals(CardStateName.Transformed)) {
+                newText.append("|Transformed");
+            } else if (c.getCurrentStateName().equals(CardStateName.Flipped)) {
                 newText.append("|Flipped");
             } else if (c.getCurrentStateName().equals(CardStateName.Meld)) {
                 newText.append("|Meld");
                 if (c.getMeldedWith() != null) {
-                    String suffix = c.getMeldedWith().hasPaperFoil() ? "+" : "";
                     newText.append(":");
-                    newText.append(c.getMeldedWith().getName()).append(suffix);
-                }
-            } else if (c.getCurrentStateName().equals(CardStateName.Backside)) {
-                if (c.isModal()) {
-                    newText.append("|Modal");
-                } else {
-                    newText.append("|Transformed");
+                    newText.append(c.getMeldedWith().getName());
                 }
+            } else if (c.getCurrentStateName().equals(CardStateName.Modal)) {
+                newText.append("|Modal");
             }
 
             if (c.getPlayerAttachedTo() != null) {
@@ -551,8 +542,6 @@ public abstract class GameState {
             getPlayerState(categoryName).landsPlayedLastTurn = Integer.parseInt(categoryValue);
         } else if (categoryName.endsWith("numringtemptedyou")) {
             getPlayerState(categoryName).numRingTemptedYou = Integer.parseInt(categoryValue);
-        } else if (categoryName.endsWith("speed")) {
-            getPlayerState(categoryName).speed = Integer.parseInt(categoryValue);
         } else if (categoryName.endsWith("play") || categoryName.endsWith("battlefield")) {
             getPlayerState(categoryName).cardTexts.put(ZoneType.Battlefield, categoryValue);
         } else if (categoryName.endsWith("hand")) {
@@ -1144,7 +1133,7 @@ public abstract class GameState {
             p.getZone(zt).removeAllCards(true);
         }
 
-        p.getCommanders().clear();
+        p.setCommanders(Lists.newArrayList());
         p.clearTheRing();
 
         Map<ZoneType, CardCollectionView> playerCards = new EnumMap<>(ZoneType.class);
@@ -1157,7 +1146,6 @@ public abstract class GameState {
         p.setLandsPlayedThisTurn(state.landsPlayed);
         p.setLandsPlayedLastTurn(state.landsPlayedLastTurn);
         p.setNumRingTemptedYou(state.numRingTemptedYou);
-        p.setSpeed(state.speed);
 
         p.clearPaidForSA();
 
@@ -1220,7 +1208,6 @@ public abstract class GameState {
                 p.setRingLevel(i);
             }
         }
-        if (state.speed > 0) p.createSpeedEffect();
     }
 
     /**
@@ -1268,7 +1255,7 @@ public abstract class GameState {
             } else if (cardinfo[0].startsWith("T:")) {
                 String tokenStr = cardinfo[0].substring(2);
                 PaperToken token = StaticData.instance().getAllTokens().getToken(tokenStr,
-                        setCode != null ? setCode : CardEdition.UNKNOWN_CODE);
+                        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;
@@ -1311,13 +1298,13 @@ public abstract class GameState {
                 } else if (info.startsWith("FaceDown")) {
                     c.turnFaceDown(true);
                     if (info.endsWith("Manifested")) {
-                        c.setManifested(new SpellAbility.EmptySa(ApiType.Manifest, c));
+                        c.setManifested(true);
                     }
                     if (info.endsWith("Cloaked")) {
-                        c.setCloaked(new SpellAbility.EmptySa(ApiType.Cloak, c));
+                        c.setCloaked(true);
                     }
-                } else if (info.startsWith("Transformed") || info.startsWith("Modal")) {
-                    c.setState(CardStateName.Backside, true);
+                } else if (info.startsWith("Transformed")) {
+                    c.setState(CardStateName.Transformed, true);
                     c.setBackSide(true);
                 } else if (info.startsWith("Flipped")) {
                     c.setState(CardStateName.Flipped, true);
@@ -1335,6 +1322,9 @@ public abstract class GameState {
                     }
                     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 | ForgetOnMoved$ Exile | Duration$ Permanent | ConditionDefined$ Self | ConditionPresent$ Card.!copiedSpell";
@@ -1411,7 +1401,7 @@ public abstract class GameState {
                 } else if (info.equals("Foretold")) {
                     c.setForetold(true);
                     c.turnFaceDown(true);
-                    c.addMayLookFaceDownExile(c.getOwner());
+                    c.addMayLookTemp(c.getOwner());
                 } else if (info.equals("ForetoldThisTurn")) {
                     c.setTurnInZone(turn);
                 } else if (info.equals("IsToken")) {

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

@@ -1,5 +1,7 @@
 package forge.ai;
 
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
 import com.google.common.collect.*;
 import forge.LobbyPlayer;
 import forge.ai.ability.ProtectAi;
@@ -15,14 +17,13 @@ import forge.game.*;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
 import forge.game.ability.effects.CharmEffect;
-import forge.game.ability.effects.RollDiceEffect;
 import forge.game.card.*;
+import forge.game.card.CardPredicates.Presets;
 import forge.game.combat.Combat;
 import forge.game.cost.Cost;
 import forge.game.cost.CostEnlist;
 import forge.game.cost.CostPart;
 import forge.game.cost.CostPartMana;
-import forge.game.cost.CostPayment;
 import forge.game.keyword.Keyword;
 import forge.game.keyword.KeywordInterface;
 import forge.game.mana.Mana;
@@ -34,21 +35,21 @@ import forge.game.player.*;
 import forge.game.replacement.ReplacementEffect;
 import forge.game.spellability.*;
 import forge.game.staticability.StaticAbility;
-import forge.game.trigger.Trigger;
-import forge.game.trigger.TriggerType;
 import forge.game.trigger.WrappedAbility;
 import forge.game.zone.PlayerZone;
 import forge.game.zone.ZoneType;
 import forge.item.PaperCard;
-import forge.util.*;
+import forge.util.Aggregates;
+import forge.util.ITriggerEvent;
+import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 import forge.util.collect.FCollectionView;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
 
+import java.security.InvalidParameterException;
 import java.util.*;
-import java.util.function.Predicate;
 
 
 /**
@@ -301,14 +302,6 @@ public class PlayerControllerAi extends PlayerController {
         return brains.chooseCardsForEffect(sourceList, sa, min, max, isOptional, params);
     }
 
-    @Override
-    public List<Card> chooseContraptionsToCrank(List<Card> contraptions) {
-        return CardLists.filter(contraptions, c -> {
-            Trigger crankTrigger = IterableUtil.find(c.getTriggers(), t -> t.getMode() == TriggerType.CrankContraption);
-            return confirmTrigger(new WrappedAbility(crankTrigger, crankTrigger.getOverridingAbility(), player));
-        });
-    }
-
     @Override
     public boolean helpPayForAssistSpell(ManaCostBeingPaid cost, SpellAbility sa, int max, int requested) {
         int toPay = getAi().attemptToAssist(sa, max, requested);
@@ -352,7 +345,11 @@ public class PlayerControllerAi extends PlayerController {
         if (delayedReveal != null) {
             reveal(delayedReveal.getCards(), delayedReveal.getZone(), delayedReveal.getOwner(), delayedReveal.getMessagePrefix());
         }
-        return SpellApiToAi.Converter.get(sa).chooseSingleEntity(player, sa, (FCollection<T>)optionList, isOptional, targetedPlayer, params);
+        ApiType api = sa.getApi();
+        if (null == api) {
+            throw new InvalidParameterException("SA is not api-based, this is not supported yet");
+        }
+        return SpellApiToAi.Converter.get(api).chooseSingleEntity(player, sa, (FCollection<T>)optionList, isOptional, targetedPlayer, params);
     }
 
     @Override
@@ -394,7 +391,11 @@ public class PlayerControllerAi extends PlayerController {
     @Override
     public SpellAbility chooseSingleSpellForEffect(List<SpellAbility> spells, SpellAbility sa, String title,
             Map<String, Object> params) {
-        return SpellApiToAi.Converter.get(sa).chooseSingleSpellAbility(player, sa, spells, params);
+        ApiType api = sa.getApi();
+        if (null == api) {
+            throw new InvalidParameterException("SA is not api-based, this is not supported yet");
+        }
+        return SpellApiToAi.Converter.get(api).chooseSingleSpellAbility(player, sa, spells, params);
     }
 
     @Override
@@ -454,17 +455,13 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @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)
+    public Player chooseStartingPlayer(boolean isFirstgame) {
+        return this.player; // AI is brave :)
     }
 
     @Override
-    public boolean confirmReplacementEffect(ReplacementEffect replacementEffect, SpellAbility effectSA, GameEntity affected, String question) {
-        Card host = replacementEffect.getHostCard();
-        if (host.hasAlternateState()) {
-            host = host.getGame().getCardState(host);
-        }
-        return brains.aiShouldRun(replacementEffect, effectSA, host, affected);
+    public CardCollection orderBlockers(Card attacker, CardCollection blockers) {
+        return AiBlockController.orderBlockers(attacker, blockers);
     }
 
     @Override
@@ -487,11 +484,6 @@ public class PlayerControllerAi extends PlayerController {
         return chosenAttackers;
     }
 
-    @Override
-    public CardCollection orderBlockers(Card attacker, CardCollection blockers) {
-        return AiBlockController.orderBlockers(attacker, blockers);
-    }
-
     @Override
     public CardCollection orderBlocker(Card attacker, Card blocker, CardCollection oldBlockers) {
     	return AiBlockController.orderBlocker(attacker, blocker, oldBlockers);
@@ -578,7 +570,7 @@ public class PlayerControllerAi extends PlayerController {
 
         if (destinationZone == ZoneType.Graveyard) {
             // In presence of Volrath's Shapeshifter in deck, try to place the best creature on top of the graveyard
-            if (getGame().getCardsInGame().anyMatch(card -> {
+            if (Iterables.any(getGame().getCardsInGame(), card -> {
                 // need a custom predicate here since Volrath's Shapeshifter may have a different name OTB
                 return card.getOriginalState(CardStateName.Original).getName().equals("Volrath's Shapeshifter");
             })) {
@@ -622,7 +614,7 @@ public class PlayerControllerAi extends PlayerController {
                 }
             }
 
-            int landsOTB = CardLists.count(p.getCardsIn(ZoneType.Battlefield), CardPredicates.LANDS_PRODUCING_MANA);
+            int landsOTB = CardLists.count(p.getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.LANDS_PRODUCING_MANA);
 
             if (!p.isOpponentOf(player)) {
                 if (landsOTB <= 2) {
@@ -683,6 +675,20 @@ public class PlayerControllerAi extends PlayerController {
                : ComputerUtil.getCardsToDiscardFromOpponent(player, p, sa, validCards, min, max);
     }
 
+    @Override
+    public void playSpellAbilityForFree(SpellAbility copySA, boolean mayChooseNewTargets) {
+        // Ai is known to set targets in doTrigger, so if it cannot choose new targets, we won't call canPlays
+        if (mayChooseNewTargets) {
+            if (copySA instanceof Spell) {
+                Spell spell = (Spell) copySA;
+                ((PlayerControllerAi) player.getController()).getAi().canPlayFromEffectAI(spell, true, true);
+            } else {
+                getAi().canPlaySa(copySA);
+            }
+        }
+        ComputerUtil.playSpellAbilityForFree(player, copySA);
+    }
+
     @Override
     public void playSpellAbilityNoStack(SpellAbility effectSA, boolean canSetupTargets) {
         if (canSetupTargets)
@@ -697,7 +703,7 @@ public class PlayerControllerAi extends PlayerController {
 
     @Override
     public CardCollectionView chooseCardsToDiscardUnlessType(int num, CardCollectionView hand, String uType, SpellAbility sa) {
-        Iterable<Card> cardsOfType = IterableUtil.filter(hand, CardPredicates.restriction(uType.split(","), sa.getActivatingPlayer(), sa.getHostCard(), sa));
+        Iterable<Card> cardsOfType = Iterables.filter(hand, CardPredicates.restriction(uType.split(","), sa.getActivatingPlayer(), sa.getHostCard(), sa));
         if (!Iterables.isEmpty(cardsOfType)) {
             Card toDiscard = Aggregates.itemWithMin(cardsOfType, Card::getCMC);
             return new CardCollection(toDiscard);
@@ -711,8 +717,8 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @Override
-    public String chooseSomeType(String kindOfType, SpellAbility sa, Collection<String> validTypes, boolean isOptional) {
-        String chosen = ComputerUtil.chooseSomeType(player, kindOfType, sa, validTypes);
+    public String chooseSomeType(String kindOfType, SpellAbility sa, Collection<String> validTypes, List<String> invalidTypes, boolean isOptional) {
+        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);
@@ -730,14 +736,6 @@ public class PlayerControllerAi extends PlayerController {
         return Aggregates.random(sectors);
     }
 
-    @Override
-    public int chooseSprocket(Card assignee, boolean forceDifferent) {
-        int nextSprocket = (player.getCrankCounter() % 3) + 1;
-        if(forceDifferent && nextSprocket == assignee.getSprocket())
-            return (nextSprocket % 3) + 1;
-        return nextSprocket;
-    }
-
     @Override
     public PlanarDice choosePDRollToIgnore(List<PlanarDice> rolls) {
         //TODO create AI logic for this
@@ -750,30 +748,6 @@ public class PlayerControllerAi extends PlayerController {
         return Aggregates.random(rolls);
     }
 
-    @Override
-    public List<Integer> chooseDiceToReroll(List<Integer> rolls) {
-        //TODO create AI logic for this
-        return new ArrayList<>();
-    }
-
-    @Override
-    public Integer chooseRollToModify(List<Integer> rolls) {
-        //TODO create AI logic for this
-        return Aggregates.random(rolls);
-    }
-
-    @Override
-    public RollDiceEffect.DieRollResult chooseRollToSwap(List<RollDiceEffect.DieRollResult> rolls) {
-        //TODO create AI logic for this
-        return Aggregates.random(rolls);
-    }
-
-    @Override
-    public String chooseRollSwapValue(List<String> swapChoices, Integer currentResult, int power, int toughness) {
-        //TODO create AI logic for this
-        return Aggregates.random(swapChoices);
-    }
-
     @Override
     public boolean mulliganKeepHand(Player firstPlayer, int cardsToReturn)  {
         return !ComputerUtil.wantMulligan(player, cardsToReturn);
@@ -790,13 +764,13 @@ public class PlayerControllerAi extends PlayerController {
         for (int i = 0; i < cardsToReturn; i++) {
             hand.removeAll(toReturn);
 
-            CardCollection landsInHand = CardLists.filter(hand, CardPredicates.LANDS);
-            int numLandsInHand = landsInHand.size() - CardLists.count(toReturn, CardPredicates.LANDS);
+            CardCollection landsInHand = CardLists.filter(hand, Presets.LANDS);
+            int numLandsInHand = landsInHand.size() - CardLists.count(toReturn, Presets.LANDS);
 
             // If we're flooding with lands, get rid of the worst land we have
             if (numLandsInHand > 0 && numLandsInHand > numLandsDesired) {
-                CardCollection producingLands = CardLists.filter(landsInHand, CardPredicates.LANDS_PRODUCING_MANA);
-                CardCollection nonProducingLands = CardLists.filter(landsInHand, CardPredicates.LANDS_PRODUCING_MANA.negate());
+                CardCollection producingLands = CardLists.filter(landsInHand, Presets.LANDS_PRODUCING_MANA);
+                CardCollection nonProducingLands = CardLists.filter(landsInHand, Predicates.not(Presets.LANDS_PRODUCING_MANA));
                 Card worstLand = nonProducingLands.isEmpty() ? ComputerUtilCard.getWorstLand(producingLands)
                         : ComputerUtilCard.getWorstLand(nonProducingLands);
                 toReturn.add(worstLand);
@@ -864,8 +838,23 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @Override
-    public Player chooseStartingPlayer(boolean isFirstgame) {
-        return this.player; // AI is brave :)
+    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(), true);
+        ability.setCardState(sa.getCardState());
+
+        if (ComputerUtil.playNoStack(c.getController(), ability, getGame(), true)) {
+            // transfer this info for Balduvian Fallen
+            sa.setPayingMana(ability.getPayingMana());
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public List<SpellAbility> chooseSaToActivateFromOpeningHand(List<SpellAbility> usableFromOpeningHand) {
+        return brains.chooseSaToActivateFromOpeningHand(usableFromOpeningHand);
     }
 
     @Override
@@ -884,11 +873,6 @@ public class PlayerControllerAi extends PlayerController {
         return bestZone;
     }
 
-    @Override
-    public List<SpellAbility> chooseSaToActivateFromOpeningHand(List<SpellAbility> usableFromOpeningHand) {
-        return brains.chooseSaToActivateFromOpeningHand(usableFromOpeningHand);
-    }
-
     @Override
     public int chooseNumber(SpellAbility sa, String title, int min, int max) {
         return brains.chooseNumber(sa, title, min, max);
@@ -896,7 +880,11 @@ public class PlayerControllerAi extends PlayerController {
 
     @Override
     public int chooseNumber(SpellAbility sa, String string, int min, int max, Map<String, Object> params) {
-        return SpellApiToAi.Converter.get(sa).chooseNumber(player, sa, min, max, params);
+        ApiType api = sa.getApi();
+        if (null == api) {
+            throw new InvalidParameterException("SA is not api-based, this is not supported yet");
+        }
+        return SpellApiToAi.Converter.get(api).chooseNumber(player, sa, min, max, params);
     }
 
     @Override
@@ -981,6 +969,7 @@ public class PlayerControllerAi extends PlayerController {
                     }
                 }
                 return defaultVal != null && defaultVal;
+            case UntapTimeVault: return false; // TODO Should AI skip his turn for time vault?
             case LeftOrRight: return brains.chooseDirection(sa);
             case OddsOrEvens: return brains.chooseEvenOdd(sa); // false is Odd, true is Even
             default:
@@ -998,7 +987,11 @@ public class PlayerControllerAi extends PlayerController {
      */
     @Override
     public boolean chooseBinary(SpellAbility sa, String question, BinaryChoiceType kindOfChoice, Map<String, Object> params) {
-        return SpellApiToAi.Converter.get(sa).chooseBinary(kindOfChoice, sa, params);
+        ApiType api = sa.getApi();
+        if (null == api) {
+            throw new InvalidParameterException("SA is not api-based, this is not supported yet");
+        }
+        return SpellApiToAi.Converter.get(api).chooseBinary(kindOfChoice, sa, params);
     }
 
     @Override
@@ -1050,6 +1043,12 @@ public class PlayerControllerAi extends PlayerController {
         return Iterables.getFirst(colors, MagicColor.WHITE);
     }
 
+    @Override
+    public ICardFace chooseSingleCardFace(SpellAbility sa, String message,
+            Predicate<ICardFace> cpp, String name) {
+        throw new UnsupportedOperationException("Should not be called for AI"); // or implement it if you know how
+    }
+
     @Override
     public List<String> chooseColors(String message, SpellAbility sa, int min, int max, List<String> options) {
         return ComputerUtilCard.chooseColor(sa, min, max, options);
@@ -1068,7 +1067,11 @@ public class PlayerControllerAi extends PlayerController {
         if (options.size() <= 1) {
             return Iterables.getFirst(options, null);
         }
-        return SpellApiToAi.Converter.get(sa).chooseCounterType(options, sa, params);
+        ApiType api = sa.getApi();
+        if (null == api) {
+            throw new InvalidParameterException("SA is not api-based, this is not supported yet");
+        }
+        return SpellApiToAi.Converter.get(api).chooseCounterType(options, sa, params);
     }
 
     @Override
@@ -1077,7 +1080,7 @@ public class PlayerControllerAi extends PlayerController {
             return Iterables.getFirst(options, null);
         }
         List<String> possible = Lists.newArrayList();
-        CardCollection oppUntappedCreatures = CardLists.filter(player.getOpponents().getCreaturesInPlay(), CardPredicates.UNTAPPED);
+        CardCollection oppUntappedCreatures = CardLists.filter(player.getOpponents().getCreaturesInPlay(), CardPredicates.Presets.UNTAPPED);
         if (tgtCard != null) {
             for (String kw : options) {
                 if (tgtCard.hasKeyword(kw)) {
@@ -1131,9 +1134,19 @@ public class PlayerControllerAi extends PlayerController {
         }
         if (!possible.isEmpty()) {
             return Aggregates.random(possible);
+        } else {
+            return Aggregates.random(options); // if worst comes to worst, at least do something
         }
+    }
 
-        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
@@ -1210,37 +1223,32 @@ public class PlayerControllerAi extends PlayerController {
         return choice;
     }
 
-    @Override
-    public boolean payManaCost(ManaCost toPay, CostPartMana costPartMana, SpellAbility sa, String prompt /* ai needs hints as well */, ManaConversionMatrix matrix, boolean effect) {
-        return ComputerUtilMana.payManaCost(new Cost(toPay, effect), player, sa, effect);
-    }
-
-    @Override
-    public boolean payCombatCost(Card c, Cost cost, SpellAbility sa, String prompt) {
-        if (ComputerUtil.playNoStack(c.getController(), sa, getGame(), true)) {
-            return true;
-        }
-        return false;
-    }
-
     @Override
     public boolean payCostToPreventEffect(Cost cost, SpellAbility sa, boolean alreadyPaid, FCollectionView<Player> allPayers) {
-        if (SpellApiToAi.Converter.get(sa).willPayUnlessCost(sa, player, cost, alreadyPaid, allPayers)) {
-            if (!ComputerUtilCost.canPayCost(cost, sa, player, true)) {
-                return false;
+        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, true);
+        emptyAbility.setTriggeringObjects(sa.getTriggeringObjects());
+        emptyAbility.setReplacingObjects(sa.getReplacingObjects());
+        emptyAbility.setTrigger(sa.getTrigger());
+        emptyAbility.setReplacementEffect(sa.getReplacementEffect());
+        emptyAbility.setSVars(sa.getSVars());
+        emptyAbility.setCardState(sa.getCardState());
+        emptyAbility.setXManaCostPaid(sa.getRootAbility().getXManaCostPaid());
+        emptyAbility.setTargets(sa.getTargets().clone());
+
+        if (ComputerUtilCost.willPayUnlessCost(sa, player, cost, alreadyPaid, allPayers)) {
+            boolean result = ComputerUtil.playNoStack(player, emptyAbility, getGame(), true); // AI needs something to resolve to pay that cost
+            if (!emptyAbility.getPaidHash().isEmpty()) {
+                // report info to original sa (Argentum Masticore)
+                sa.setPaidHash(emptyAbility.getPaidHash());
             }
-
-            final CostPayment pay = new CostPayment(cost, sa);
-            return pay.payComputerCosts(new AiCostDecision(player, sa, true));
+            return result;
         }
         return false;
     }
 
-    public boolean payCostDuringRoll(final Cost cost, final SpellAbility sa, final FCollectionView<Player> allPayers) {
-        // TODO logic for AI to pay rerolls and modification costs
-        return false;
-    }
-
     @Override
     public void orderAndPlaySimultaneousSa(List<SpellAbility> activePlayerSAs) {
         for (final SpellAbility sa : getAi().orderPlaySa(activePlayerSAs)) {
@@ -1297,11 +1305,15 @@ public class PlayerControllerAi extends PlayerController {
 
     @Override
     public boolean playSaFromPlayEffect(SpellAbility tgtSA) {
-        boolean optional = !tgtSA.getPayCosts().isMandatory();
+        boolean optional = tgtSA.hasParam("Optional");
         boolean noManaCost = tgtSA.hasParam("WithoutManaCost");
-        if (tgtSA instanceof Spell spell) { // Isn't it ALWAYS a spell?
+        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 (brains.canPlayFromEffectAI(spell, !optional, noManaCost) == AiPlayDecision.WillPlay || !optional) {
+                if (noManaCost) {
+                    return ComputerUtil.playSpellAbilityWithoutPayingManaCost(player, tgtSA, getGame());
+                }
                 return ComputerUtil.playStack(tgtSA, player, getGame());
             }
             return false; // didn't play spell
@@ -1330,7 +1342,7 @@ public class PlayerControllerAi extends PlayerController {
             // Probably want to see if the face up pile has anything "worth it", then potentially take face down pile
             return pile1.size() >= pile2.size();
         } else {
-            boolean allCreatures = IterableUtil.all(Iterables.concat(pile1, pile2), CardPredicates.CREATURES);
+            boolean allCreatures = Iterables.all(Iterables.concat(pile1, pile2), CardPredicates.Presets.CREATURES);
             int cmc1 = allCreatures ? ComputerUtilCard.evaluateCreatureList(pile1) : ComputerUtilCard.evaluatePermanentList(pile1);
             int cmc2 = allCreatures ? ComputerUtilCard.evaluateCreatureList(pile2) : ComputerUtilCard.evaluatePermanentList(pile2);
 
@@ -1351,11 +1363,6 @@ public class PlayerControllerAi extends PlayerController {
         // Ai won't understand that anyway
     }
 
-    @Override
-    public void revealUnsupported(Map<Player, List<PaperCard>> unsupported) {
-        // Ai won't understand that anyway
-    }
-
     @Override
     public Map<DeckSection, List<? extends PaperCard>> complainCardsCantPlayWell(Deck myDeck) {
         // TODO check if profile detection set to Auto
@@ -1375,6 +1382,11 @@ public class PlayerControllerAi extends PlayerController {
         return losses;
     }
 
+    @Override
+    public boolean payManaCost(ManaCost toPay, CostPartMana costPartMana, SpellAbility sa, String prompt /* ai needs hints as well */, ManaConversionMatrix matrix, boolean effect) {
+        return ComputerUtilMana.payManaCost(player, sa, effect);
+    }
+
     @Override
     public Map<Card, ManaCostShard> chooseCardsForConvokeOrImprovise(SpellAbility sa, ManaCost manaCost, CardCollectionView untappedCards, boolean improvise) {
         final Player ai = sa.getActivatingPlayer();
@@ -1409,11 +1421,6 @@ public class PlayerControllerAi extends PlayerController {
         return ComputerUtilMana.getConvokeOrImproviseFromList(manaCost, untapped, improvise);
     }
 
-    @Override
-    public String chooseCardName(SpellAbility sa, List<ICardFace> faces, String message) {
-        return SpellApiToAi.Converter.get(sa).chooseCardName(player, sa, faces);
-    }
-
     @Override
     public String chooseCardName(SpellAbility sa, Predicate<ICardFace> cpp, String valid, String message) {
         if (sa.hasParam("AILogic")) {
@@ -1428,14 +1435,14 @@ public class PlayerControllerAi extends PlayerController {
                 oppLibrary = CardLists.getValidCards(oppLibrary, valid, source.getController(), source, sa);
             }
 
-            if (source != null && source.getState(CardStateName.Original).hasKeyword(Keyword.HIDDEN_AGENDA)) {
+            if (source != null && source.getState(CardStateName.Original).hasIntrinsicKeyword("Hidden agenda")) {
                 // If any Conspiracies are present, try not to choose the same name twice
                 // (otherwise the AI will spam the same name)
                 for (Card consp : player.getCardsIn(ZoneType.Command)) {
-                    if (consp.getState(CardStateName.Original).hasKeyword(Keyword.HIDDEN_AGENDA)) {
+                    if (consp.getState(CardStateName.Original).hasIntrinsicKeyword("Hidden agenda")) {
                         String chosenName = consp.getNamedCard();
                         if (!chosenName.isEmpty()) {
-                            aiLibrary = CardLists.filter(aiLibrary, CardPredicates.nameNotEquals(chosenName));
+                            aiLibrary = CardLists.filter(aiLibrary, Predicates.not(CardPredicates.nameEquals(chosenName)));
                         }
                     }
                 }
@@ -1468,7 +1475,7 @@ public class PlayerControllerAi extends PlayerController {
             }
         } else {
             CardCollectionView list = CardLists.filterControlledBy(getGame().getCardsInGame(), player.getOpponents());
-            list = CardLists.filter(list, CardPredicates.NON_LANDS);
+            list = CardLists.filter(list, Predicates.not(Presets.LANDS));
             if (!list.isEmpty()) {
                 return list.get(0).getName();
             }
@@ -1515,18 +1522,30 @@ public class PlayerControllerAi extends PlayerController {
     }
 
     @Override
-    public ICardFace chooseSingleCardFace(SpellAbility sa, List<ICardFace> faces, String message) {
-        return SpellApiToAi.Converter.get(sa).chooseCardFace(player, sa, faces);
+    public String chooseCardName(SpellAbility sa, List<ICardFace> faces, String message) {
+        ApiType api = sa.getApi();
+        if (null == api) {
+            throw new InvalidParameterException("SA is not api-based, this is not supported yet");
+        }
+        return SpellApiToAi.Converter.get(api).chooseCardName(player, sa, faces);
     }
 
     @Override
-    public ICardFace chooseSingleCardFace(SpellAbility sa, String message, Predicate<ICardFace> cpp, String name) {
-        throw new UnsupportedOperationException("Should not be called for AI"); // or implement it if you know how
+    public ICardFace chooseSingleCardFace(SpellAbility sa, List<ICardFace> faces, String message) {
+        ApiType api = sa.getApi();
+        if (null == api) {
+            throw new InvalidParameterException("SA is not api-based, this is not supported yet");
+        }
+        return SpellApiToAi.Converter.get(api).chooseCardFace(player, sa, faces);
     }
 
     @Override
     public CardState chooseSingleCardState(SpellAbility sa, List<CardState> states, String message, Map<String, Object> params) {
-        return SpellApiToAi.Converter.get(sa).chooseCardState(player, sa, states, params);
+        ApiType api = sa.getApi();
+        if (null == api) {
+            throw new InvalidParameterException("SA is not api-based, this is not supported yet");
+        }
+        return SpellApiToAi.Converter.get(api).chooseCardState(player, sa, states, params);
     }
 
     @Override
@@ -1546,13 +1565,8 @@ public class PlayerControllerAi extends PlayerController {
             }
         }
 
-        try {
-            // if this fail somehow add fallback to get any from dungeonCards
-            int i = MyRandom.getRandom().nextInt(dungeonNames.size());
-            return Card.fromPaperCard(dungeonCards.get(i), ai);
-        } catch (Exception e) {
-            return Card.fromPaperCard(Aggregates.random(dungeonCards), ai);
-        }
+        int i = MyRandom.getRandom().nextInt(dungeonNames.size());
+        return Card.fromPaperCard(dungeonCards.get(i), ai);
     }
 
     @Override
@@ -1578,7 +1592,32 @@ public class PlayerControllerAi extends PlayerController {
 
     @Override
     public List<OptionalCostValue> chooseOptionalCosts(SpellAbility chosen, List<OptionalCostValue> optionalCostValues) {
-        return SpellApiToAi.Converter.get(chosen).chooseOptionalCosts(chosen, player, optionalCostValues);
+        List<OptionalCostValue> chosenOptCosts = Lists.newArrayList();
+        Cost costSoFar = chosen.getPayCosts().copy();
+
+        for (OptionalCostValue opt : optionalCostValues) {
+            // Choose the optional cost if it can be paid (to be improved later, check for playability and other conditions perhaps)
+            Cost fullCost = opt.getCost().copy().add(costSoFar);
+            SpellAbility fullCostSa = chosen.copyWithDefinedCost(fullCost);
+
+            // Playability check for Kicker
+            if (opt.getType() == OptionalCost.Kicker1 || opt.getType() == OptionalCost.Kicker2) {
+                SpellAbility kickedSaCopy = fullCostSa.copy();
+                kickedSaCopy.addOptionalCost(opt.getType());
+                Card copy = CardCopyService.getLKICopy(chosen.getHostCard());
+                copy.setCastSA(kickedSaCopy);
+                if (ComputerUtilCard.checkNeedsToPlayReqs(copy, kickedSaCopy) != AiPlayDecision.WillPlay) {
+                    continue; // don't choose kickers we don't want to play
+                }
+            }
+
+            if (ComputerUtilCost.canPayCost(fullCostSa, player, false)) {
+                chosenOptCosts.add(opt);
+                costSoFar.add(opt.getCost());
+            }
+        }
+
+        return chosenOptCosts;
     }
 
     @Override
@@ -1618,11 +1657,6 @@ public class PlayerControllerAi extends PlayerController {
         return max;
     }
 
-    @Override
-    public List<CostPart> orderCosts(List<CostPart> costs) {
-        return costs;
-    }
-
     @Override
     public CardCollection chooseCardsForEffectMultiple(Map<String, CardCollection> validMap, SpellAbility sa, String title, boolean isOptional) {
         CardCollection choices = new CardCollection();

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

@@ -171,7 +171,7 @@ public class SpecialAiLogic {
                 final boolean isInfect = source.hasKeyword(Keyword.INFECT); // Flesh-Eater Imp
                 int lethalDmg = isInfect ? 10 - defPlayer.getPoisonCounters() : defPlayer.getLife();
 
-                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterEnumType.POISON)) {
+                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
                     lethalDmg = Integer.MAX_VALUE; // won't be able to deal poison damage to kill the opponent
                 }
 
@@ -214,7 +214,7 @@ public class SpecialAiLogic {
     }
 
     // A logic for cards that say "Sacrifice a creature: put X +1/+1 counters on CARDNAME" (e.g. Falkenrath Aristocrat)
-    public static AiAbilityDecision doAristocratWithCountersLogic(final Player ai, final SpellAbility sa) {
+    public static boolean doAristocratWithCountersLogic(final Player ai, final SpellAbility sa) {
         final Card source = sa.getHostCard();
         final String logic = sa.getParam("AILogic"); // should not even get here unless there's an Aristocrats logic applied
         final boolean isDeclareBlockers = ai.getGame().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS);
@@ -222,14 +222,14 @@ public class SpecialAiLogic {
         final int numOtherCreats = Math.max(0, ai.getCreaturesInPlay().size() - 1);
         if (numOtherCreats == 0) {
             // Cut short if there's nothing to sac at all
-            return new AiAbilityDecision(0, AiPlayDecision.CantAfford);
+            return false;
         }
 
         // Check if the standard Aristocrats logic applies first (if in the right conditions for it)
         final boolean isThreatened = ComputerUtil.predictThreatenedObjects(ai, null, true).contains(source);
         if (isDeclareBlockers || isThreatened) {
             if (doAristocratLogic(ai, sa)) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
         }
 
@@ -247,7 +247,7 @@ public class SpecialAiLogic {
         if (countersSa == null) {
             // Shouldn't get here if there is no PutCounter subability (wrong AI logic specified?)
             System.err.println("Warning: AILogic AristocratCounters was specified on " + source + ", but there was no PutCounter SA in chain!");
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+            return false;
         }
 
         final Game game = ai.getGame();
@@ -263,7 +263,7 @@ public class SpecialAiLogic {
         relevantCreats.remove(source);
         if (relevantCreats.isEmpty()) {
             // No relevant creatures to sac
-            return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+            return false;
         }
 
         int numCtrs = AbilityUtils.calculateAmount(source, countersSa.getParam("CounterNum"), countersSa);
@@ -277,7 +277,7 @@ public class SpecialAiLogic {
                 final boolean isInfect = source.hasKeyword(Keyword.INFECT);
                 int lethalDmg = isInfect ? 10 - defPlayer.getPoisonCounters() : defPlayer.getLife();
 
-                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterEnumType.POISON)) {
+                if (isInfect && !combat.getDefenderByAttacker(source).canReceiveCounters(CounterType.get(CounterEnumType.POISON))) {
                     lethalDmg = Integer.MAX_VALUE; // won't be able to deal poison damage to kill the opponent
                 }
 
@@ -287,20 +287,16 @@ public class SpecialAiLogic {
                                 || (combat.isAttacking(card) && combat.isBlocked(card) && ComputerUtilCombat.combatantWouldBeDestroyed(ai, card, combat))
                 );
                 if (!forcedSacTgts.isEmpty()) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
 
                 final int numCreatsToSac = Math.max(0, (lethalDmg - source.getNetCombatDamage()) / numCtrs);
 
                 if (defTappedOut || numCreatsToSac < relevantCreats.size() / 2) {
-                    if (source.getNetCombatDamage() < lethalDmg
-                            && source.getNetCombatDamage() + relevantCreats.size() * numCtrs >= lethalDmg) {
-                        return new AiAbilityDecision(100, AiPlayDecision.ImpactCombat);
-                    }
-
-                    return new AiAbilityDecision(0, AiPlayDecision.DoesntImpactCombat);
+                    return source.getNetCombatDamage() < lethalDmg
+                            && source.getNetCombatDamage() + relevantCreats.size() * numCtrs >= lethalDmg;
                 } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
             } else {
                 // We have already attacked. Thus, see if we have a creature to sac that is worse to lose
@@ -313,7 +309,7 @@ public class SpecialAiLogic {
                 );
 
                 if (sacTgts.isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                    return false;
                 }
 
                 final boolean sourceCantDie = ComputerUtilCombat.combatantCantBeDestroyed(ai, source);
@@ -321,10 +317,7 @@ public class SpecialAiLogic {
                 final int DefP = sourceCantDie ? 0 : Aggregates.sum(combat.getBlockers(source), Card::getNetPower);
 
                 // Make sure we don't over-sacrifice, only sac until we can survive and kill a creature
-                if (source.getNetToughness() - source.getDamage() <= DefP || source.getNetCombatDamage() < minDefT) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                }
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return source.getNetToughness() - source.getDamage() <= DefP || source.getNetCombatDamage() < minDefT;
             }
         } else {
             // We can't deal lethal, check if there's any sac fodder than can be used for other circumstances
@@ -336,11 +329,7 @@ public class SpecialAiLogic {
                             || ComputerUtil.predictThreatenedObjects(ai, null, true).contains(card)
             );
 
-            if (sacFodder.isEmpty()) {
-                return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
-            }
-
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return !sacFodder.isEmpty();
         }
     }
 
@@ -371,10 +360,10 @@ public class SpecialAiLogic {
             // FIXME: We're emulating the UnlessCost on the SA to run the proper checks.
             // This is hacky, but it works. Perhaps a cleaner way exists?
             sa.getMapParams().put("UnlessCost", falseSub.getParam("UnlessCost"));
-            willPlay = SpellApiToAi.Converter.get(ApiType.Counter).canPlayWithSubs(ai, sa).willingToPlay();
+            willPlay = SpellApiToAi.Converter.get(ApiType.Counter).canPlayAIWithSubs(ai, sa);
             sa.getMapParams().remove("UnlessCost");
         } else {
-            willPlay = SpellApiToAi.Converter.get(ApiType.Counter).canPlayWithSubs(ai, sa).willingToPlay();
+            willPlay = SpellApiToAi.Converter.get(ApiType.Counter).canPlayAIWithSubs(ai, sa);
         }
         return willPlay;
     }

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

@@ -1,19 +1,13 @@
 package forge.ai;
 
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-
 import forge.card.CardStateName;
 import forge.card.ICardFace;
 import forge.card.mana.ManaCost;
 import forge.card.mana.ManaCostParser;
 import forge.game.GameEntity;
 import forge.game.card.Card;
-import forge.game.card.CardCopyService;
 import forge.game.card.CardState;
 import forge.game.card.CounterType;
 import forge.game.cost.Cost;
@@ -24,13 +18,14 @@ import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.player.PlayerController.BinaryChoiceType;
 import forge.game.spellability.AbilitySub;
-import forge.game.spellability.OptionalCost;
-import forge.game.spellability.OptionalCostValue;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityCondition;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
-import forge.util.collect.FCollectionView;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
 
 /**
  * Base class for API-specific AI logic
@@ -39,75 +34,72 @@ import forge.util.collect.FCollectionView;
  */
 public abstract class SpellAbilityAi {
 
-    public final AiAbilityDecision canPlayWithSubs(final Player aiPlayer, final SpellAbility sa) {
-        AiAbilityDecision decision = canPlay(aiPlayer, sa);
-        if (!decision.willingToPlay() && !"PlayForSub".equals(sa.getParam("AILogic"))) {
-            return decision;
+    public final boolean canPlayAIWithSubs(final Player aiPlayer, final SpellAbility sa) {
+        if (!canPlayAI(aiPlayer, sa)) {
+            return false;
         }
         final AbilitySub subAb = sa.getSubAbility();
-        if (subAb == null) {
-            return decision;
-        }
-
-        return chkDrawbackWithSubs(aiPlayer, subAb);
+        return subAb == null || chkDrawbackWithSubs(aiPlayer,  subAb);
     }
 
     /**
      * Handles the AI decision to play a "main" SpellAbility
      */
-    protected AiAbilityDecision canPlay(final Player ai, final SpellAbility sa) {
-        if (sa.getRestrictions() != null && !sa.getRestrictions().canPlay(sa.getHostCard(), sa)) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+    protected boolean canPlayAI(final Player ai, final SpellAbility sa) {
+        final Card source = sa.getHostCard();
+
+        if (sa.getRestrictions() != null && !sa.getRestrictions().canPlay(source, sa)) {
+            return false;
         }
 
         return canPlayWithoutRestrict(ai, sa);
     }
 
-    protected AiAbilityDecision canPlayWithoutRestrict(final Player ai, final SpellAbility sa) {
+    protected boolean canPlayWithoutRestrict(final Player ai, final SpellAbility sa) {
         final Card source = sa.getHostCard();
         final Cost cost = sa.getPayCosts();
 
+        if (sa.hasParam("AICheckCanPlayWithDefinedX")) {
+            // FIXME: can this somehow be simplified without the need for an extra AI hint?
+            sa.setXManaCostPaid(ComputerUtilCost.getMaxXValue(sa, ai, false));
+        }
+
+        if (!checkConditions(ai, sa, sa.getConditions())) {
+            SpellAbility sub = sa.getSubAbility();
+            if (sub != null && !checkConditions(ai, sub, sub.getConditions())) {
+                return false;
+            }
+        }
+
         if (sa.hasParam("AILogic")) {
             final String logic = sa.getParam("AILogic");
             final boolean alwaysOnDiscard = "AlwaysOnDiscard".equals(logic) && ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN, ai)
                     && !ai.isUnlimitedHandSize() && ai.getCardsIn(ZoneType.Hand).size() > ai.getMaxHandSize();
             if (!checkAiLogic(ai, sa, logic)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
             if (!alwaysOnDiscard && !checkPhaseRestrictions(ai, sa, ai.getGame().getPhaseHandler(), logic)) {
-                return new AiAbilityDecision(0, AiPlayDecision.MissingPhaseRestrictions);
+                return false;
+            }
+        } else {
+            if (!checkPhaseRestrictions(ai, sa, ai.getGame().getPhaseHandler())) {
+                return false;
             }
-        } else if (!checkPhaseRestrictions(ai, sa, ai.getGame().getPhaseHandler())) {
-            return new AiAbilityDecision(0, AiPlayDecision.MissingPhaseRestrictions);
-        } else if (ComputerUtil.preventRunAwayActivations(sa)) {
-            return new AiAbilityDecision(0, AiPlayDecision.StopRunawayActivations);
         }
 
-        AiAbilityDecision decision = checkApiLogic(ai, sa);
-        if (!decision.willingToPlay()) {
-            return decision;
+        if (!checkApiLogic(ai, sa)) {
+            return false;
         }
-
-        // needs to be after API logic because needs to check possible X Cost
+        // needs to be after API logic because needs to check possible X Cost?
         if (cost != null && !willPayCosts(ai, sa, cost, source)) {
-            return new AiAbilityDecision(0, AiPlayDecision.CostNotAcceptable);
+            return false;
         }
-
-        // for cards like Figure of Destiny
-        // (it's unlikely many valid effect would work like this -
-        // and while in theory AI could turn some conditions true in response that's far too advanced as default)
-        if (!checkConditions(ai, sa)) {
-            SpellAbility sub = sa.getSubAbility();
-            if (sub == null || !checkConditions(ai, sub)) {
-                return new AiAbilityDecision(0, AiPlayDecision.NeedsToPlayCriteriaNotMet);
-            }
-        }
-        return decision;
+        return true;
     }
 
-    protected boolean checkConditions(final Player ai, final SpellAbility sa) {
+    protected boolean checkConditions(final Player ai, final SpellAbility sa, SpellAbilityCondition con) {
         // copy it to disable some checks that the AI need to check extra
-        SpellAbilityCondition con = (SpellAbilityCondition) sa.getConditions().copy();
+        con = (SpellAbilityCondition) con.copy();
 
         // if manaspent, check if AI can pay the colored mana as cost
         if (!con.getManaSpent().isEmpty()) {
@@ -121,47 +113,62 @@ public abstract class SpellAbilityAi {
         return con.areMet(sa);
     }
 
+    /**
+     * Checks if the AI will play a SpellAbility with the specified AiLogic
+     */
+    protected boolean checkAiLogic(final Player ai, final SpellAbility sa, final String aiLogic) {
+        if (aiLogic.equals("CheckCondition")) {
+            SpellAbility saCopy = sa.copy();
+            saCopy.setActivatingPlayer(ai, true);
+            return saCopy.metConditions();
+        }
+
+        return !("Never".equals(aiLogic));
+    }
+
+    /**
+     * Checks if the AI is willing to pay for additional costs
+     * <p>
+     * Evaluated costs are: life, discard, sacrifice and counter-removal
+     */
+    protected boolean willPayCosts(final Player ai, final SpellAbility sa, final Cost cost, final Card source) {
+        if (!ComputerUtilCost.checkLifeCost(ai, cost, source, 4, sa)) {
+            return false;
+        }
+        if (!ComputerUtilCost.checkDiscardCost(ai, cost, source, sa)) {
+            return false;
+        }
+        if (!ComputerUtilCost.checkSacrificeCost(ai, cost, source, sa)) {
+            return false;
+        }
+        if (!ComputerUtilCost.checkRemoveCounterCost(cost, source, sa)) {
+            return false;
+        }
+        return true;
+    }
+
     /**
      * Checks if the AI will play a SpellAbility based on its phase restrictions
      */
     protected boolean checkPhaseRestrictions(final Player ai, final SpellAbility sa, final PhaseHandler ph) {
         return true;
     }
-
+    
     protected boolean checkPhaseRestrictions(final Player ai, final SpellAbility sa, final PhaseHandler ph,
             final String logic) {
-         if (logic.equals("AtOppEOT")) {
-            return ph.getNextTurn() == ai && ph.is(PhaseType.END_OF_TURN);
-         }
         return checkPhaseRestrictions(ai, sa, ph);
     }
-
-    /**
-     * Checks if the AI will play a SpellAbility with the specified AiLogic
-     */
-    protected boolean checkAiLogic(final Player ai, final SpellAbility sa, final String aiLogic) {
-        if ("Never".equals(aiLogic)) {
-            return false;
-        }
-        if (!"Once".equals(aiLogic)) {
-            return !sa.getHostCard().getAbilityActivatedThisTurn().getActivators(sa).contains(ai);
-        }
-        return true;
-    }
-
     /**
      * The rest of the logic not covered by the canPlayAI template is defined here
      */
-    protected AiAbilityDecision checkApiLogic(final Player ai, final SpellAbility sa) {
-        if (sa.getActivationsThisTurn() == 0 || MyRandom.getRandom().nextFloat() < .8f) {
-            // 80% chance to play the ability
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+    protected boolean checkApiLogic(final Player ai, final SpellAbility sa) {
+        if (ComputerUtil.preventRunAwayActivations(sa)) {
+            return false; // prevent infinite loop
         }
-
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return MyRandom.getRandom().nextFloat() < .8f; // random success
     }
-
-    public final boolean doTrigger(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
+    
+    public final boolean doTriggerAI(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
         // this evaluation order is currently intentional as it does more stuff that helps avoiding some crashes
         if (!ComputerUtilCost.canPayCost(sa, aiPlayer, true) && !mandatory) {
             return false;
@@ -173,48 +180,28 @@ public abstract class SpellAbilityAi {
             return sa.isTargetNumberValid();
         }
 
-        return doTriggerNoCostWithSubs(aiPlayer, sa, mandatory).willingToPlay();
+        return doTriggerNoCostWithSubs(aiPlayer, sa, mandatory);
     }
 
-    public final AiAbilityDecision doTriggerNoCostWithSubs(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
-        AiAbilityDecision decision = doTriggerNoCost(aiPlayer, sa, mandatory);
-        if (!decision.willingToPlay() && !"Always".equals(sa.getParam("AILogic"))) {
-            return decision;
+    public final boolean doTriggerNoCostWithSubs(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
+        if (!doTriggerAINoCost(aiPlayer, sa, mandatory) && !"Always".equals(sa.getParam("AILogic"))) {
+            return false;
         }
         final AbilitySub subAb = sa.getSubAbility();
-        if (subAb == null) {
-            if (decision.willingToPlay()) {
-                return decision;
-            }
-
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-
-        decision = chkDrawbackWithSubs(aiPlayer, subAb);
-        if (decision.willingToPlay()) {
-            return decision;
-        }
-
-        if (mandatory) {
-            return new AiAbilityDecision(50, AiPlayDecision.MandatoryPlay);
-        }
-
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-     }
+        return subAb == null || chkDrawbackWithSubs(aiPlayer, subAb) || mandatory;
+    }
 
     /**
      * Handles the AI decision to play a triggered SpellAbility
      */
-    protected AiAbilityDecision doTriggerNoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
-        AiAbilityDecision decision = canPlayWithoutRestrict(aiPlayer, sa);
-        if (decision.willingToPlay() && (!mandatory || sa.isTargetNumberValid())) {
-            // This is a weird check. Why do we care if its not mandatory if we WANT to do it?
-            return decision;
+    protected boolean doTriggerAINoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
+        if (canPlayWithoutRestrict(aiPlayer, sa) && (!mandatory || sa.isTargetNumberValid())) {
+            return true;
         }
 
         // not mandatory, short way out
         if (!mandatory) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         // invalid target might prevent it
@@ -230,13 +217,82 @@ public abstract class SpellAbilityAi {
                 if (sa.canTarget(p)) {
                     sa.resetTargets();
                     sa.getTargets().add(p);
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
 
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
         }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
+    }
+
+    /**
+     * Handles the AI decision to play a sub-SpellAbility
+     */
+    public boolean chkAIDrawback(final SpellAbility sa, final Player aiPlayer) {
+        // sub-SpellAbility might use targets too
+        if (sa.usesTargeting()) {
+            // no Candidates, no adding to Stack
+            if (!sa.getTargetRestrictions().hasCandidates(sa)) {
+                return false;
+            }
+            // but if it does, it should override this function
+            System.err.println("Warning: default (ie. inherited from base class) implementation of chkAIDrawback is used by " + sa.getHostCard().getName() + " for " + this.getClass().getName() + ". Consider declaring an overloaded method");
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * <p>
+     * isSorcerySpeed.
+     * </p>
+     * 
+     * @param sa
+     *            a {@link forge.game.spellability.SpellAbility} object.
+     * @return a boolean.
+     */
+    protected static boolean isSorcerySpeed(final SpellAbility sa, Player ai) {
+        return (sa.getRootAbility().isSpell() && sa.getHostCard().isSorcery())
+            || (sa.getRootAbility().isActivatedAbility() && sa.getRootAbility().getRestrictions().isSorcerySpeed())
+            || (sa.getRootAbility().isAdventure() && sa.getHostCard().getState(CardStateName.Adventure).getType().isSorcery())
+            || (sa.isPwAbility() && !sa.withFlash(sa.getHostCard(), ai));
+    }
+
+    /**
+     * <p>
+     * playReusable.
+     * </p>
+     * 
+     * @param sa
+     *            a {@link forge.game.spellability.SpellAbility} object.
+     * @return a boolean.
+     */
+    protected static boolean playReusable(final Player ai, final SpellAbility sa) {
+        PhaseHandler phase = ai.getGame().getPhaseHandler();
+
+        // TODO probably also consider if winter orb or similar are out
+
+        if (sa instanceof AbilitySub) {
+            return true; // This is only true for Drawbacks and triggers
+        }
+        
+        if (!sa.getPayCosts().isReusuableResource()) {
+            return false;
+        }
+        
+        if (ComputerUtil.playImmediately(ai, sa)) {
+            return true;
+        }
+    
+        if (sa.isPwAbility() && phase.is(PhaseType.MAIN2)) {
+            return true;
+        }
+        if (sa.isSpell() && !sa.isBuyback()) {
+            return false;
+        }
+
+        return phase.is(PhaseType.END_OF_TURN) && phase.getNextTurn().equals(ai);
     }
 
     /**
@@ -245,35 +301,9 @@ public abstract class SpellAbilityAi {
      * @param ab
      * @return
      */
-    public AiAbilityDecision chkDrawbackWithSubs(Player aiPlayer, AbilitySub ab) {
+    public boolean chkDrawbackWithSubs(Player aiPlayer, AbilitySub ab) {
         final AbilitySub subAb = ab.getSubAbility();
-        AiAbilityDecision decision = SpellApiToAi.Converter.get(ab).chkDrawback(ab, aiPlayer);
-        if (!decision.willingToPlay()) {
-            return decision;
-        }
-
-        if (subAb == null) {
-            return decision;
-        }
-
-        return chkDrawbackWithSubs(aiPlayer, subAb);
-    }
-
-    /**
-     * Handles the AI decision to play a sub-SpellAbility
-     */
-    public AiAbilityDecision chkDrawback(final SpellAbility sa, final Player aiPlayer) {
-        // sub-SpellAbility might use targets too
-        if (sa.usesTargeting()) {
-            // no Candidates, no adding to Stack
-            if (!sa.getTargetRestrictions().hasCandidates(sa)) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
-            }
-            // but if it does, it should override this function
-            System.err.println("Warning: default (ie. inherited from base class) implementation of chkAIDrawback is used by " + sa.getHostCard().getName() + " for " + this.getClass().getName() + ". Consider declaring an overloaded method");
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-        }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        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, Map<String, Object> params) {
@@ -290,9 +320,9 @@ public abstract class SpellAbilityAi {
         for (T ent : options) {
             if (ent instanceof Player) {
                 hasPlayer = true;
-            } else if (ent instanceof Card card) {
+            } else if (ent instanceof Card) {
                 hasCard = true;
-                if (card.isPlaneswalker() || card.isBattle()) {
+                if (((Card)ent).isPlaneswalker() || ((Card)ent).isBattle()) {
                     hasAttackableCard = true;
                 }
             }
@@ -318,7 +348,7 @@ public abstract class SpellAbilityAi {
         System.err.println("Warning: default (ie. inherited from base class) implementation of chooseSingleCard is used by " + sa.getHostCard().getName() + " for " + this.getClass().getName() + ". Consider declaring an overloaded method");
         return Iterables.getFirst(options, null);
     }
-
+    
     protected Player chooseSinglePlayer(Player ai, SpellAbility sa, Iterable<Player> options, Map<String, Object> params) {
         System.err.println("Warning: default (ie. inherited from base class) implementation of chooseSinglePlayer is used by " + sa.getHostCard().getName() + " for " + this.getClass().getName() + ". Consider declaring an overloaded method");
         return Iterables.getFirst(options, null);
@@ -332,7 +362,7 @@ public abstract class SpellAbilityAi {
     public String chooseCardName(Player ai, SpellAbility sa, List<ICardFace> faces) {
         System.err.println("Warning: default (ie. inherited from base class) implementation of chooseCardName is used for " + this.getClass().getName() + ". Consider declaring an overloaded method");
 
-        final ICardFace face = Iterables.getFirst(faces, null);
+        final ICardFace face = Iterables.getFirst(faces, null); 
         return face == null ? "" : face.getName();
     }
 
@@ -359,125 +389,4 @@ public abstract class SpellAbilityAi {
     public boolean chooseBinary(BinaryChoiceType kindOfChoice, SpellAbility sa, Map<String, Object> params) {
         return MyRandom.getRandom().nextBoolean();
     }
-
-    /**
-     * Checks if the AI is willing to pay for additional costs
-     * <p>
-     * Evaluated costs are: life, discard, sacrifice and counter-removal
-     */
-    protected boolean willPayCosts(final Player ai, final SpellAbility sa, final Cost cost, final Card source) {
-        if (!ComputerUtilCost.checkLifeCost(ai, cost, source, 4, sa)) {
-            return false;
-        }
-        if (!ComputerUtilCost.checkDiscardCost(ai, cost, source, sa)) {
-            return false;
-        }
-        if (!ComputerUtilCost.checkSacrificeCost(ai, cost, source, sa)) {
-            return false;
-        }
-        if (!ComputerUtilCost.checkRemoveCounterCost(cost, source, sa)) {
-            return false;
-        }
-        return true;
-    }
-
-    public boolean willPayUnlessCost(SpellAbility sa, Player payer, Cost cost, boolean alreadyPaid, FCollectionView<Player> payers) {
-        final Card source = sa.getHostCard();
-        final String aiLogic = sa.getParam("UnlessAI");
-        boolean payNever = "Never".equals(aiLogic);
-        boolean isMine = sa.getActivatingPlayer().equals(payer);
-
-        if (payNever) { return false; }
-
-        // AI will only pay when it's not already payed and only opponents abilities
-        if (alreadyPaid || (payers.size() > 1 && isMine)) {
-            return false;
-        }
-
-        return ComputerUtilCost.checkLifeCost(payer, cost, source, 4, sa)
-                && ComputerUtilCost.checkDamageCost(payer, cost, source, 4, sa)
-                && (isMine || ComputerUtilCost.checkSacrificeCost(payer, cost, source, sa))
-                && (isMine || ComputerUtilCost.checkDiscardCost(payer, cost, source, sa));
-    }
-
-    public List<OptionalCostValue> chooseOptionalCosts(SpellAbility chosen, Player player, List<OptionalCostValue> optionalCostValues) {
-        List<OptionalCostValue> chosenOptCosts = Lists.newArrayList();
-        Cost costSoFar = chosen.getPayCosts().copy();
-
-        for (OptionalCostValue opt : optionalCostValues) {
-            // Choose the optional cost if it can be paid (to be improved later, check for playability and other conditions perhaps)
-            Cost fullCost = opt.getCost().copy().add(costSoFar);
-            SpellAbility fullCostSa = chosen.copyWithDefinedCost(fullCost);
-
-            if (opt.getType() == OptionalCost.Kicker1 || opt.getType() == OptionalCost.Kicker2) {
-                SpellAbility kickedSaCopy = fullCostSa.copy();
-                kickedSaCopy.addOptionalCost(opt.getType());
-                Card copy = CardCopyService.getLKICopy(chosen.getHostCard());
-                copy.setCastSA(kickedSaCopy);
-                if (ComputerUtilCard.checkNeedsToPlayReqs(copy, kickedSaCopy) != AiPlayDecision.WillPlay) {
-                    // don't choose kickers we don't want to play
-                    continue;
-                }
-            }
-
-            if (ComputerUtilCost.canPayCost(fullCostSa, player, false)) {
-                chosenOptCosts.add(opt);
-                costSoFar.add(opt.getCost());
-            }
-        }
-
-        return chosenOptCosts;
-    }
-
-    /**
-     * <p>
-     * isSorcerySpeed.
-     * </p>
-     *
-     * @param sa
-     *            a {@link forge.game.spellability.SpellAbility} object.
-     * @return a boolean.
-     */
-    protected static boolean isSorcerySpeed(final SpellAbility sa, Player ai) {
-        return (sa.getRootAbility().isSpell() && sa.getHostCard().isSorcery())
-                || (sa.getRootAbility().isActivatedAbility() && sa.getRootAbility().getRestrictions().isSorcerySpeed())
-                || (sa.getRootAbility().isAdventure() && sa.getHostCard().getState(CardStateName.Secondary).getType().isSorcery())
-                || (sa.isPwAbility() && !sa.withFlash(sa.getHostCard(), ai));
-    }
-
-    /**
-     * <p>
-     * playReusable.
-     * </p>
-     *
-     * @param sa
-     *            a {@link forge.game.spellability.SpellAbility} object.
-     * @return a boolean.
-     */
-    protected static boolean playReusable(final Player ai, final SpellAbility sa) {
-        PhaseHandler phase = ai.getGame().getPhaseHandler();
-
-        // TODO probably also consider if winter orb or similar are out
-
-        if (sa instanceof AbilitySub) {
-            return true; // This is only true for Drawbacks and triggers
-        }
-
-        if (!sa.getPayCosts().isReusuableResource()) {
-            return false;
-        }
-
-        if (ComputerUtil.playImmediately(ai, sa)) {
-            return true;
-        }
-
-        if (sa.isPwAbility() && phase.is(PhaseType.MAIN2)) {
-            return true;
-        }
-        if (sa.isSpell() && !sa.isBuyback()) {
-            return false;
-        }
-
-        return phase.is(PhaseType.END_OF_TURN) && phase.getNextTurn().equals(ai);
-    }
 }

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

@@ -1,15 +1,14 @@
 package forge.ai;
 
+import java.util.Map;
+
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
+
 import forge.ai.ability.*;
 import forge.game.ability.ApiType;
-import forge.game.spellability.SpellAbility;
 import forge.util.ReflectionUtil;
 
-import java.security.InvalidParameterException;
-import java.util.Map;
-
 public enum SpellApiToAi {
     Converter;
 
@@ -23,14 +22,12 @@ public enum SpellApiToAi {
             .put(ApiType.AddOrRemoveCounter, CountersPutOrRemoveAi.class)
             .put(ApiType.AddPhase, AddPhaseAi.class)
             .put(ApiType.AddTurn, AddTurnAi.class)
-            .put(ApiType.AdvanceCrank, AdvanceCrankAi.class)
             .put(ApiType.AlterAttribute, AlterAttributeAi.class)
             .put(ApiType.Amass, AmassAi.class)
             .put(ApiType.Animate, AnimateAi.class)
             .put(ApiType.AnimateAll, AnimateAllAi.class)
             .put(ApiType.Attach, AttachAi.class)
             .put(ApiType.Ascend, AlwaysPlayAi.class)
-            .put(ApiType.AssembleContraption, AssembleContraptionAi.class)
             .put(ApiType.AssignGroup, AssignGroupAi.class)
             .put(ApiType.Balance, BalanceAi.class)
             .put(ApiType.BecomeMonarch, AlwaysPlayAi.class)
@@ -41,7 +38,6 @@ public enum SpellApiToAi {
             .put(ApiType.Branch, BranchAi.class)
             .put(ApiType.Camouflage, ChooseCardAi.class)
             .put(ApiType.ChangeCombatants, ChangeCombatantsAi.class)
-            .put(ApiType.ChangeSpeed, AlwaysPlayAi.class)
             .put(ApiType.ChangeTargets, ChangeTargetsAi.class)
             .put(ApiType.ChangeX, AlwaysPlayAi.class)
             .put(ApiType.ChangeZone, ChangeZoneAi.class)
@@ -57,9 +53,8 @@ public enum SpellApiToAi {
             .put(ApiType.ChooseSector, AlwaysPlayAi.class)
             .put(ApiType.ChooseSource, ChooseSourceAi.class)
             .put(ApiType.ChooseType, ChooseTypeAi.class)
-            .put(ApiType.ClaimThePrize, AlwaysPlayAi.class)
             .put(ApiType.Clash, ClashAi.class)
-            .put(ApiType.ClassLevelUp, ClassLevelUpAi.class)
+            .put(ApiType.ClassLevelUp, AlwaysPlayAi.class)
             .put(ApiType.Cleanup, AlwaysPlayAi.class)
             .put(ApiType.Cloak, CloakAi.class)
             .put(ApiType.Clone, CloneAi.class)
@@ -88,7 +83,6 @@ public enum SpellApiToAi {
             .put(ApiType.EachDamage, DamageEachAi.class)
             .put(ApiType.Effect, EffectAi.class)
             .put(ApiType.Encode, EncodeAi.class)
-            .put(ApiType.Endure, EndureAi.class)
             .put(ApiType.EndCombatPhase, EndTurnAi.class)
             .put(ApiType.EndTurn, EndTurnAi.class)
             .put(ApiType.ExchangeLife, LifeExchangeAi.class)
@@ -131,7 +125,6 @@ public enum SpellApiToAi {
             .put(ApiType.Mutate, MutateAi.class)
             .put(ApiType.NameCard, ChooseCardNameAi.class)
             //.put(ApiType.NoteCounters, AlwaysPlayAi.class)
-            .put(ApiType.OpenAttraction, AssembleContraptionAi.class)
             .put(ApiType.PeekAndReveal, PeekAndRevealAi.class)
             .put(ApiType.PermanentCreature, PermanentCreatureAi.class)
             .put(ApiType.PermanentNoncreature, PermanentNoncreatureAi.class)
@@ -211,14 +204,6 @@ public enum SpellApiToAi {
             .put(ApiType.InternalRadiation, AlwaysPlayAi.class)
             .build());
 
-    public SpellAbilityAi get(final SpellAbility sa) {
-        ApiType api = sa.getApi();
-        if (null == api) {
-            throw new InvalidParameterException("SA is not api-based, this is not supported yet");
-        }
-        return get(api);
-    }
-
     public SpellAbilityAi get(final ApiType api) {
         SpellAbilityAi result = apiToInstance.get(api);
         if (null == result) {

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

@@ -1,7 +1,8 @@
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+import java.util.List;
+import java.util.Map;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
@@ -10,76 +11,83 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
-
-import java.util.List;
-import java.util.Map;
+import forge.util.MyRandom;
 
 public class ActivateAbilityAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
+        // AI cannot use this properly until he can use SAs during Humans turn
+
         final Card source = sa.getHostCard();
         final Player opp = ai.getStrongestOpponent();
 
         List<Card> list = CardLists.getType(opp.getCardsIn(ZoneType.Battlefield), sa.getParamOrDefault("Type", "Card"));
         if (list.isEmpty()) {
-            return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+            return false;
         }
 
         if (!sa.usesTargeting()) {
             final List<Player> defined = AbilityUtils.getDefinedPlayers(source, sa.getParam("Defined"), sa);
+
             if (!defined.contains(opp)) {
-                return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+                return false;
             }
         } else {
             sa.resetTargets();
             if (sa.canTarget(opp)) {
                 sa.getTargets().add(opp);
             } else {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
         }
 
-        return super.checkApiLogic(ai, sa);
+        boolean randomReturn = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        return randomReturn;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Player opp = ai.getStrongestOpponent();
+
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         final Card source = sa.getHostCard();
 
         if (null == tgt) {
             if (mandatory) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             } else {
                 final List<Player> defined = AbilityUtils.getDefinedPlayers(source, sa.getParam("Defined"), sa);
-                if (defined.contains(opp)) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
+
+                return defined.contains(opp);
             }
         } else {
             sa.resetTargets();
             sa.getTargets().add(opp);
         }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+
+        return true;
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
+        // AI cannot use this properly until he can use SAs during Humans turn
         final Card source = sa.getHostCard();
+
+        boolean randomReturn = true;
+
         if (!sa.usesTargeting()) {
             final List<Player> defined = AbilityUtils.getDefinedPlayers(source, sa.getParam("Defined"), sa);
+
             if (defined.contains(ai)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
         } else {
             sa.resetTargets();
             sa.getTargets().add(ai.getWeakestOpponent());
         }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+
+        return randomReturn;
     }
 
     @Override

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

@@ -1,7 +1,5 @@
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
@@ -13,8 +11,8 @@ import forge.game.spellability.SpellAbility;
 public class AddPhaseAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision canPlay(Player aiPlayer, SpellAbility sa) {
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
+        return false;
     }
 
 }

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

@@ -17,17 +17,16 @@
  */
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.player.Player;
 import forge.game.player.PlayerCollection;
 import forge.game.player.PlayerPredicates;
 import forge.game.spellability.SpellAbility;
-import org.apache.commons.lang3.StringUtils;
-
-import java.util.List;
 
 /**
  * <p>
@@ -40,7 +39,7 @@ import java.util.List;
 public class AddTurnAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         PlayerCollection targetableOpps = ai.getOpponents().filter(PlayerPredicates.isTargetableBy(sa));
         Player opp = targetableOpps.min(PlayerPredicates.compareByLife());
 
@@ -49,41 +48,41 @@ public class AddTurnAi extends SpellAbilityAi {
             if (sa.canTarget(ai) && (mandatory || !ai.getGame().getReplacementHandler().wouldExtraTurnBeSkipped(ai))) {
                 sa.getTargets().add(ai);
             } else if (mandatory) {
-                for (final Player ally : ai.getAllies()) {
+            	for (final Player ally : ai.getAllies()) {
                     if (sa.canTarget(ally)) {
-                        sa.getTargets().add(ally);
-                        break;
+                    	sa.getTargets().add(ally);
+                    	break;
                     }
-                }
+            	}
                 if (!sa.getTargetRestrictions().isMinTargetsChosen(sa.getHostCard(), sa) && opp != null) {
                     sa.getTargets().add(opp);
                 } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                    return false;
                 }
             } else {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
         } else {
             final List<Player> tgtPlayers = AbilityUtils.getDefinedPlayers(sa.getHostCard(), sa.getParam("Defined"), sa);
             for (final Player p : tgtPlayers) {
                 if (p.isOpponentOf(ai) && !mandatory) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
             }
             // TODO: improve ai for Sage of Hours
-            if (!StringUtils.isNumeric(sa.getParam("NumTurns"))) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
+            return StringUtils.isNumeric(sa.getParam("NumTurns"));
+            // not sure if the AI should be playing with cards that give the
+            // Human more turns.
         }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected AiAbilityDecision canPlay(Player aiPlayer, SpellAbility sa) {
-        return doTriggerNoCost(aiPlayer, sa, false);
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
+        return doTriggerAINoCost(aiPlayer, sa, false);
     }
 
 }

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

@@ -1,23 +0,0 @@
-package forge.ai.ability;
-
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
-import forge.ai.SpellAbilityAi;
-import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
-import forge.game.player.Player;
-import forge.game.spellability.SpellAbility;
-import forge.game.zone.ZoneType;
-
-public class AdvanceCrankAi extends SpellAbilityAi {
-    @Override
-    protected AiAbilityDecision canPlay(Player ai, SpellAbility sa) {
-        int nextSprocket = (ai.getCrankCounter() % 3) + 1;
-        int crankCount = CardLists.count(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.isContraptionOnSprocket(nextSprocket));
-        if (crankCount < 2) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-        }
-        return super.canPlay(ai, sa);
-    }
-
-}

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

@@ -1,7 +1,8 @@
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+import java.util.List;
+import java.util.Map;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
@@ -12,13 +13,10 @@ import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.SpellAbility;
 
-import java.util.List;
-import java.util.Map;
-
 public class AlterAttributeAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision checkApiLogic(Player aiPlayer, SpellAbility sa) {
+    protected boolean checkApiLogic(Player aiPlayer, SpellAbility sa) {
         final Card source = sa.getHostCard();
         boolean activate = Boolean.parseBoolean(sa.getParamOrDefault("Activate", "true"));
         String[] attributes = sa.getParam("Attributes").split(",");
@@ -26,7 +24,7 @@ public class AlterAttributeAi extends SpellAbilityAi {
         if (sa.usesTargeting()) {
             // TODO add targeting logic
             // needed for Suspected
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
         }
 
         final List<Card> defined = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
@@ -38,7 +36,7 @@ public class AlterAttributeAi extends SpellAbilityAi {
                     case "Solved":
                         // there is currently no effect that would un-solve something
                         if (!c.isSolved() && activate) {
-                            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                            return true;
                         }
                         break;
                     case "Suspect":
@@ -46,21 +44,21 @@ public class AlterAttributeAi extends SpellAbilityAi {
                         // is Suspected good or bad?
                         // currently Suspected is better
                         if (!activate) {
-                            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                            return false;
                         }
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
 
                     case "Saddle":
                     case "Saddled":
                         // AI should not try to Saddle again?
                         if (c.isSaddled()) {
-                            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                            return false;
                         }
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
                 }
             }
         }
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return false;
     }
 
     @Override

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

@@ -1,21 +1,20 @@
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+
+import java.util.Map;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.SpellAbility;
 
-import java.util.Map;
-
 public class AlwaysPlayAi extends SpellAbilityAi {
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected AiAbilityDecision canPlay(Player aiPlayer, SpellAbility sa) {
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
+        return true;
     }
 
     @Override

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

@@ -1,15 +1,20 @@
 package forge.ai.ability;
 
+import java.util.Map;
+
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
+import forge.game.card.CounterEnumType;
 import forge.game.card.token.TokenInfo;
 import forge.game.phase.PhaseHandler;
 import forge.game.player.Player;
@@ -17,32 +22,26 @@ import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.Map;
-
 public class AmassAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, final SpellAbility sa) {
+    protected boolean checkApiLogic(Player ai, final SpellAbility sa) {
         CardCollection aiArmies = CardLists.getType(ai.getCardsIn(ZoneType.Battlefield), "Army");
         Card host = sa.getHostCard();
         final Game game = ai.getGame();
 
         if (!aiArmies.isEmpty()) {
-            if (aiArmies.anyMatch(CardPredicates.canReceiveCounters(CounterEnumType.P1P1))) {
-                // If AI has an Army that can receive counters, play the ability
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            } else {
-                // AI has Armies but none can receive counters, so don't play
-                return new AiAbilityDecision(0, AiPlayDecision.DoesntImpactGame);
-            }
+            return Iterables.any(aiArmies, CardPredicates.canReceiveCounters(CounterEnumType.P1P1));
         }
         final String type = sa.getParam("Type");
-        final String tokenScript = "b_0_0_" + sa.getOriginalParam("Type").toLowerCase() + "_army";
+        StringBuilder sb = new StringBuilder("b_0_0_");
+        sb.append(sa.getOriginalParam("Type").toLowerCase()).append("_army");
+        final String tokenScript = sb.toString();
         final int amount = AbilityUtils.calculateAmount(host, sa.getParamOrDefault("Num", "1"), sa);
 
         Card token = TokenInfo.getProtoType(tokenScript, sa, ai, false);
 
         if (token == null) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         token.setController(ai, 0);
@@ -69,11 +68,7 @@ public class AmassAi extends SpellAbilityAi {
         //reset static abilities
         game.getAction().checkStaticAbilities(false);
 
-        if (result) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        } else {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-        }
+        return result;
     }
 
     @Override
@@ -92,12 +87,8 @@ public class AmassAi extends SpellAbilityAi {
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        if (mandatory) {
-            return new AiAbilityDecision(50, AiPlayDecision.MandatoryPlay);
-        }
-
-        return checkApiLogic(ai, sa);
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
+        return mandatory || checkApiLogic(ai, sa);
     }
 
     @Override

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

@@ -1,8 +1,8 @@
 package forge.ai.ability;
 
+import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
-
 import forge.ai.*;
 import forge.card.CardType;
 import forge.card.ColorSet;
@@ -13,9 +13,7 @@ import forge.game.ability.ApiType;
 import forge.game.ability.effects.AnimateEffectBase;
 import forge.game.card.*;
 import forge.game.combat.Combat;
-import forge.game.cost.Cost;
 import forge.game.cost.CostPutCounter;
-import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -24,10 +22,8 @@ import forge.game.spellability.SpellAbility;
 import forge.game.staticability.StaticAbility;
 import forge.game.staticability.StaticAbilityContinuous;
 import forge.game.staticability.StaticAbilityLayer;
-import forge.game.staticability.StaticAbilityMode;
 import forge.game.zone.ZoneType;
 import forge.util.FileSection;
-import forge.util.collect.FCollectionView;
 
 import java.util.Arrays;
 import java.util.List;
@@ -37,7 +33,7 @@ import java.util.Map;
  * <p>
  * AbilityFactoryAnimate class.
  * </p>
- *
+ * 
  * @author Forge
  * @version $Id: AbilityFactoryAnimate.java 17608 2012-10-20 22:27:27Z Max mtg $
  */
@@ -74,7 +70,7 @@ public class AnimateAi extends SpellAbilityAi {
             }
 
             // check for duplicate static ability
-            if (host.getStaticAbilities().anyMatch(CardTraitPredicates.hasParam("Description", map.get("Description")))) {
+            if (Iterables.any(host.getStaticAbilities(), CardTraitPredicates.hasParam("Description", map.get("Description")))) {
                 return false;
             }
             // TODO check if Bone Man would deal damage to something that otherwise would regenerate
@@ -134,7 +130,7 @@ public class AnimateAi extends SpellAbilityAi {
                 && game.getPhaseHandler().getNextTurn() != ai
                 && source.isPermanent();
         if (ph.isPlayerTurn(ai) && ai.getLife() < 6 && opponent.getLife() > 6
-                && opponent.getZone(ZoneType.Battlefield).contains(CardPredicates.CREATURES)
+                && opponent.getZone(ZoneType.Battlefield).contains(CardPredicates.Presets.CREATURES)
                 && !sa.hasParam("AILogic") && !"Permanent".equals(sa.getParam("Duration")) && !activateAsPotentialBlocker) {
             return false;
         }
@@ -142,166 +138,160 @@ public class AnimateAi extends SpellAbilityAi {
     }
 
     @Override
-    protected AiAbilityDecision checkApiLogic(Player aiPlayer, SpellAbility sa) {
+    protected boolean checkApiLogic(Player aiPlayer, SpellAbility sa) {
         final Card source = sa.getHostCard();
         final Game game = aiPlayer.getGame();
         final PhaseHandler ph = game.getPhaseHandler();
-
+        if (!sa.metConditions() && sa.getSubAbility() == null) {
+            return false; // what is this for?
+        }
         if (!game.getStack().isEmpty() && game.getStack().peekAbility().getApi() == ApiType.Sacrifice) {
-            // Should I animate a card before i have to sacrifice something better?
             if (!isAnimatedThisTurn(aiPlayer, source)) {
                 rememberAnimatedThisTurn(aiPlayer, source);
-                return new AiAbilityDecision(100, AiPlayDecision.ResponseToStackResolve);
+                return true;  // interrupt sacrifice
             }
         }
         if (!ComputerUtilCost.checkTapTypeCost(aiPlayer, sa.getPayCosts(), source, sa, new CardCollection())) {
-            return new AiAbilityDecision(0, AiPlayDecision.CostNotAcceptable);
+            return false; // prevent crewing with equal or better creatures
         }
 
         if (sa.costHasManaX() && sa.getSVar("X").equals("Count$xPaid")) {
+            // Set PayX here to maximum value.
             final int xPay = ComputerUtilCost.getMaxXValue(sa, aiPlayer, sa.isTrigger());
+
             sa.setXManaCostPaid(xPay);
         }
 
-        if (sa.usesTargeting()) {
-            sa.resetTargets();
-            return animateTgtAI(sa);
-        }
-
-        final List<Card> defined = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
-        boolean bFlag = false;
-        boolean givesHaste = sa.hasParam("Keywords") && sa.getParam("Keywords").contains("Haste");
-        for (final Card c : defined) {
-            bFlag |= !c.isCreature() && !c.isTapped()
-                    && (!c.hasSickness() || givesHaste || !ph.isPlayerTurn(aiPlayer))
-                    && !c.isEquipping();
-
-            // for creatures that could be improved (like Figure of Destiny)
-            if (!bFlag && c.isCreature() && ("Permanent".equals(sa.getParam("Duration")) || (!c.isTapped() && !c.isSick()))) {
-                int power = -5;
-                if (sa.hasParam("Power")) {
-                    power = AbilityUtils.calculateAmount(c, sa.getParam("Power"), sa);
-                }
-                int toughness = -5;
-                if (sa.hasParam("Toughness")) {
-                    toughness = AbilityUtils.calculateAmount(c, sa.getParam("Toughness"), sa);
-                }
-                if (sa.hasParam("Keywords")) {
-                    for (String keyword : sa.getParam("Keywords").split(" & ")) {
-                        if (!c.hasKeyword(keyword)) {
-                            bFlag = true;
+        if (!sa.usesTargeting()) {
+            final List<Card> defined = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
+            boolean bFlag = false;
+            boolean givesHaste = sa.hasParam("Keywords") && sa.getParam("Keywords").contains("Haste");
+            for (final Card c : defined) {
+                bFlag |= !c.isCreature() && !c.isTapped()
+                        && (!c.hasSickness() || givesHaste || !ph.isPlayerTurn(aiPlayer))
+                        && !c.isEquipping();
+                
+                // for creatures that could be improved (like Figure of Destiny)
+                if (!bFlag && c.isCreature() && ("Permanent".equals(sa.getParam("Duration")) || (!c.isTapped() && !c.isSick()))) {
+                    int power = -5;
+                    if (sa.hasParam("Power")) {
+                        power = AbilityUtils.calculateAmount(c, sa.getParam("Power"), sa);
+                    }
+                    int toughness = -5;
+                    if (sa.hasParam("Toughness")) {
+                        toughness = AbilityUtils.calculateAmount(c, sa.getParam("Toughness"), sa);
+                    }
+                    if (sa.hasParam("Keywords")) {
+                        for (String keyword : sa.getParam("Keywords").split(" & ")) {
+                            if (!c.hasKeyword(keyword)) {
+                                bFlag = true;
+                            }
                         }
                     }
-                }
-                if (power + toughness > c.getCurrentPower() + c.getCurrentToughness()) {
-                    if (!c.isTapped() || (ph.inCombat() && game.getCombat().isAttacking(c))) {
-                        bFlag = true;
-                    }
-                }
-            }
-
-            if (!isSorcerySpeed(sa, aiPlayer) && !"Permanent".equals(sa.getParam("Duration"))) {
-                if (sa.isCrew() && c.isCreature()) {
-                    // Do not try to crew a vehicle which is already a creature
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
-                Card animatedCopy = becomeAnimated(c, sa);
-                if (ph.isPlayerTurn(aiPlayer)
-                        && !ComputerUtilCard.doesSpecifiedCreatureAttackAI(aiPlayer, animatedCopy)) {
-                    return new AiAbilityDecision(0, AiPlayDecision.DoesntImpactCombat);
-                }
-                if (ph.getPlayerTurn().isOpponentOf(aiPlayer)
-                        && !ComputerUtilCard.doesSpecifiedCreatureBlock(aiPlayer, animatedCopy)) {
-                    return new AiAbilityDecision(0, AiPlayDecision.DoesntImpactCombat);
-                }
-                // also check if maybe there are static effects applied to the animated copy that would matter
-                // (e.g. Myth Realized)
-                if (animatedCopy.getCurrentPower() + animatedCopy.getCurrentToughness() >
-                        c.getCurrentPower() + c.getCurrentToughness()) {
-                    if (!isAnimatedThisTurn(aiPlayer, source)) {
+                    if (power + toughness > c.getCurrentPower() + c.getCurrentToughness()) {
                         if (!c.isTapped() || (ph.inCombat() && game.getCombat().isAttacking(c))) {
                             bFlag = true;
                         }
                     }
                 }
+
+                if (!isSorcerySpeed(sa, aiPlayer) && !"Permanent".equals(sa.getParam("Duration"))) {
+                    if (sa.isCrew() && c.isCreature()) {
+                        // Do not try to crew a vehicle which is already a creature
+                        return false;
+                    }
+                    Card animatedCopy = becomeAnimated(c, sa);
+                    if (ph.isPlayerTurn(aiPlayer)
+                            && !ComputerUtilCard.doesSpecifiedCreatureAttackAI(aiPlayer, animatedCopy)) {
+                        return false;
+                    }
+                    if (ph.getPlayerTurn().isOpponentOf(aiPlayer)
+                            && !ComputerUtilCard.doesSpecifiedCreatureBlock(aiPlayer, animatedCopy)) {
+                        return false;
+                    }
+                    // also check if maybe there are static effects applied to the animated copy that would matter
+                    // (e.g. Myth Realized)
+                    if (animatedCopy.getCurrentPower() + animatedCopy.getCurrentToughness() >
+                            c.getCurrentPower() + c.getCurrentToughness()) {
+                        if (!isAnimatedThisTurn(aiPlayer, sa.getHostCard())) {
+                            if (!c.isTapped() || (ph.inCombat() && game.getCombat().isAttacking(c))) {
+                                bFlag = true;
+                            }
+                        }
+                    }
+                }
             }
+            if (bFlag) {
+                rememberAnimatedThisTurn(aiPlayer, sa.getHostCard());
+            }
+            return bFlag; // All of the defined stuff is animated, not very useful
+        } else {
+            sa.resetTargets();
+            return animateTgtAI(sa);
         }
-        if (bFlag) {
-            rememberAnimatedThisTurn(aiPlayer, source);
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         if (sa.usesTargeting()) {
             sa.resetTargets();
             return animateTgtAI(sa);
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
-        AiAbilityDecision decision;
-        if (sa.usesTargeting()) {
-            decision = animateTgtAI(sa);
-            if (decision.willingToPlay()) {
-                return decision;
-            } else if (!mandatory) {
-                return decision;
-            } else {
-                // fallback if animate is mandatory
-                sa.resetTargets();
-                List<Card> list = CardUtil.getValidCardsToTarget(sa);
-                if (list.isEmpty()) {
-                    return decision;
-                }
-                Card toAnimate = ComputerUtilCard.getWorstAI(list);
-                rememberAnimatedThisTurn(aiPlayer, toAnimate);
-                sa.getTargets().add(toAnimate);
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+        if (sa.usesTargeting() && !animateTgtAI(sa) && !mandatory) {
+            return false;
+        } else if (sa.usesTargeting() && mandatory) {
+            // fallback if animate is mandatory
+            sa.resetTargets();
+            List<Card> list = CardUtil.getValidCardsToTarget(sa);
+            if (list.isEmpty()) {
+                return false;
             }
+            Card toAnimate = ComputerUtilCard.getWorstAI(list);
+            rememberAnimatedThisTurn(aiPlayer, toAnimate);
+            sa.getTargets().add(toAnimate);
         }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     @Override
     public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {
         return player.getGame().getPhaseHandler().getPhase().isBefore(PhaseType.MAIN2);
     }
-
-    private AiAbilityDecision animateTgtAI(final SpellAbility sa) {
-        if (sa.getMaxTargets() == 0) {
-            // this happens if an optional cost is skipped, e.g. Brave the Wilds
-            return new AiAbilityDecision(80, AiPlayDecision.WillPlay);
-        }
+    
+    private boolean animateTgtAI(final SpellAbility sa) {
         final Player ai = sa.getActivatingPlayer();
-        final Game game = ai.getGame();
-        final PhaseHandler ph = game.getPhaseHandler();
+        final PhaseHandler ph = ai.getGame().getPhaseHandler();
         final String logic = sa.getParamOrDefault("AILogic", "");
         final boolean alwaysActivatePWAbility = sa.isPwAbility()
                 && sa.getPayCosts().hasSpecificCostType(CostPutCounter.class)
                 && sa.usesTargeting()
                 && sa.getTargetRestrictions().getMinTargets(sa.getHostCard(), sa) == 0;
-
+        
         final CardType types = new CardType(true);
         if (sa.hasParam("Types")) {
             types.addAll(Arrays.asList(sa.getParam("Types").split(",")));
         }
 
-        CardCollection list = CardLists.getTargetableCards(game.getCardsIn(ZoneType.Battlefield), sa);
-
-        list = ComputerUtil.filterAITgts(sa, ai, list, false);
-
-        // list is empty, no possible targets
-        if (list.isEmpty() && !alwaysActivatePWAbility) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-        }
-
         // something is used for animate into creature
         if (types.isCreature()) {
+            final Game game = ai.getGame();
+            CardCollection list = CardLists.getTargetableCards(game.getCardsIn(ZoneType.Battlefield), sa);
+
+            // Filter AI-specific targets if provided
+            list = ComputerUtil.filterAITgts(sa, ai, list, false);
+
+            // list is empty, no possible targets
+            if (list.isEmpty() && !alwaysActivatePWAbility) {
+                return false;
+            }
+
             Map<Card, Integer> data = Maps.newHashMap();
             for (final Card c : list) {
                 // don't use Permanent animate on something that would leave the field
@@ -364,14 +354,14 @@ public class AnimateAi extends SpellAbilityAi {
 
             // data is empty, no good targets
             if (data.isEmpty() && !alwaysActivatePWAbility) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
 
-            // get the best creature to be animated
+            // get the best creature to be animated 
             List<Card> maxList = Lists.newArrayList();
             int maxValue = 0;
             for (final Map.Entry<Card, Integer> e : data.entrySet()) {
-                int v = e.getValue();
+                int v = e.getValue(); 
                 if (v > maxValue) {
                     maxValue = v;
                     maxList.clear();
@@ -387,18 +377,17 @@ public class AnimateAi extends SpellAbilityAi {
                     holdAnimatedTillMain2(ai, worst);
                     if (!ComputerUtilMana.canPayManaCost(sa, ai, 0, sa.isTrigger())) {
                         releaseHeldTillMain2(ai, worst);
-                        return new AiAbilityDecision(0, AiPlayDecision.CantAfford);
+                        return false;
                     }
                 }
                 rememberAnimatedThisTurn(ai, worst);
                 sa.getTargets().add(worst);
             }
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
 
         if (logic.equals("SetPT")) {
-            // TODO: 1. Teach the AI to use this to save the creature from direct damage;
-            //  2. Determine the best target in a smarter way?
+            // TODO: 1. Teach the AI to use this to save the creature from direct damage; 2. Determine the best target in a smarter way?
             Card worst = ComputerUtilCard.getWorstCreatureAI(ai.getCreaturesInPlay());
             Card buffed = becomeAnimated(worst, sa);
 
@@ -406,45 +395,28 @@ public class AnimateAi extends SpellAbilityAi {
                     && (buffed.getNetPower() - worst.getNetPower() >= 3 || !ComputerUtilCard.doesCreatureAttackAI(ai, worst))) {
                 sa.getTargets().add(worst);
                 rememberAnimatedThisTurn(ai, worst);
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
         }
 
         if (logic.equals("ValuableAttackerOrBlocker")) {
             if (ph.inCombat()) {
                 final Combat combat = ph.getCombat();
+                CardCollection list = CardLists.getTargetableCards(ai.getGame().getCardsIn(ZoneType.Battlefield), sa);
                 for (Card c : list) {
                     Card animated = becomeAnimated(c, sa);
                     boolean isValuableAttacker = ph.is(PhaseType.MAIN1, ai) && ComputerUtilCard.doesSpecifiedCreatureAttackAI(ai, animated);
                     boolean isValuableBlocker = combat != null && combat.getDefendingPlayers().contains(ai) && ComputerUtilCard.doesSpecifiedCreatureBlock(ai, animated);
                     if (isValuableAttacker || isValuableBlocker)
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
                 }
             }
         }
-
-        if (logic.equals("Worst")) {
-            Card worst = ComputerUtilCard.getWorstPermanentAI(list, false, false, false, false);
-            if(worst != null) {
-                sa.getTargets().add(worst);
-                rememberAnimatedThisTurn(ai, worst);
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            }
-        }
-
-        if (sa.hasParam("AITgts") && !list.isEmpty()) {
-            //No logic, but we do have preferences. Pick the best among those?
-            Card best = ComputerUtilCard.getBestAI(list);
-            sa.getTargets().add(best);
-            rememberAnimatedThisTurn(ai, best);
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-
         // This is reasonable for now. Kamahl, Fist of Krosa and a sorcery or
         // two are the only things
         // that animate a target. Those can just use AI:RemoveDeck:All until
         // this can do a reasonably good job of picking a good target
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return false;
     }
 
     public static Card becomeAnimated(final Card card, final SpellAbility sa) {
@@ -564,7 +536,7 @@ public class AnimateAi extends SpellAbilityAi {
         CardTraitChanges traits = card.getChangedCardTraits().get(timestamp, 0);
         if (traits != null) {
             for (StaticAbility stAb : traits.getStaticAbilities()) {
-                if (stAb.checkMode(StaticAbilityMode.Continuous)) {
+                if ("Continuous".equals(stAb.getParam("Mode"))) {
                     for (final StaticAbilityLayer layer : stAb.getLayers()) {
                         StaticAbilityContinuous.applyContinuousAbility(stAb, new CardCollection(card), layer);
                     }
@@ -605,12 +577,4 @@ public class AnimateAi extends SpellAbilityAi {
     private void releaseHeldTillMain2(Player ai, Card c) {
         AiCardMemory.forgetCard(ai, c, AiCardMemory.MemorySet.HELD_MANA_SOURCES_FOR_MAIN2);
     }
-
-    @Override
-    public boolean willPayUnlessCost(SpellAbility sa, Player payer, Cost cost, boolean alreadyPaid, FCollectionView<Player> payers) {
-        if (sa.isKeyword(Keyword.RIOT)) {
-            return !SpecialAiLogic.preferHasteForRiot(sa, payer);
-        }
-        return super.willPayUnlessCost(sa, payer, cost, alreadyPaid, payers);
-    }
 }

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

@@ -1,7 +1,5 @@
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
@@ -11,30 +9,24 @@ import forge.game.spellability.SpellAbility;
 public class AnimateAllAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision canPlay(Player aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         String logic = sa.getParamOrDefault("AILogic", "");
 
         if ("CreatureAdvantage".equals(logic) && !aiPlayer.getCreaturesInPlay().isEmpty()) {
             // TODO: improve this or implement a better logic for abilities like Oko, the Trickster ultimate
             for (Card c : aiPlayer.getCreaturesInPlay()) {
                 if (ComputerUtilCard.doesCreatureAttackAI(aiPlayer, c)) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
         }
 
-        if ("Always".equals(logic)) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-    }
+        return "Always".equals(logic);
+    } // end animateAllCanPlayAI()
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
-        if (mandatory) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-        return canPlay(aiPlayer, sa);
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+        return mandatory || canPlayAI(aiPlayer, sa);
     }
 
 }

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

@@ -1,101 +0,0 @@
-package forge.ai.ability;
-
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
-import forge.ai.ComputerUtilCost;
-import forge.ai.SpellAbilityAi;
-import forge.game.GameEntity;
-import forge.game.ability.ApiType;
-import forge.game.card.Card;
-import forge.game.card.CardCollectionView;
-import forge.game.player.Player;
-import forge.game.spellability.SpellAbility;
-import forge.game.zone.ZoneType;
-
-import java.util.List;
-
-public class AssembleContraptionAi extends SpellAbilityAi {
-    @Override
-    protected AiAbilityDecision canPlay(Player ai, SpellAbility sa) {
-        CardCollectionView deck = getDeck(ai, sa);
-
-        if(deck.isEmpty())
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-
-        AiAbilityDecision superDecision = super.canPlay(ai, sa);
-        if (!superDecision.willingToPlay())
-            return superDecision;
-
-        if ("X".equals(sa.getParam("Amount")) && sa.getSVar("X").equals("Count$xPaid")) {
-            int xPay = ComputerUtilCost.getMaxXValue(sa, ai, sa.isTrigger());
-            xPay = Math.max(xPay, deck.size());
-            if (xPay == 0) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantAffordX);
-            }
-            sa.getRootAbility().setXManaCostPaid(xPay);
-        }
-
-        if(sa.hasParam("DefinedContraption") && sa.usesTargeting()) {
-            if (getGoodReassembleTarget(ai, sa) == null) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
-            }
-        }
-
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-    }
-
-    private static CardCollectionView getDeck(Player ai, SpellAbility sa) {
-        return ai.getCardsIn(sa.getApi() == ApiType.OpenAttraction ?
-                ZoneType.AttractionDeck : ZoneType.ContraptionDeck);
-    }
-
-    @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
-        if ("X".equals(sa.getParam("Amount")) && sa.getSVar("X").equals("Count$xPaid")) {
-            int xPay = ComputerUtilCost.getMaxXValue(sa, ai, sa.isTrigger());
-            if (xPay == 0) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
-            sa.getRootAbility().setXManaCostPaid(xPay);
-        }
-
-        if(sa.hasParam("DefinedContraption") && sa.usesTargeting()) {
-            Card target = getGoodReassembleTarget(ai, sa);
-            if(target != null)
-                sa.getTargets().add(target);
-            else
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-        }
-
-        return super.checkApiLogic(ai, sa);
-    }
-
-    private Card getGoodReassembleTarget(Player ai, SpellAbility sa) {
-        List<GameEntity> targets = sa.getTargetRestrictions().getAllCandidates(sa, true);
-        int nextSprocket = (ai.getCrankCounter() % 3) + 1;
-        return targets.stream()
-                .filter(e -> {
-                    if(!(e instanceof Card))
-                        return false;
-                    Card c = (Card) e;
-                    if(c.getController().isOpponentOf(ai))
-                        return true;
-                    return c.isContraption() && c.getSprocket() != nextSprocket;
-                }).map(c -> (Card) c)
-                .findFirst().orElse(null);
-    }
-
-    @Override
-    protected AiAbilityDecision doTriggerNoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
-        if(!mandatory && getDeck(aiPlayer, sa).isEmpty())
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-        return super.doTriggerNoCost(aiPlayer, sa, mandatory);
-    }
-
-    @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player aiPlayer) {
-        if(getDeck(aiPlayer, sa).isEmpty())
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-        return super.chkDrawback(sa, aiPlayer);
-    }
-}

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

@@ -1,22 +1,21 @@
 package forge.ai.ability;
 
-import com.google.common.collect.Iterables;
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
-import forge.ai.SpellAbilityAi;
-import forge.game.player.Player;
-import forge.game.spellability.SpellAbility;
-
 import java.util.List;
 import java.util.Map;
 
+import com.google.common.collect.Iterables;
+
+import forge.ai.SpellAbilityAi;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+
 public class AssignGroupAi extends SpellAbilityAi {
 
-    @Override
-    protected AiAbilityDecision canPlay(Player ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // TODO: Currently this AI relies on the card-specific limiting hints (NeedsToPlay / NeedsToPlayVar),
         // otherwise the AI considers the card playable.
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+
+        return true;
     }
 
     public SpellAbility chooseSingleSpellAbility(Player player, SpellAbility sa, List<SpellAbility> spells, Map<String, Object> params) {
@@ -28,7 +27,7 @@ public class AssignGroupAi extends SpellAbilityAi {
                 return spells.get(player.isOpponentOf(t) ? 1 : 0);
             }
         }
-
+        
         return Iterables.getFirst(spells, null);
     }
 }

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

@@ -1,58 +1,75 @@
 package forge.ai.ability;
 
+import java.util.*;
+
+import forge.game.card.*;
+import org.apache.commons.lang3.ObjectUtils;
+
+import com.google.common.base.Predicates;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
-import forge.ai.*;
+
+import forge.ai.AiAttackController;
+import forge.ai.AiCardMemory;
+import forge.ai.AiController;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.GameObject;
 import forge.game.ability.AbilityFactory;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
 import forge.game.combat.Combat;
 import forge.game.combat.CombatUtil;
 import forge.game.cost.Cost;
 import forge.game.cost.CostPart;
 import forge.game.cost.CostSacrifice;
 import forge.game.keyword.Keyword;
-import forge.game.keyword.KeywordInterface;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
-import forge.game.replacement.ReplacementLayer;
-import forge.game.replacement.ReplacementType;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.staticability.StaticAbility;
 import forge.game.staticability.StaticAbilityCantAttackBlock;
-import forge.game.staticability.StaticAbilityMode;
 import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 import forge.util.MyRandom;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Predicate;
-
 public class AttachAi extends SpellAbilityAi {
 
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getHostCard();
 
         // TODO: improve this so that the AI can use a flash aura buff as a means of killing opposing creatures
         // and gaining card advantage
         if (source.hasKeyword("MayFlashSac") && !ai.canCastSorcery()) {
-            return new AiAbilityDecision(0, AiPlayDecision.TimingRestrictions);
+            return false;
+        }
+
+        if (abCost != null) {
+            // AI currently disabled for these costs
+            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa)) {
+                return false;
+            }
+            if (!ComputerUtilCost.checkLifeCost(ai, abCost, source, 4, sa)) {
+                return false;
+            }
         }
 
         if (source.isAura() && sa.isSpell() && !source.ignoreLegendRule() && ai.isCardInPlay(source.getName())) {
@@ -60,16 +77,20 @@ public class AttachAi extends SpellAbilityAi {
 
             // TODO: Add some extra checks for where the AI may want to cast a replacement aura
             // on another creature and keep it when the original enchanted creature is useless
-            return new AiAbilityDecision(0, AiPlayDecision.WouldDestroyLegend);
+            return false;
+        }
+
+        // prevent run-away activations - first time will always return true
+        if (ComputerUtil.preventRunAwayActivations(sa)) {
+        	return false;
         }
 
         // Attach spells always have a target
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt != null) {
             sa.resetTargets();
-            AiAbilityDecision attachDecision = attachPreference(sa, tgt, false);
-            if (!attachDecision.willingToPlay()) {
-                return attachDecision;
+            if (!attachPreference(sa, tgt, false)) {
+                return false;
             }
         }
 
@@ -80,7 +101,7 @@ public class AttachAi extends SpellAbilityAi {
         }
         if ((source.hasKeyword(Keyword.FLASH) || (!ai.canCastSorcery() && sa.canCastTiming(ai)))
                 && source.isAura() && advancedFlash && !doAdvancedFlashAuraLogic(ai, sa, sa.getTargetCard())) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         if (abCost.getTotalMana().countX() > 0 && sa.getSVar("X").equals("Count$xPaid")) {
@@ -88,7 +109,7 @@ public class AttachAi extends SpellAbilityAi {
             final int xPay = ComputerUtilCost.getMaxXValue(sa, ai, sa.isTrigger());
 
             if (xPay == 0) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantAffordX);
+                return false;
             }
 
             sa.setXManaCostPaid(xPay);
@@ -96,12 +117,12 @@ 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 List<Card> targets = CardUtil.getValidCardsToTarget(effectExile);
-            return !targets.isEmpty() ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return !targets.isEmpty();
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     private boolean doAdvancedFlashAuraLogic(Player ai, SpellAbility sa, Card attachTarget) {
@@ -119,7 +140,7 @@ public class AttachAi extends SpellAbilityAi {
         int power = 0, toughness = 0;
         List<String> keywords = Lists.newArrayList();
         for (StaticAbility stAb : source.getStaticAbilities()) {
-            if (stAb.checkMode(StaticAbilityMode.Continuous)) {
+            if ("Continuous".equals(stAb.getParam("Mode"))) {
                 if (stAb.hasParam("AddPower")) {
                     power += AbilityUtils.calculateAmount(source, stAb.getParam("AddPower"), stAb);
                 }
@@ -296,8 +317,9 @@ public class AttachAi extends SpellAbilityAi {
         String type = "";
 
         for (final StaticAbility stAb : attachSource.getStaticAbilities()) {
-            if (stAb.checkMode(StaticAbilityMode.Continuous) && stAb.hasParam("AddType")) {
-                type = stAb.getParam("AddType");
+            final Map<String, String> stab = stAb.getMapParams();
+            if (stab.get("Mode").equals("Continuous") && stab.containsKey("AddType")) {
+                type = stab.get("AddType");
             }
         }
 
@@ -359,39 +381,9 @@ public class AttachAi extends SpellAbilityAi {
      */
     private static Card attachAIKeepTappedPreference(final SpellAbility sa, final List<Card> list, final boolean mandatory, final Card attachSource) {
         // AI For Cards like Paralyzing Grasp and Glimmerdust Nap
-
-        // check for ETB Trigger
-        boolean tapETB = isAuraSpell(sa) && attachSource.getTriggers().anyMatch(t -> {
-            if (t.getMode() != TriggerType.ChangesZone) {
-                return false;
-            }
-
-            if (!ZoneType.Battlefield.toString().equals(t.getParam("Destination"))) {
-                return false;
-            }
-
-            if (t.hasParam("ValidCard") && !t.getParam("ValidCard").contains("Self")) {
-                return false;
-            }
-
-            SpellAbility tSa = t.ensureAbility();
-            if (tSa == null) {
-                return false;
-            }
-
-            if (!ApiType.Tap.equals(tSa.getApi())) {
-                return false;
-            }
-            if (!"Enchanted".equals(tSa.getParam("Defined"))) {
-                return false;
-            }
-
-            return true;
-        });
-
         final List<Card> prefList = CardLists.filter(list, c -> {
             // Don't do Untapped Vigilance cards
-            if (!tapETB && c.isCreature() && c.hasKeyword(Keyword.VIGILANCE) && c.isUntapped()) {
+            if (c.isCreature() && c.hasKeyword(Keyword.VIGILANCE) && c.isUntapped()) {
                 return false;
             }
 
@@ -406,9 +398,20 @@ public class AttachAi extends SpellAbilityAi {
                     return false;
                 }
             }
-            // already affected
-            if (!c.canUntap(c.getController(), true)) {
-                return false;
+
+            if (!c.isEnchanted()) {
+                return true;
+            }
+
+            final Iterable<Card> auras = c.getEnchantedBy();
+            for (Card aura : auras) {
+                SpellAbility auraSA = aura.getSpells().get(0);
+                if (auraSA.getApi() == ApiType.Attach) {
+                    if ("KeepTapped".equals(auraSA.getParam("AILogic"))) {
+                        // Don't attach multiple KeepTapped Auras to one card
+                        return false;
+                    }
+                }
             }
 
             return true;
@@ -493,29 +496,29 @@ public class AttachAi extends SpellAbilityAi {
      */
     private static Card attachAIAnimatePreference(final SpellAbility sa, final List<Card> list, final boolean mandatory,
             final Card attachSource) {
-        if (list.isEmpty()) {
-            return null;
-        }
-        Card card = null;
+    	if (list.isEmpty()) {
+    		return null;
+    	}
+    	Card card = null;
         // AI For choosing a Card to Animate.
         List<Card> betterList = CardLists.getNotType(list, "Creature");
         if (ComputerUtilAbility.getAbilitySourceName(sa).equals("Animate Artifact")) {
             betterList = CardLists.filter(betterList, c -> c.getCMC() > 0);
             card = ComputerUtilCard.getMostExpensivePermanentAI(betterList);
         } else {
-            List<Card> evenBetterList = CardLists.filter(betterList, c -> c.hasKeyword(Keyword.INDESTRUCTIBLE) || c.hasKeyword(Keyword.HEXPROOF));
-            if (!evenBetterList.isEmpty()) {
-                betterList = evenBetterList;
-            }
-            evenBetterList = CardLists.filter(betterList, CardPredicates.UNTAPPED);
-            if (!evenBetterList.isEmpty()) {
-                betterList = evenBetterList;
-            }
-            evenBetterList = CardLists.filter(betterList, c -> c.getTurnInZone() != c.getGame().getPhaseHandler().getTurn());
-            if (!evenBetterList.isEmpty()) {
-                betterList = evenBetterList;
-            }
-            evenBetterList = CardLists.filter(betterList, c -> {
+        	List<Card> evenBetterList = CardLists.filter(betterList, c -> c.hasKeyword(Keyword.INDESTRUCTIBLE) || c.hasKeyword(Keyword.HEXPROOF));
+        	if (!evenBetterList.isEmpty()) {
+        		betterList = evenBetterList;
+        	}
+        	evenBetterList = CardLists.filter(betterList, CardPredicates.Presets.UNTAPPED);
+        	if (!evenBetterList.isEmpty()) {
+        		betterList = evenBetterList;
+        	}
+        	evenBetterList = CardLists.filter(betterList, c -> c.getTurnInZone() != c.getGame().getPhaseHandler().getTurn());
+        	if (!evenBetterList.isEmpty()) {
+        		betterList = evenBetterList;
+        	}
+        	evenBetterList = CardLists.filter(betterList, c -> {
                 for (final SpellAbility sa1 : c.getSpellAbilities()) {
                     if (sa1.isAbility() && sa1.getPayCosts().hasTapCost()) {
                         return false;
@@ -523,10 +526,10 @@ public class AttachAi extends SpellAbilityAi {
                 }
                 return true;
             });
-            if (!evenBetterList.isEmpty()) {
-                betterList = evenBetterList;
-            }
-            card = ComputerUtilCard.getWorstAI(betterList);
+        	if (!evenBetterList.isEmpty()) {
+        		betterList = evenBetterList;
+        	}
+        	card = ComputerUtilCard.getWorstAI(betterList);
         }
 
 
@@ -556,46 +559,28 @@ public class AttachAi extends SpellAbilityAi {
             final Card attachSource) {
         // AI For choosing a Card to Animate.
         final Player ai = sa.getActivatingPlayer();
-        Card attachSourceLki = null;
-        for (Trigger t : attachSource.getTriggers()) {
-            if (!t.getMode().equals(TriggerType.ChangesZone)) {
-                continue;
-            }
-            if (!"Battlefield".equals(t.getParam("Destination"))) {
-                continue;
-            }
-            if (!"Card.Self".equals(t.getParam("ValidCard"))) {
-                continue;
-            }
-            SpellAbility trigSa = t.ensureAbility();
-            SpellAbility animateSa = trigSa.findSubAbilityByType(ApiType.Animate);
-            if (animateSa == null) {
-                continue;
-            }
-            animateSa.setActivatingPlayer(sa.getActivatingPlayer());
-            attachSourceLki = AnimateAi.becomeAnimated(attachSource, animateSa);
-        }
-        if (attachSourceLki == null) {
-            return null;
-        }
+        final Card attachSourceLki = CardCopyService.getLKICopy(attachSource);
         attachSourceLki.setLastKnownZone(ai.getZone(ZoneType.Battlefield));
-        final Card finalAttachSourceLki = attachSourceLki;
+        // Suppress original attach Spell to replace it with another
+        attachSourceLki.getFirstAttachSpell().setSuppressed(true);
 
+        //TODO for Reanimate Auras i need the new Attach Spell, in later versions it might be part of the Enchant Keyword
+        attachSourceLki.addSpellAbility(AbilityFactory.getAbility(attachSourceLki, "NewAttach"));
         List<Card> betterList = CardLists.filter(list, c -> {
             final Card lki = CardCopyService.getLKICopy(c);
             // need to fake it as if lki would be on the battlefield
             lki.setLastKnownZone(ai.getZone(ZoneType.Battlefield));
 
             // Reanimate Auras use "Enchant creature put onto the battlefield with CARDNAME" with Remembered
-            finalAttachSourceLki.clearRemembered();
-            finalAttachSourceLki.addRemembered(lki);
+            attachSourceLki.clearRemembered();
+            attachSourceLki.addRemembered(lki);
 
             // need to check what the cards would be on the battlefield
             // do not attach yet, that would cause Events
             CardCollection preList = new CardCollection(lki);
-            preList.add(finalAttachSourceLki);
+            preList.add(attachSourceLki);
             c.getGame().getAction().checkStaticAbilities(false, Sets.newHashSet(preList), preList);
-            boolean result = lki.canBeAttached(finalAttachSourceLki, null);
+            boolean result = lki.canBeAttached(attachSourceLki, null);
 
             //reset static abilities
             c.getGame().getAction().checkStaticAbilities(false);
@@ -820,45 +805,27 @@ public class AttachAi extends SpellAbilityAi {
         int totPower = 0;
         final List<String> keywords = new ArrayList<>();
 
-        boolean cantAttack = false;
-        boolean cantBlock = false;
-
         for (final StaticAbility stAbility : attachSource.getStaticAbilities()) {
-            if (stAbility.checkMode(StaticAbilityMode.CantAttack)) {
-                String valid = stAbility.getParam("ValidCard");
-                if (valid.contains(stCheck) || valid.contains("AttachedBy")) {
-                    cantAttack = true;
-                }
-            } else if (stAbility.checkMode(StaticAbilityMode.CantBlock)) {
-                String valid = stAbility.getParam("ValidCard");
-                if (valid.contains(stCheck) || valid.contains("AttachedBy")) {
-                    cantBlock = true;
-                }
-            } else if (stAbility.checkMode(StaticAbilityMode.CantBlockBy)) {
-                String valid = stAbility.getParam("ValidBlocker");
-                if (valid.contains(stCheck) || valid.contains("AttachedBy")) {
-                    cantBlock = true;
-                }
-            }
+            final Map<String, String> stabMap = stAbility.getMapParams();
 
-            if (!stAbility.checkMode(StaticAbilityMode.Continuous)) {
+            if (!stabMap.get("Mode").equals("Continuous")) {
                 continue;
             }
 
-            final String affected = stAbility.getParam("Affected");
+            final String affected = stabMap.get("Affected");
 
             if (affected == null) {
                 continue;
             }
             if ((affected.contains(stCheck) || affected.contains("AttachedBy"))) {
-                totToughness += AbilityUtils.calculateAmount(attachSource, stAbility.getParam("AddToughness"), sa);
-                totPower += AbilityUtils.calculateAmount(attachSource, stAbility.getParam("AddPower"), sa);
+                totToughness += AbilityUtils.calculateAmount(attachSource, stabMap.get("AddToughness"), sa);
+                totPower += AbilityUtils.calculateAmount(attachSource, stabMap.get("AddPower"), sa);
 
-                String kws = stAbility.getParam("AddKeyword");
+                String kws = stabMap.get("AddKeyword");
                 if (kws != null) {
                     keywords.addAll(Arrays.asList(kws.split(" & ")));
                 }
-                kws = stAbility.getParam("AddHiddenKeyword");
+                kws = stabMap.get("AddHiddenKeyword");
                 if (kws != null) {
                     keywords.addAll(Arrays.asList(kws.split(" & ")));
                 }
@@ -894,16 +861,10 @@ public class AttachAi extends SpellAbilityAi {
             prefList = CardLists.filter(prefList, c -> c.getNetPower() > 0 && ComputerUtilCombat.canAttackNextTurn(c));
         }
 
-        if (cantAttack) {
-            prefList = CardLists.filter(prefList, c -> c.isCreature() && ComputerUtilCombat.canAttackNextTurn(c));
-        } else if (cantBlock) { // TODO better can block filter?
-            prefList = CardLists.filter(prefList, c -> c.isCreature() && !ComputerUtilCard.isUselessCreature(ai, c));
-        }
-
         //some auras aren't useful in multiples
         if (attachSource.hasSVar("NonStackingAttachEffect")) {
             prefList = CardLists.filter(prefList,
-                CardPredicates.isEnchantedBy(attachSource.getName()).negate()
+                Predicates.not(CardPredicates.isEnchantedBy(attachSource.getName()))
             );
         }
 
@@ -941,8 +902,9 @@ public class AttachAi extends SpellAbilityAi {
      * @return true, if successful
      */
     @Override
-    protected AiAbilityDecision doTriggerNoCost(final Player ai, final SpellAbility sa, final boolean mandatory) {
+    protected boolean doTriggerAINoCost(final Player ai, final SpellAbility sa, final boolean mandatory) {
         final Card card = sa.getHostCard();
+        // Check if there are any valid targets
         List<GameObject> targets = new ArrayList<>();
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         if (tgt == null) {
@@ -954,48 +916,23 @@ public class AttachAi extends SpellAbilityAi {
 
         if (!mandatory && card.isEquipment() && !targets.isEmpty()) {
             Card newTarget = (Card) targets.get(0);
+            //don't equip human creatures
             if (newTarget.getController().isOpponentOf(ai)) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
+
+            //don't equip a worse creature
             if (card.isEquipping()) {
                 Card oldTarget = card.getEquipping();
                 if (ComputerUtilCard.evaluateCreature(oldTarget) > ComputerUtilCard.evaluateCreature(newTarget)) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
-                boolean stacking = !card.hasSVar("NonStackingAttachEffect") || !newTarget.isEquippedBy(card.getName());
-                if (!stacking) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
+                // don't equip creatures that don't gain anything
+                return !card.hasSVar("NonStackingAttachEffect") || !newTarget.isEquippedBy(card.getName());
             }
         }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-    }
 
-    @Override
-    public AiAbilityDecision chkDrawback(final SpellAbility sa, final Player ai) {
-        if (sa.isTrigger() && sa.usesTargeting()) {
-            CardCollection targetables = CardLists.getTargetableCards(ai.getCardsIn(ZoneType.Battlefield), sa);
-            CardCollection source = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Object"), sa);
-            Card tgt = attachGeneralAI(ai, sa, targetables, !sa.getRootAbility().isOptionalTrigger(), source.getFirst(), null);
-            if (tgt != null) {
-                sa.resetTargets();
-                sa.getTargets().add(tgt);
-            }
-            if (sa.isTargetNumberValid()) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            } else {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
-            }
-        } else if ("Remembered".equals(sa.getParam("Defined")) && sa.getParent() != null
-            && sa.getParent().getApi() == ApiType.Token && sa.getParent().hasParam("RememberTokens")) {
-            // Living Weapon or similar
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-    }
-
-    private static boolean isAuraSpell(final SpellAbility sa) {
-        return sa.isSpell() && sa.getHostCard().isAura();
+        return true;
     }
 
     /**
@@ -1011,25 +948,9 @@ public class AttachAi extends SpellAbilityAi {
      *            the mandatory
      * @return true, if successful
      */
-    private static AiAbilityDecision attachPreference(final SpellAbility sa, final TargetRestrictions tgt, final boolean mandatory) {
+    private static boolean attachPreference(final SpellAbility sa, final TargetRestrictions tgt, final boolean mandatory) {
         GameObject o;
-        boolean spellCanTargetPlayer = false;
-        if (isAuraSpell(sa)) {
-            Card source = sa.getHostCard();
-            if (!source.hasKeyword(Keyword.ENCHANT)) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
-            }
-            for (KeywordInterface ki : source.getKeywords(Keyword.ENCHANT)) {
-                String ko = ki.getOriginal();
-                String m[] = ko.split(":");
-                String v = m[1];
-                if (v.contains("Player") || v.contains("Opponent")) {
-                    spellCanTargetPlayer = true;
-                    break;
-                }
-            }
-        }
-        if (tgt.canTgtPlayer() && (!isAuraSpell(sa) || spellCanTargetPlayer)) {
+        if (tgt.canTgtPlayer()) {
             List<Player> targetable = new ArrayList<>();
             for (final Player player : sa.getHostCard().getGame().getPlayers()) {
                 if (sa.canTarget(player)) {
@@ -1042,11 +963,11 @@ public class AttachAi extends SpellAbilityAi {
         }
 
         if (o == null) {
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
         }
 
         sa.getTargets().add(o);
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     /**
@@ -1094,8 +1015,9 @@ public class AttachAi extends SpellAbilityAi {
         CardCollection toRemove = new CardCollection();
         for (Trigger t : attachSource.getTriggers()) {
             if (t.getMode() == TriggerType.ChangesZone) {
-                if ("Card.Self".equals(t.getParam("ValidCard"))
-                        && "Battlefield".equals(t.getParam("Destination"))) {
+                final Map<String, String> params = t.getMapParams();
+                if ("Card.Self".equals(params.get("ValidCard"))
+                        && "Battlefield".equals(params.get("Destination"))) {
                     SpellAbility trigSa = t.ensureAbility();
                     if (trigSa != null && trigSa.getApi() == ApiType.DealDamage && "Enchanted".equals(trigSa.getParam("Defined"))) {
                         for (Card target : list) {
@@ -1132,17 +1054,17 @@ public class AttachAi extends SpellAbilityAi {
                 // Probably want to "weight" the list by amount of Enchantments and
                 // choose the "lightest"
 
-                List<Card> betterList = CardLists.filter(magnetList, c -> CombatUtil.canAttack(c, ai.getWeakestOpponent()));
-                if (!betterList.isEmpty()) {
-                    return ComputerUtilCard.getBestAI(betterList);
-                }
+            	List<Card> betterList = CardLists.filter(magnetList, c -> CombatUtil.canAttack(c, ai.getWeakestOpponent()));
+            	if (!betterList.isEmpty()) {
+            		return ComputerUtilCard.getBestAI(betterList);
+            	}
 
-                // Magnet List should not be attached when they are useless
-                betterList = CardLists.filter(magnetList, c -> !ComputerUtilCard.isUselessCreature(ai, c));
+            	// Magnet List should not be attached when they are useless
+            	betterList = CardLists.filter(magnetList, c -> !ComputerUtilCard.isUselessCreature(ai, c));
 
-                if (!betterList.isEmpty()) {
-                    return ComputerUtilCard.getBestAI(betterList);
-                }
+            	if (!betterList.isEmpty()) {
+            		return ComputerUtilCard.getBestAI(betterList);
+            	}
 
                 //return ComputerUtilCard.getBestAI(magnetList);
             }
@@ -1155,27 +1077,29 @@ public class AttachAi extends SpellAbilityAi {
         boolean grantingExtraBlock = false;
 
         for (final StaticAbility stAbility : attachSource.getStaticAbilities()) {
-            if (!stAbility.checkMode(StaticAbilityMode.Continuous)) {
+            final Map<String, String> stabMap = stAbility.getMapParams();
+
+            if (!"Continuous".equals(stabMap.get("Mode"))) {
                 continue;
             }
 
-            final String affected = stAbility.getParam("Affected");
+            final String affected = stabMap.get("Affected");
 
             if (affected == null) {
                 continue;
             }
             if (affected.contains(stCheck) || affected.contains("AttachedBy")) {
-                totToughness += AbilityUtils.calculateAmount(attachSource, stAbility.getParam("AddToughness"), stAbility);
-                totPower += AbilityUtils.calculateAmount(attachSource, stAbility.getParam("AddPower"), stAbility);
+                totToughness += AbilityUtils.calculateAmount(attachSource, stabMap.get("AddToughness"), stAbility);
+                totPower += AbilityUtils.calculateAmount(attachSource, stabMap.get("AddPower"), stAbility);
 
-                grantingAbilities |= stAbility.hasParam("AddAbility");
-                grantingExtraBlock |= stAbility.hasParam("CanBlockAmount") || stAbility.hasParam("CanBlockAny");
+                grantingAbilities |= stabMap.containsKey("AddAbility");
+                grantingExtraBlock |= stabMap.containsKey("CanBlockAmount") || stabMap.containsKey("CanBlockAny");
 
-                String kws = stAbility.getParam("AddKeyword");
+                String kws = stabMap.get("AddKeyword");
                 if (kws != null) {
                     keywords.addAll(Arrays.asList(kws.split(" & ")));
                 }
-                kws = stAbility.getParam("AddHiddenKeyword");
+                kws = stabMap.get("AddHiddenKeyword");
                 if (kws != null) {
                     keywords.addAll(Arrays.asList(kws.split(" & ")));
                 }
@@ -1219,23 +1143,23 @@ public class AttachAi extends SpellAbilityAi {
 
         //some auras/equipments aren't useful in multiples
         if (attachSource.hasSVar("NonStackingAttachEffect")) {
-            prefList = CardLists.filter(prefList, Predicate.not(
-                    CardPredicates.isEquippedBy(attachSource.getName())
-                            .or(CardPredicates.isEnchantedBy(attachSource.getName()))
-            ));
+            prefList = CardLists.filter(prefList, Predicates.not(Predicates.or(
+                CardPredicates.isEquippedBy(attachSource.getName()),
+                CardPredicates.isEnchantedBy(attachSource.getName())
+            )));
         }
 
         // Don't pump cards that will die.
         prefList = ComputerUtil.getSafeTargets(ai, sa, prefList);
 
         if (attachSource.isAura()) {
-            if (!attachSource.getName().equals("Daybreak Coronet")) {
-                // TODO For Auras like Rancor, that aren't as likely to lead to
-                // card disadvantage, this check should be skipped
-                prefList = CardLists.filter(prefList, c -> !c.isEnchanted() || c.hasKeyword(Keyword.HEXPROOF));
-            }
+        	if (!attachSource.getName().equals("Daybreak Coronet")) {
+	            // TODO For Auras like Rancor, that aren't as likely to lead to
+	            // card disadvantage, this check should be skipped
+	            prefList = CardLists.filter(prefList, c -> !c.isEnchanted() || c.hasKeyword(Keyword.HEXPROOF));
+        	}
 
-            // should not attach Auras to creatures that does leave the play
+        	// should not attach Auras to creatures that does leave the play
             prefList = CardLists.filter(prefList, c -> !c.hasSVar("EndOfTurnLeavePlay"));
         }
 
@@ -1244,15 +1168,10 @@ public class AttachAi extends SpellAbilityAi {
         // TODO Somehow test for definitive advantage (e.g. opponent low on health, AI is attacking)
         // to be able to deal the final blow with an enchanted vehicle like that
         boolean canOnlyTargetCreatures = true;
-        if (attachSource.isAura()) {
-            for (KeywordInterface ki : attachSource.getKeywords(Keyword.ENCHANT)) {
-                String o = ki.getOriginal();
-                String m[] = o.split(":");
-                String v = m[1];
-                if (!v.startsWith("Creature")) {
-                    canOnlyTargetCreatures = false;
-                    break;
-                }
+        for (String valid : ObjectUtils.firstNonNull(attachSource.getFirstAttachSpell(), sa).getTargetRestrictions().getValidTgts()) {
+            if (!valid.startsWith("Creature")) {
+                canOnlyTargetCreatures = false;
+                break;
             }
         }
         if (canOnlyTargetCreatures && (attachSource.isAura() || attachSource.isEquipment())) {
@@ -1263,7 +1182,7 @@ public class AttachAi extends SpellAbilityAi {
             // Probably prefer to Enchant Creatures that Can Attack
             // Filter out creatures that can't Attack or have Defender
             if (keywords.isEmpty()) {
-                final int powerBonus = totPower;
+            	final int powerBonus = totPower;
                 prefList = CardLists.filter(prefList, c -> {
                     if (!c.isCreature()) {
                         return true;
@@ -1328,8 +1247,8 @@ public class AttachAi extends SpellAbilityAi {
 
         // Is a SA that moves target attachment
         if ("MoveTgtAura".equals(sa.getParam("AILogic"))) {
-            CardCollection list = CardLists.filter(CardUtil.getValidCardsToTarget(sa), CardPredicates.isControlledByAnyOf(aiPlayer.getOpponents())
-                    .or(card -> ComputerUtilCard.isUselessCreature(aiPlayer, card.getAttachedTo())));
+            CardCollection list = CardLists.filter(CardUtil.getValidCardsToTarget(sa), Predicates.or(CardPredicates.isControlledByAnyOf(aiPlayer.getOpponents()),
+                    card -> ComputerUtilCard.isUselessCreature(aiPlayer, card.getAttachedTo())));
 
             return !list.isEmpty() ? ComputerUtilCard.getBestAI(list) : null;
         } else if ("Unenchanted".equals(sa.getParam("AILogic"))) {
@@ -1478,6 +1397,8 @@ public class AttachAi extends SpellAbilityAi {
             c = attachAICuriosityPreference(sa, prefList, mandatory, attachSource);
         } else if ("ChangeType".equals(logic)) {
             c = attachAIChangeTypePreference(sa, prefList, mandatory, attachSource);
+        } else if ("KeepTapped".equals(logic)) {
+            c = attachAIKeepTappedPreference(sa, prefList, mandatory, attachSource);
         } else if ("Animate".equals(logic)) {
             c = attachAIAnimatePreference(sa, prefList, mandatory, attachSource);
         } else if ("Reanimate".equals(logic)) {
@@ -1488,12 +1409,6 @@ public class AttachAi extends SpellAbilityAi {
             c = attachAIHighestEvaluationPreference(prefList);
         }
 
-        if (isAuraSpell(sa)) {
-            if (attachSource.getReplacementEffects().anyMatch(re -> re.getMode().equals(ReplacementType.Untap) && re.getLayer().equals(ReplacementLayer.CantHappen))) {
-                c = attachAIKeepTappedPreference(sa, prefList, mandatory, attachSource);
-            }
-        }
-
         // Consider exceptional cases which break the normal evaluation rules
         if (!isUsefulAttachAction(ai, c, sa)) {
             return null;
@@ -1646,6 +1561,8 @@ public class AttachAi extends SpellAbilityAi {
         } else if (keyword.endsWith("Prevent all combat damage that would be dealt to and dealt by CARDNAME.")
                 || keyword.endsWith("Prevent all damage that would be dealt to and dealt by CARDNAME.")) {
             return card.getNetCombatDamage() >= 2 && ComputerUtilCombat.canAttackNextTurn(card);
+        } else if (keyword.endsWith("CARDNAME doesn't untap during your untap step.")) {
+            return !card.isUntapped();
         }
         return true;
     }
@@ -1698,6 +1615,25 @@ public class AttachAi extends SpellAbilityAi {
         return chosen;
     }
 
+    @Override
+    public boolean chkAIDrawback(final SpellAbility sa, final Player ai) {
+        // TODO for targeting optional Halvar trigger, needs to be coordinated with PumpAi to make it playable
+        if (sa.isTrigger() && sa.usesTargeting()) {
+            CardCollection targetables = CardLists.getTargetableCards(ai.getCardsIn(ZoneType.Battlefield), sa);
+            CardCollection source = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Object"), sa);
+            Card tgt = attachGeneralAI(ai, sa, targetables, !sa.getRootAbility().isOptionalTrigger(), source.getFirst(), null);
+            if (tgt != null) {
+                sa.resetTargets();
+                sa.getTargets().add(tgt);
+            }
+            return sa.isTargetNumberValid();
+        } else if ("Remembered".equals(sa.getParam("Defined")) && sa.getParent() != null
+            && sa.getParent().getApi() == ApiType.Token && sa.getParent().hasParam("RememberTokens")) {
+            // Living Weapon or similar
+            return true;
+        }
+        return false;
+    }
 
     @Override
     public boolean confirmAction(Player player, SpellAbility sa, PlayerActionConfirmMode mode, String message, Map<String, Object> params) {

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

@@ -1,7 +1,5 @@
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
 import forge.ai.SpellAbilityAi;
 import forge.game.card.CardCollectionView;
 import forge.game.card.CardLists;
@@ -13,7 +11,7 @@ import forge.util.MyRandom;
 
 public class BalanceAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision canPlay(Player aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         String logic = sa.getParam("AILogic");
         int diff = 0;
         Player opp = aiPlayer.getWeakestOpponent();
@@ -27,10 +25,10 @@ public class BalanceAi extends SpellAbilityAi {
         
         if ("BalanceCreaturesAndLands".equals(logic)) {
             // TODO Copied over from hardcoded Balance. We should be checking value of the lands/creatures for each opponent, not just counting
-            diff += CardLists.filter(humPerms, CardPredicates.LANDS).size() -
-                    CardLists.filter(compPerms, CardPredicates.LANDS).size();
-            diff += 1.5 * (CardLists.filter(humPerms, CardPredicates.CREATURES).size() -
-                    CardLists.filter(compPerms, CardPredicates.CREATURES).size());
+            diff += CardLists.filter(humPerms, CardPredicates.Presets.LANDS).size() - 
+                    CardLists.filter(compPerms, CardPredicates.Presets.LANDS).size();
+            diff += 1.5 * (CardLists.filter(humPerms, CardPredicates.Presets.CREATURES).size() - 
+                    CardLists.filter(compPerms, CardPredicates.Presets.CREATURES).size());
         }
         else if ("BalancePermanents".equals(logic)) {
             // Don't cast if you have to sacrifice permanents
@@ -39,7 +37,7 @@ public class BalanceAi extends SpellAbilityAi {
 
         if (diff < 0) {
             // Don't sacrifice permanents even if opponent has a ton of cards in hand
-            return new AiAbilityDecision(0, forge.ai.AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         final CardCollectionView humHand = opp.getCardsIn(ZoneType.Hand);
@@ -47,7 +45,6 @@ public class BalanceAi extends SpellAbilityAi {
         diff += 0.5 * (humHand.size() - compHand.size());
 
         // Larger differential == more chance to actually cast this spell
-        boolean willPlay = diff > 2 && MyRandom.getRandom().nextInt(100) < diff*10;
-        return new AiAbilityDecision(willPlay ? 100 : 0, willPlay ? forge.ai.AiPlayDecision.WillPlay : AiPlayDecision.StopRunawayActivations);
+        return diff > 2 && MyRandom.getRandom().nextInt(100) < diff*10;
     }
 }

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

@@ -1,7 +1,6 @@
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
@@ -17,51 +16,55 @@ import forge.game.zone.ZoneType;
 
 public class BecomesBlockedAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision canPlay(Player aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         final Card source = sa.getHostCard();
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         final Game game = aiPlayer.getGame();
 
         if (!game.getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS)
                 || !game.getPhaseHandler().getPlayerTurn().isOpponentOf(aiPlayer)) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         if (tgt != null) {
-            sa.resetTargets();
-            CardCollection list = CardLists.filterControlledBy(game.getCardsIn(ZoneType.Battlefield), aiPlayer.getOpponents());
-            list = CardLists.getTargetableCards(list, sa);
-            list = CardLists.getNotKeyword(list, Keyword.TRAMPLE);
+        	sa.resetTargets();
+	        CardCollection list = CardLists.filterControlledBy(game.getCardsIn(ZoneType.Battlefield), aiPlayer.getOpponents());
+	        list = CardLists.getTargetableCards(list, sa);
+	        list = CardLists.getNotKeyword(list, Keyword.TRAMPLE);
 
-            while (sa.canAddMoreTarget()) {
-                Card choice = null;
+	        while (sa.canAddMoreTarget()) {
+	            Card choice = null;
 
-                if (list.isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
+	            if (list.isEmpty()) {
+	                return false;
+	            }
 
-                choice = ComputerUtilCard.getBestCreatureAI(list);
+	            choice = ComputerUtilCard.getBestCreatureAI(list);
 
-                if (choice == null) { // can't find anything left
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
+	            if (choice == null) { // can't find anything left
+	                return false;
+	            }
 
-                list.remove(choice);
-                sa.getTargets().add(choice);
-            }
+	            list.remove(choice);
+	            sa.getTargets().add(choice);
+	        }
         }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         // TODO - implement AI
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return false;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+        boolean chance;
+
         // TODO - implement AI
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        chance = false;
+
+        return chance;
     }
 }

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

@@ -1,8 +1,8 @@
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
+import java.util.List;
+
 import forge.ai.AiAttackController;
-import forge.ai.AiPlayDecision;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
@@ -12,13 +12,12 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
-
-import java.util.List;
+import forge.util.MyRandom;
 
 public class BidLifeAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision checkApiLogic(Player aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         final Card source = sa.getHostCard();
         final Game game = source.getGame();
         TargetRestrictions tgt = sa.getTargetRestrictions();
@@ -27,31 +26,31 @@ public class BidLifeAi extends SpellAbilityAi {
             if (tgt.canTgtCreature()) {
                 List<Card> list = CardLists.getTargetableCards(AiAttackController.choosePreferredDefenderPlayer(aiPlayer).getCardsIn(ZoneType.Battlefield), sa);
                 if (list.isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                    return false;
                 }
                 Card c = ComputerUtilCard.getBestCreatureAI(list);
                 if (sa.canTarget(c)) {
                     sa.getTargets().add(c);
                 } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                    return false;
                 }
             } else if (tgt.getZone().contains(ZoneType.Stack)) {
                 if (game.getStack().isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
                 final SpellAbility topSA = game.getStack().peekAbility();
                 if (!topSA.isCounterableBy(sa) || aiPlayer.equals(topSA.getActivatingPlayer())) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
                 if (sa.canTargetSpellAbility(topSA)) {
                     sa.getTargets().add(topSA);
                 } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                    return false;
                 }
             }
         }
-
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        return chance;
     }
 
 }

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

@@ -17,16 +17,14 @@
  */
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+import java.util.Map;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 
-import java.util.Map;
-
 /**
  * <p>
  * AbilityFactoryBond class.
@@ -48,9 +46,9 @@ public final class BondAi extends SpellAbilityAi {
      * @return a boolean.
      */
     @Override
-    protected AiAbilityDecision canPlay(Player aiPlayer, SpellAbility sa) {
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-    }
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
+        return true;
+    } // end bondCanPlayAI()
 
     @Override
     protected Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
@@ -58,7 +56,7 @@ public final class BondAi extends SpellAbilityAi {
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+    protected boolean doTriggerAINoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
+        return true;
     }
 }

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

@@ -1,8 +1,6 @@
 package forge.ai.ability;
 
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpecialAiLogic;
 import forge.ai.SpecialCardAi;
@@ -23,18 +21,16 @@ public class BranchAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected AiAbilityDecision canPlay(Player aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         final String aiLogic = sa.getParamOrDefault("AILogic", "");
         if ("GrislySigil".equals(aiLogic)) {
-            boolean result = SpecialCardAi.GrislySigil.consider(aiPlayer, sa);
-            return new AiAbilityDecision(result ? 100 : 0, result ? AiPlayDecision.WillPlay : AiPlayDecision.CantPlayAi);
+            return SpecialCardAi.GrislySigil.consider(aiPlayer, sa);
         } else if ("BranchCounter".equals(aiLogic)) {
-            boolean result = SpecialAiLogic.doBranchCounterspellLogic(aiPlayer, sa);
-            return new AiAbilityDecision(result ? 100 : 0, result ? AiPlayDecision.WillPlay : AiPlayDecision.CantPlayAi);
+            return SpecialAiLogic.doBranchCounterspellLogic(aiPlayer, sa); // Bring the Ending, Anticognition (hacky implementation)
         } else if ("TgtAttacker".equals(aiLogic)) {
             final Combat combat = aiPlayer.getGame().getCombat();
             if (combat == null || combat.getAttackingPlayer() != aiPlayer) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
 
             final CardCollection attackers = combat.getAttackers();
@@ -49,20 +45,16 @@ public class BranchAi extends SpellAbilityAi {
                 sa.getTargets().add(ComputerUtilCard.getBestCreatureAI(attackers));
             }
 
-            return new AiAbilityDecision(sa.isTargetNumberValid() ? 100 : 0, sa.isTargetNumberValid() ? AiPlayDecision.WillPlay : AiPlayDecision.CantPlayAi);
+            return sa.isTargetNumberValid();
         }
 
         // TODO: expand for other cases where the AI is needed to make a decision on a branch
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
-        AiAbilityDecision decision = canPlay(aiPlayer, sa);
-        if (decision.willingToPlay() || mandatory) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+        return canPlayAI(aiPlayer, sa) || mandatory;
     }
 
     @Override

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

@@ -1,8 +1,6 @@
 package forge.ai.ability;
 
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
@@ -12,15 +10,15 @@ public class CannotPlayAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected AiAbilityDecision canPlay(Player aiPlayer, SpellAbility sa) {
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
+        return false;
     }
 
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
      */
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player aiPlayer) {
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
+        return canPlayAI(aiPlayer, sa);
     }
 }

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

@@ -1,7 +1,8 @@
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+import java.util.Collection;
+import java.util.Map;
+
 import forge.ai.SpellAbilityAi;
 import forge.game.GameEntity;
 import forge.game.player.Player;
@@ -9,44 +10,39 @@ import forge.game.player.PlayerCollection;
 import forge.game.player.PlayerPredicates;
 import forge.game.spellability.SpellAbility;
 
-import java.util.Collection;
-import java.util.Map;
-
 public class ChangeCombatantsAi extends SpellAbilityAi {
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected AiAbilityDecision canPlay(Player aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         // TODO: Extend this if possible for cards that have this as an activated ability
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return false;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
-        if (mandatory) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+        return mandatory || canPlayAI(aiPlayer, sa);
     }
 
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
      */
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         final String logic = sa.getParamOrDefault("AILogic", "");
 
         if (logic.equals("WeakestOppExceptCtrl")) {
             PlayerCollection targetableOpps = aiPlayer.getOpponents();
             targetableOpps.remove(sa.getHostCard().getController());
             if (targetableOpps.isEmpty()) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+
+            return true;
         }
 
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return false;
     }
 
     @Override
@@ -67,3 +63,4 @@ public class ChangeCombatantsAi extends SpellAbilityAi {
         return (T)weakestTargetableOpp;
     }
 }
+

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

@@ -1,6 +1,9 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilMana;
+import forge.ai.SpellAbilityAi;
 import forge.card.mana.ManaCost;
 import forge.game.Game;
 import forge.game.card.Card;
@@ -18,7 +21,7 @@ public class ChangeTargetsAi extends SpellAbilityAi {
      * forge.game.spellability.SpellAbility)
      */
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+    protected boolean checkApiLogic(Player ai, SpellAbility sa) {
         final Game game = sa.getHostCard().getGame();
         final SpellAbility topSa = game.getStack().isEmpty() ? null
                 : ComputerUtilAbility.getTopSpellAbilityOnStack(game, sa);
@@ -29,50 +32,47 @@ public class ChangeTargetsAi extends SpellAbilityAi {
 
         // The AI can't otherwise play this ability, but should at least not
         // miss mandatory activations (e.g. triggers).
-        if (sa.isMandatory()) {
-            return new AiAbilityDecision(50, AiPlayDecision.MandatoryPlay);
-        }
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return sa.isMandatory();
     }
 
-    private AiAbilityDecision doSpellMagnet(SpellAbility sa, SpellAbility topSa, Player aiPlayer) {
+    private boolean doSpellMagnet(SpellAbility sa, SpellAbility topSa, Player aiPlayer) {
         // For cards like Spellskite that retarget spells to itself
         if (topSa == null) {
             // nothing on stack, so nothing to target
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
         final TargetChoices topTargets = topSa.getTargets();
         final Card topHost = topSa.getHostCard();
 
-        if (!sa.getTargets().isEmpty() && sa.isTrigger()) {
+        if (sa.getTargets().size() != 0 && sa.isTrigger()) {
             // something was already chosen before (e.g. in response to a trigger - Mizzium Meddler), so just proceed
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
 
         if (!topSa.usesTargeting() || topTargets.getTargetCards().contains(sa.getHostCard())) {
             // if this does not target at all or already targets host, no need to redirect it again
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         for (Card tgt : topTargets.getTargetCards()) {
             if (ComputerUtilAbility.getAbilitySourceName(sa).equals(tgt.getName()) && tgt.getController().equals(aiPlayer)) {
                 // We are already targeting at least one card with the same name (e.g. in presence of 2+ Spellskites),
                 // no need to retarget again to another one
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
         }
 
         if (topHost != null && !topHost.getController().isOpponentOf(aiPlayer)) {
             // make sure not to redirect our own abilities
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
         if (!topSa.canTarget(sa.getHostCard())) {
             // don't try targeting it if we can't legally target the host card with it in the first place
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
         if (!sa.canTarget(topSa)) {
             // don't try retargeting a spell that the current card can't legally retarget (e.g. Muck Drubb + Lightning Bolt to the face)
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         if (sa.getPayCosts().getCostMana() != null && sa.getPayCosts().getCostMana().getMana().hasPhyrexian()) {
@@ -85,22 +85,22 @@ public class ChangeTargetsAi extends SpellAbilityAi {
             if (potentialDmg != -1 && potentialDmg <= payDamage && !canPay
                     && topTargets.contains(aiPlayer)) {
                 // do not pay Phyrexian mana if the spell is a damaging one but it deals less damage or the same damage as we'll pay life
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
         }
 
         Card firstCard = topTargets.getFirstTargetedCard();
         // if we're not the target don't intervene unless we can steal a buff
         if (firstCard != null && !aiPlayer.equals(firstCard.getController()) && !topHost.getController().equals(firstCard.getController()) && !topHost.getController().getAllies().contains(firstCard.getController())) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
         Player firstPlayer = topTargets.getFirstTargetedPlayer();
         if (firstPlayer != null && !aiPlayer.equals(firstPlayer)) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         sa.resetTargets();
         sa.getTargets().add(topSa);
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 }

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

@@ -1,11 +1,28 @@
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
-import forge.ai.*;
+import java.util.Collections;
+import java.util.Map;
+
+import com.google.common.collect.Iterables;
+
+import forge.ai.AiController;
+import forge.ai.AiPlayerPredicates;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+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.cost.Cost;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -16,12 +33,9 @@ import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 
-import java.util.Collections;
-import java.util.Map;
-
 public class ChangeZoneAllAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision canPlay(Player ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // Change Zone All, can be any type moving from one zone to another
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getHostCard();
@@ -34,14 +48,14 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
         if (abCost != null) {
             // AI currently disabled for these costs
             if (!ComputerUtilCost.checkLifeCost(ai, abCost, source, 4, sa)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CostNotAcceptable);
+                return false;
             }
 
             if (!ComputerUtilCost.checkDiscardCost(ai, abCost, source, sa)) {
                 boolean aiLogicAllowsDiscard = aiLogic.startsWith("DiscardAll");
 
                 if (!aiLogicAllowsDiscard) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CostNotAcceptable);
+                    return false;
                 }
             }
         }
@@ -61,29 +75,31 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
 
         // Ugin AI: always try to sweep before considering +1
         if (sourceName.equals("Ugin, the Spirit Dragon")) {
-            boolean result = SpecialCardAi.UginTheSpiritDragon.considerPWAbilityPriority(ai, sa, origin, oppType, computerType);
-            return result ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return SpecialCardAi.UginTheSpiritDragon.considerPWAbilityPriority(ai, sa, origin, oppType, computerType);
         }
 
         oppType = AbilityUtils.filterListByType(oppType, sa.getParam("ChangeType"), sa);
         computerType = AbilityUtils.filterListByType(computerType, sa.getParam("ChangeType"), sa);
         
         if ("LivingDeath".equals(aiLogic)) {
+            // Living Death AI
             return SpecialCardAi.LivingDeath.consider(ai, sa);
         } else if ("Timetwister".equals(aiLogic)) {
+            // Timetwister AI
             return SpecialCardAi.Timetwister.consider(ai, sa);
         } else if ("RetDiscardedThisTurn".equals(aiLogic)) {
-            boolean result = !ai.getDiscardedThisTurn().isEmpty() && ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN);
-            return result ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            // e.g. Shadow of the Grave
+            return ai.getDiscardedThisTurn().size() > 0 && ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN);
         } else if ("ExileGraveyards".equals(aiLogic)) {
             for (Player opp : ai.getOpponents()) {
                 CardCollectionView cardsGY = opp.getCardsIn(ZoneType.Graveyard);
-                CardCollection creats = CardLists.filter(cardsGY, CardPredicates.CREATURES);
+                CardCollection creats = CardLists.filter(cardsGY, CardPredicates.Presets.CREATURES);
+
                 if (opp.hasDelirium() || opp.hasThreshold() || creats.size() >= 5) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         } else if ("ManifestCreatsFromGraveyard".equals(aiLogic)) {
             PlayerCollection players = ai.getOpponents();
             players.add(ai);
@@ -92,54 +108,74 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
                 Player bestTgt = null;
                 if (player.canBeTargetedBy(sa)) {
                     int numGY = CardLists.count(player.getCardsIn(ZoneType.Graveyard),
-                            CardPredicates.CREATURES);
+                            CardPredicates.Presets.CREATURES);
                     if (numGY > maxSize) {
                         maxSize = numGY;
                         bestTgt = player;
                     }
                 }
+
                 if (bestTgt != null) {
                     sa.resetTargets();
                     sa.getTargets().add(bestTgt);
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         // TODO improve restrictions on when the AI would want to use this
         // spBounceAll has some AI we can compare to.
         if (origin.equals(ZoneType.Hand) || origin.equals(ZoneType.Library)) {
             if (!sa.usesTargeting()) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                // TODO: improve logic for non-targeted SAs of this type (most are currently AI:RemoveDeck:All, e.g. Memory Jar)
+                return true;
             } else {
+                // search targetable Opponents
                 final PlayerCollection oppList = ai.getOpponents().filter(PlayerPredicates.isTargetableBy(sa));
+
                 if (oppList.isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+                    return false;
                 }
+
+                // get the one with the most handsize
                 Player oppTarget = oppList.max(PlayerPredicates.compareByZoneSize(origin));
+
+                // set the target
                 if (!oppTarget.getCardsIn(ZoneType.Hand).isEmpty()) {
                     sa.resetTargets();
                     sa.getTargets().add(oppTarget);
                 } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+                    return false;
                 }
             }
         } else if (origin.equals(ZoneType.Battlefield)) {
+            // this statement is assuming the AI is trying to use this spell offensively
+            // if the AI is using it defensively, then something else needs to occur
+            // if only creatures are affected evaluate both lists and pass only
+            // if human creatures are more valuable
             if (sa.usesTargeting()) {
+                // search targetable Opponents
                 final PlayerCollection oppList = ai.getOpponents().filter(PlayerPredicates.isTargetableBy(sa));
+
                 if (oppList.isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+                    return false;
                 }
+
+                // get the one with the most in graveyard
+                // zone is visible so evaluate which would be hurt the most
                 Player oppTarget = oppList.max(PlayerPredicates.compareByZoneSize(origin));
+
+                // set the target
                 if (oppTarget.getCardsIn(ZoneType.Graveyard).isEmpty()) {
                     sa.resetTargets();
                     sa.getTargets().add(oppTarget);
                 } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+                    return false;
                 }
                 computerType = new CardCollection();
             }
+
             int creatureEvalThreshold = 200; // value difference (in evaluateCreatureList units)
             int nonCreatureEvalThreshold = 3; // CMC difference
             if (ai.getController().isAI()) {
@@ -161,80 +197,103 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
                             && game.getPhaseHandler().getPlayerTurn().isOpponentOf(ai)) {
                         // Life is in serious danger, return all creatures from the battlefield to wherever
                         // so they don't deal lethal damage
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
                     }
                 }
                 if ((ComputerUtilCard.evaluateCreatureList(computerType) + creatureEvalThreshold) >= ComputerUtilCard
                         .evaluateCreatureList(oppType)) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
-            } else if ((ComputerUtilCard.evaluatePermanentList(computerType) + nonCreatureEvalThreshold) >= ComputerUtilCard
+            } // mass zone change for non-creatures: evaluate both lists by CMC and pass only if human
+              // permanents are more valuable
+            else if ((ComputerUtilCard.evaluatePermanentList(computerType) + nonCreatureEvalThreshold) >= ComputerUtilCard
                     .evaluatePermanentList(oppType)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
+
+            // Don't cast during main1?
             if (game.getPhaseHandler().is(PhaseType.MAIN1, ai) && !aiLogic.equals("Main1")) {
-                return new AiAbilityDecision(0, AiPlayDecision.TimingRestrictions);
+                return false;
             }
         } else if (origin.equals(ZoneType.Graveyard)) {
             if (sa.usesTargeting()) {
+                // search targetable Opponents
                 final PlayerCollection oppList = ai.getOpponents().filter(PlayerPredicates.isTargetableBy(sa));
+
                 if (oppList.isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+                    return false;
                 }
+
+                // get the one with the most in graveyard
+                // zone is visible so evaluate which would be hurt the most
                 Player oppTarget = Collections.max(oppList, AiPlayerPredicates.compareByZoneValue(sa.getParam("ChangeType"), origin, sa));
+
+                // set the target
                 if (!oppTarget.getCardsIn(ZoneType.Graveyard).isEmpty()) {
                     sa.resetTargets();
                     sa.getTargets().add(oppTarget);
                 } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+                    return false;
                 }
             } else if (destination.equals(ZoneType.Library) && "Card.YouOwn".equals(sa.getParam("ChangeType"))) {
-                boolean result = (ai.getCardsIn(ZoneType.Graveyard).size() > ai.getCardsIn(ZoneType.Library).size())
+                return (ai.getCardsIn(ZoneType.Graveyard).size() > ai.getCardsIn(ZoneType.Library).size())
                         && !ComputerUtil.isPlayingReanimator(ai);
-                return result ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
             }
         } else if (origin.equals(ZoneType.Exile)) {
             if (aiLogic.startsWith("DiscardAllAndRetExiled")) {
                 int numExiledWithSrc = CardLists.filter(ai.getCardsIn(ZoneType.Exile), CardPredicates.isExiledWith(source)).size();
                 int curHandSize = ai.getCardsIn(ZoneType.Hand).size();
+            
+                // minimum card advantage unless the hand will be fully reloaded
                 int minAdv = aiLogic.contains(".minAdv") ? Integer.parseInt(aiLogic.substring(aiLogic.indexOf(".minAdv") + 7)) : 0;
                 boolean noDiscard = aiLogic.contains(".noDiscard");
+
                 if (numExiledWithSrc > curHandSize || (noDiscard && numExiledWithSrc > 0)) {
                     if (ComputerUtil.predictThreatenedObjects(ai, sa, true).contains(source)) {
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        // Try to gain some card advantage if the card will die anyway
+                        // TODO: ideally, should evaluate the hand value and not discard good hands to it
+                        return true;
                     }
                 }
-                boolean result = (curHandSize + minAdv - 1 < numExiledWithSrc) || (!noDiscard && numExiledWithSrc >= ai.getMaxHandSize());
-                return result ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+
+                return (curHandSize + minAdv - 1 < numExiledWithSrc) || (!noDiscard && numExiledWithSrc >= ai.getMaxHandSize());
             }
         } else if (origin.equals(ZoneType.Stack)) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            // TODO
+            return false;
         }
+
         if (destination.equals(ZoneType.Battlefield)) {
             if (sa.hasParam("GainControl")) {
+                // Check if the cards are valuable enough
                 if (CardLists.getNotType(oppType, "Creature").isEmpty() && CardLists.getNotType(computerType, "Creature").isEmpty()) {
                     if ((ComputerUtilCard.evaluateCreatureList(computerType) + ComputerUtilCard
                             .evaluateCreatureList(oppType)) < 400) {
-                        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                        return false;
                     }
-                } else if ((ComputerUtilCard.evaluatePermanentList(computerType) + ComputerUtilCard
+                } // otherwise evaluate both lists by CMC and pass only if human
+                  // permanents are less valuable
+                else if ((ComputerUtilCard.evaluatePermanentList(computerType) + ComputerUtilCard
                         .evaluatePermanentList(oppType)) < 6) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
             } else {
+                // don't activate if human gets more back than AI does
                 if (CardLists.getNotType(oppType, "Creature").isEmpty() && CardLists.getNotType(computerType, "Creature").isEmpty()) {
                     if (ComputerUtilCard.evaluateCreatureList(computerType) <= (ComputerUtilCard
                             .evaluateCreatureList(oppType) + 100)) {
-                        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                        return false;
                     }
-                } else if (ComputerUtilCard.evaluatePermanentList(computerType) <= (ComputerUtilCard
+                } // otherwise evaluate both lists by CMC and pass only if human
+                  // permanents are less valuable
+                else if (ComputerUtilCard.evaluatePermanentList(computerType) <= (ComputerUtilCard
                         .evaluatePermanentList(oppType) + 2)) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
             }
         }
-        boolean result = ((MyRandom.getRandom().nextFloat() < .8) || sa.isTrigger()) && chance;
-        return result ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+
+        return (((MyRandom.getRandom().nextFloat() < .8) || sa.isTrigger()) && chance);
     }
 
     /**
@@ -249,11 +308,11 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
      * @return a boolean.
      */
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         // if putting cards from hand to library and parent is drawing cards
         // make sure this will actually do something:
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     /* (non-Javadoc)
@@ -285,90 +344,127 @@ public class ChangeZoneAllAi extends SpellAbilityAi {
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, final SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, final SpellAbility sa, boolean mandatory) {
+        // Change Zone All, can be any type moving from one zone to another
+
         final ZoneType destination = ZoneType.smartValueOf(sa.getParam("Destination"));
         final ZoneType origin = ZoneType.listValueOf(sa.getParam("Origin")).get(0);
 
         if (ComputerUtilAbility.getAbilitySourceName(sa).equals("Profaner of the Dead")) {
-            boolean result = ai.getOpponents().getCardsIn(origin).anyMatch(CardPredicates.CREATURES);
-            return result ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            // TODO: this is a stub to prevent the AI from crashing the game when, for instance, playing the opponent's
+            // Profaner from exile without paying its mana cost. Otherwise the card is marked AI:RemoveDeck:All and
+            // there is no specific AI to support playing it in a smarter way. Feel free to expand.
+            return Iterables.any(ai.getOpponents().getCardsIn(origin), CardPredicates.Presets.CREATURES);
         }
+
         CardCollectionView humanType = ai.getOpponents().getCardsIn(origin);
         humanType = AbilityUtils.filterListByType(humanType, sa.getParam("ChangeType"), sa);
+
         CardCollectionView computerType = ai.getCardsIn(origin);
         computerType = AbilityUtils.filterListByType(computerType, sa.getParam("ChangeType"), sa);
+
+        // TODO improve restrictions on when the AI would want to use this
+        // spBounceAll has some AI we can compare to.
         if (origin.equals(ZoneType.Hand) || origin.equals(ZoneType.Library)) {
             if (sa.usesTargeting()) {
+                // search targetable Opponents
                 final PlayerCollection oppList = ai.getOpponents().filter(PlayerPredicates.isTargetableBy(sa));
+
                 if (oppList.isEmpty()) {
                     if (mandatory && !sa.isTargetNumberValid() && sa.canTarget(ai)) {
                         sa.resetTargets();
                         sa.getTargets().add(ai);
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
                     }
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+                    return false;
                 }
+
+                // get the one with the most handsize
                 Player oppTarget = oppList.max(PlayerPredicates.compareByZoneSize(origin));
+
+                // set the target
                 if (!oppTarget.getCardsIn(ZoneType.Hand).isEmpty() || mandatory) {
                     sa.resetTargets();
                     sa.getTargets().add(oppTarget);
                 } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+                    return false;
                 }
             }
         } else if (origin.equals(ZoneType.Battlefield)) {
+            // if mandatory, no need to evaluate
             if (mandatory) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
+            // this statement is assuming the AI is trying to use this spell offensively
+            // if the AI is using it defensively, then something else needs to occur
+            // if only creatures are affected evaluate both lists and pass only
+            // if human creatures are more valuable
             if (CardLists.getNotType(humanType, "Creature").isEmpty() && CardLists.getNotType(computerType, "Creature").isEmpty()) {
                 if (ComputerUtilCard.evaluateCreatureList(computerType) >= ComputerUtilCard.evaluateCreatureList(humanType)) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
-            } else if (ComputerUtilCard.evaluatePermanentList(computerType) >= ComputerUtilCard.evaluatePermanentList(humanType)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            } // otherwise evaluate both lists by CMC and pass only if human
+              // permanents are more valuable
+            else if (ComputerUtilCard.evaluatePermanentList(computerType) >= ComputerUtilCard.evaluatePermanentList(humanType)) {
+                return false;
             }
         } else if (origin.equals(ZoneType.Graveyard)) {
             if (sa.usesTargeting()) {
+                // search targetable Opponents
                 final PlayerCollection oppList = ai.getOpponents().filter(PlayerPredicates.isTargetableBy(sa));
+
                 if (oppList.isEmpty()) {
                     if (mandatory && !sa.isTargetNumberValid() && sa.canTarget(ai)) {
                         sa.resetTargets();
                         sa.getTargets().add(ai);
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
                     }
-                    return sa.isTargetNumberValid() ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+                    return sa.isTargetNumberValid();
                 }
+
+                // get the one with the most in graveyard
+                // zone is visible so evaluate which would be hurt the most
                 Player oppTarget = oppList.max(
                         AiPlayerPredicates.compareByZoneValue(sa.getParam("ChangeType"), origin, sa));
+
+                // set the target
                 if (!oppTarget.getCardsIn(ZoneType.Graveyard).isEmpty() || mandatory) {
                     sa.resetTargets();
                     sa.getTargets().add(oppTarget);
                 } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+                    return false;
                 }
             }
+        } else if (origin.equals(ZoneType.Exile)) {
+
+        } else if (origin.equals(ZoneType.Stack)) {
+            // currently only exists indirectly (e.g. Summary Dismissal via PlayAi)
         }
+
         if (destination.equals(ZoneType.Battlefield)) {
+            // if mandatory, no need to evaluate
             if (mandatory) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
             if (sa.hasParam("GainControl")) {
+                // Check if the cards are valuable enough
                 if (CardLists.getNotType(humanType, "Creature").isEmpty() && CardLists.getNotType(computerType, "Creature").isEmpty()) {
-                    boolean result = (ComputerUtilCard.evaluateCreatureList(computerType) + ComputerUtilCard.evaluateCreatureList(humanType)) >= 1;
-                    return result ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
-                boolean result = (ComputerUtilCard.evaluatePermanentList(computerType) + ComputerUtilCard
+                    return (ComputerUtilCard.evaluateCreatureList(computerType) + ComputerUtilCard.evaluateCreatureList(humanType)) >= 1;
+                } // otherwise evaluate both lists by CMC and pass only if human
+                  // permanents are less valuable
+                return (ComputerUtilCard.evaluatePermanentList(computerType) + ComputerUtilCard
                         .evaluatePermanentList(humanType)) >= 1;
-                return result ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
             }
+
+            // don't activate if human gets more back than AI does
             if (CardLists.getNotType(humanType, "Creature").isEmpty() && CardLists.getNotType(computerType, "Creature").isEmpty()) {
-                boolean result = ComputerUtilCard.evaluateCreatureList(computerType) > ComputerUtilCard.evaluateCreatureList(humanType);
-                return result ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
-            boolean result = ComputerUtilCard.evaluatePermanentList(computerType) > ComputerUtilCard.evaluatePermanentList(humanType);
-            return result ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return ComputerUtilCard.evaluateCreatureList(computerType) > ComputerUtilCard.evaluateCreatureList(humanType);
+            } // otherwise evaluate both lists by CMC and pass only if human
+            // permanents are less valuable
+            return ComputerUtilCard.evaluatePermanentList(computerType) > ComputerUtilCard.evaluatePermanentList(humanType);
         }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+
+        return true;
     }
 
 }

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

@@ -1,7 +1,16 @@
 package forge.ai.ability;
 
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.collect.Lists;
-import forge.ai.*;
+
+import forge.ai.AiController;
+import forge.ai.AiPlayDecision;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.effects.CharmEffect;
 import forge.game.card.Card;
@@ -9,15 +18,12 @@ import forge.game.player.Player;
 import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
 import forge.util.Aggregates;
+import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-
 public class CharmAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+    protected boolean checkApiLogic(Player ai, SpellAbility sa) {
         final Card source = sa.getHostCard();
         List<AbilitySub> choices = CharmEffect.makePossibleOptions(sa);
 
@@ -31,14 +37,13 @@ public class CharmAi extends SpellAbilityAi {
         }
 
         boolean timingRight = sa.isTrigger(); //is there a reason to play the charm now?
-        boolean choiceForOpp = !ai.equals(sa.getActivatingPlayer());
 
         // Reset the chosen list otherwise it will be locked in forever by earlier calls
         sa.setChosenList(null);
         sa.setSubAbility(null);
         List<AbilitySub> chosenList;
-
-        if (choiceForOpp) {
+        
+        if (!ai.equals(sa.getActivatingPlayer())) {
             // This branch is for "An Opponent chooses" Charm spells from Alliances
             // Current just choose the first available spell, which seem generally less disastrous for the AI.
             chosenList = choices.subList(1, choices.size());
@@ -69,29 +74,26 @@ public class CharmAi extends SpellAbilityAi {
                 // Set minimum choices for triggers where chooseMultipleOptionsAi() returns null
                 chosenList = chooseOptionsAi(sa, choices, ai, true, num, min);
                 if (chosenList.isEmpty() && min != 0) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
             } else {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
         }
 
         // store the choices so they'll get reused
         sa.setChosenList(chosenList);
-
-        if (choiceForOpp) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-        }
-
         if (sa.isSpell()) {
             // prebuild chain to improve cost calculation accuracy
             CharmEffect.chainAbilities(sa, chosenList);
         }
 
-        return super.checkApiLogic(ai, sa);
+        // prevent run-away activations - first time will always return true
+        return MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
     }
 
-    private List<AbilitySub> chooseOptionsAi(SpellAbility sa, List<AbilitySub> choices, final Player ai, boolean isTrigger, int num, int min) {
+    private List<AbilitySub> chooseOptionsAi(SpellAbility sa, List<AbilitySub> choices, final Player ai, boolean isTrigger, int num,
+            int min) {
         List<AbilitySub> chosenList = Lists.newArrayList();
         AiController aic = ((PlayerControllerAi) ai.getController()).getAi();
         boolean allowRepeat = sa.hasParam("CanRepeatModes"); // FIXME: unused for now, the AI doesn't know how to effectively handle repeated choices
@@ -105,14 +107,15 @@ public class CharmAi extends SpellAbilityAi {
 
         // First pass using standard canPlayAi() for good choices
         for (AbilitySub sub : choices) {
-            sub.setActivatingPlayer(ai);
+            sub.setActivatingPlayer(ai, true);
             if (AiPlayDecision.WillPlay == aic.canPlaySa(sub)) {
                 if (pawprintLimit > 0) {
                     int curPawprintAmount = AbilityUtils.calculateAmount(sub.getHostCard(), sub.getParamOrDefault("Pawprint", "0"), sub);
                     if (pawprintAmount + curPawprintAmount > pawprintLimit) {
                         continue;
+                    } else {
+                        pawprintAmount += curPawprintAmount;
                     }
-                    pawprintAmount += curPawprintAmount;
                 }
                 chosenList.add(sub);
                 if (chosenList.size() == num) {
@@ -243,13 +246,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.setActivatingPlayer(ai, true);
                 if (AiPlayDecision.WillPlay == aic.canPlaySa(sub)) {
                     chosenList.add(sub);
                     if (chosenList.size() == min) {
@@ -274,10 +277,10 @@ public class CharmAi extends SpellAbilityAi {
     }
 
     @Override
-    public AiAbilityDecision chkDrawbackWithSubs(Player aiPlayer, AbilitySub ab) {
+    public boolean chkDrawbackWithSubs(Player aiPlayer, AbilitySub ab) {
         // choices were already targeted
         if (ab.getRootAbility().getChosenList() != null) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
         return super.chkDrawbackWithSubs(aiPlayer, ab);
     }

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

@@ -1,19 +1,21 @@
 package forge.ai.ability;
 
+import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import forge.ai.*;
 import forge.game.Game;
 import forge.game.card.*;
+import forge.game.card.CardPredicates.Presets;
 import forge.game.combat.Combat;
 import forge.game.keyword.Keyword;
+import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerPredicates;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
-import forge.util.IterableUtil;
 
 import java.util.Collections;
 import java.util.List;
@@ -25,19 +27,19 @@ public class ChooseCardAi extends SpellAbilityAi {
      * The rest of the logic not covered by the canPlayAI template is defined here
      */
     @Override
-    protected AiAbilityDecision checkApiLogic(final Player ai, final SpellAbility sa) {
+    protected boolean checkApiLogic(final Player ai, final SpellAbility sa) {
         if (sa.usesTargeting()) {
             sa.resetTargets();
             // search targetable Opponents
             final List<Player> oppList = ai.getOpponents().filter(PlayerPredicates.isTargetableBy(sa));
 
             if (oppList.isEmpty()) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
 
             sa.getTargets().add(Iterables.getFirst(oppList, null));
         }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     /**
@@ -134,12 +136,21 @@ public class ChooseCardAi extends SpellAbilityAi {
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         if (sa.hasParam("AILogic") && !checkAiLogic(ai, sa, sa.getParam("AILogic"))) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
+        }
+        return checkApiLogic(ai, sa);
+    }
+
+    protected boolean checkPhaseRestrictions(Player ai, SpellAbility sa, PhaseHandler ph) {
+        String aiLogic = sa.getParamOrDefault("AILogic", "");
+
+        if (aiLogic.equals("AtOppEOT")) {
+            return ph.getNextTurn().equals(ai) && ph.is(PhaseType.END_OF_TURN);
         }
 
-        return checkApiLogic(ai, sa);
+        return super.checkPhaseRestrictions(ai, sa, ph);
     }
 
     /* (non-Javadoc)
@@ -171,8 +182,8 @@ public class ChooseCardAi extends SpellAbilityAi {
             }
             choice = ComputerUtilCard.getBestAI(ownChoices);
         } else if (logic.equals("BestBlocker")) {
-            if (IterableUtil.any(options, CardPredicates.UNTAPPED)) {
-                options = CardLists.filter(options, CardPredicates.UNTAPPED);
+            if (Iterables.any(options, Presets.UNTAPPED)) {
+                options = CardLists.filter(options, Presets.UNTAPPED);
             }
             choice = ComputerUtilCard.getBestCreatureAI(options);
         } else if (logic.equals("Clone")) {
@@ -209,7 +220,7 @@ public class ChooseCardAi extends SpellAbilityAi {
                 choice = ComputerUtilCard.getWorstAI(aiControlled);
             }
         } else if ("LowestCMCCreature".equals(logic)) {
-            CardCollection creats = CardLists.filter(options, CardPredicates.CREATURES);
+            CardCollection creats = CardLists.filter(options, Presets.CREATURES);
             creats = CardLists.filterToughness(creats, 1);
             if (creats.isEmpty()) {
                 choice = ComputerUtilCard.getWorstAI(options);
@@ -261,10 +272,10 @@ public class ChooseCardAi extends SpellAbilityAi {
                 //  – might also be good to do a separate AI for Noble Heritage
             }
         } else if (logic.equals("Phylactery")) {
-            CardCollection aiArtifacts = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), CardPredicates.ARTIFACTS);
+            CardCollection aiArtifacts = CardLists.filter(ai.getCardsIn(ZoneType.Battlefield), Presets.ARTIFACTS);
             CardCollection indestructibles = CardLists.filter(aiArtifacts, CardPredicates.hasKeyword(Keyword.INDESTRUCTIBLE));
-            CardCollection nonCreatures = CardLists.filter(aiArtifacts, CardPredicates.NON_CREATURES);
-            CardCollection creatures = CardLists.filter(aiArtifacts, CardPredicates.CREATURES);
+            CardCollection nonCreatures = CardLists.filter(aiArtifacts, Predicates.not(Presets.CREATURES));
+            CardCollection creatures = CardLists.filter(aiArtifacts, Presets.CREATURES);
             if (!indestructibles.isEmpty()) {
                 // Choose the worst (smallest) indestructible artifact so that the opponent would have to waste
                 // removal on something unpreferred

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

@@ -1,10 +1,22 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
+
 import forge.StaticData;
-import forge.ai.*;
-import forge.card.*;
+import forge.ai.AiAttackController;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
+import forge.card.CardDb;
+import forge.card.CardRules;
+import forge.card.CardSplitType;
+import forge.card.CardStateName;
+import forge.card.ICardFace;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardCopyService;
@@ -16,26 +28,19 @@ import forge.game.zone.ZoneType;
 import forge.item.PaperCard;
 import forge.util.MyRandom;
 
-import java.util.List;
-import java.util.Map;
-
 public class ChooseCardNameAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision canPlay(Player ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         if (sa.hasParam("AILogic")) {
             // Don't tap creatures that may be able to block
             if (ComputerUtil.waitForBlocking(sa)) {
-                return new AiAbilityDecision(0, AiPlayDecision.WaitForCombat);
+                return false;
             }
 
             String logic = sa.getParam("AILogic");
             if (logic.equals("CursedScroll")) {
-                if (SpecialCardAi.CursedScroll.consider(ai, sa)) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
+                return SpecialCardAi.CursedScroll.consider(ai, sa);
             }
 
             final TargetRestrictions tgt = sa.getTargetRestrictions();
@@ -47,13 +52,13 @@ public class ChooseCardNameAi extends SpellAbilityAi {
                     sa.getTargets().add(ai);
                 }
             }
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return false;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         String aiLogic = sa.getParamOrDefault("AILogic", "");
         if ("PithingNeedle".equals(aiLogic)) {
             // Make sure theres something in play worth Needlings.
@@ -61,27 +66,18 @@ public class ChooseCardNameAi extends SpellAbilityAi {
 
             CardCollection oppPerms = CardLists.getValidCards(ai.getOpponents().getCardsIn(ZoneType.Battlefield), "Card.OppCtrl+hasNonManaActivatedAbility", ai, sa.getHostCard(), sa);
             if (oppPerms.isEmpty()) {
-                return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+                return false;
             }
 
             Card card = ComputerUtilCard.getBestPlaneswalkerAI(oppPerms);
             if (card != null) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
 
             // 5 percent chance to cast per opposing card with a non mana ability
-            if (MyRandom.getRandom().nextFloat() <= .05 * oppPerms.size()) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            } else {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
-        }
-
-        if (mandatory) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        } else {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return MyRandom.getRandom().nextFloat() <= .05 * oppPerms.size();
         }
+        return mandatory;
     }
     /* (non-Javadoc)
      * @see forge.card.ability.SpellAbilityAi#chooseSingleCard(forge.card.spellability.SpellAbility, java.util.List, boolean)

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

@@ -1,6 +1,11 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCost;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.card.MagicColor;
 import forge.game.Game;
 import forge.game.card.CardCollectionView;
@@ -11,45 +16,40 @@ import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
+import forge.util.MyRandom;
 
 public class ChooseColorAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Game game = ai.getGame();
         final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
         final PhaseHandler ph = game.getPhaseHandler();
 
         if (!sa.hasParam("AILogic")) {
-            return new AiAbilityDecision(0, AiPlayDecision.MissingLogic);
+            return false;
         }
         final String logic = sa.getParam("AILogic");
 
+        if (ComputerUtil.preventRunAwayActivations(sa)) {
+            return false;
+        }
+
         if ("Nykthos, Shrine to Nyx".equals(sourceName)) {
-            if (SpecialCardAi.NykthosShrineToNyx.consider(ai, sa)) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            } else {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
+            return SpecialCardAi.NykthosShrineToNyx.consider(ai, sa);
         }
 
         if ("Oona, Queen of the Fae".equals(sourceName)) {
             if (ph.isPlayerTurn(ai) || ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
-                return new AiAbilityDecision(0, AiPlayDecision.AnotherTime);
+                return false;
             }
             // Set PayX here to maximum value.
             sa.setXManaCostPaid(ComputerUtilCost.getMaxXValue(sa, ai, false));
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
 
         if ("Addle".equals(sourceName)) {
-            // TODO Why is this not in the AI logic?
-            // Why are we specifying the weakest opponent?
-            if (!ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS) && !ai.getWeakestOpponent().getCardsIn(ZoneType.Hand).isEmpty()) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            } else {
-                return new AiAbilityDecision(0, AiPlayDecision.AnotherTime);
-            }
+            return !ph.getPhase().isBefore(PhaseType.COMBAT_DECLARE_ATTACKERS) && !ai.getWeakestOpponent().getCardsIn(ZoneType.Hand).isEmpty();
         }
 
         if (logic.equals("MostExcessOpponentControls")) {
@@ -59,39 +59,33 @@ public class ChooseColorAi extends SpellAbilityAi {
 
                 int excess = ComputerUtilCard.evaluatePermanentList(opplist) - ComputerUtilCard.evaluatePermanentList(ailist);
                 if (excess > 4) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         } else if (logic.equals("MostProminentInComputerDeck")) {
             if ("Astral Cornucopia".equals(sourceName)) {
                 // activate in Main 2 hoping that the extra mana surplus will make a difference
                 // if there are some nonland permanents in hand
                 CardCollectionView permanents = CardLists.filter(ai.getCardsIn(ZoneType.Hand), 
-                        CardPredicates.NONLAND_PERMANENTS);
+                        CardPredicates.Presets.NONLAND_PERMANENTS);
 
-                if (!permanents.isEmpty() && ph.is(PhaseType.MAIN2, ai)) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.WaitForMain2);
-                }
+                return permanents.size() > 0 && ph.is(PhaseType.MAIN2, ai);
             }
         } else if (logic.equals("HighestDevotionToColor")) {
             // currently only works more or less reliably in Main2 to cast own spells
             if (!ph.is(PhaseType.MAIN2, ai)) {
-                return new AiAbilityDecision(0, AiPlayDecision.WaitForMain2);
+                return false;
             }
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        return chance;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        if (mandatory) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-        return canPlay(ai, sa);
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
+        return mandatory || canPlayAI(ai, sa);
     }
 
 }

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

@@ -1,15 +1,16 @@
 package forge.ai.ability;
 
-import com.google.common.collect.Lists;
-import forge.ai.SpellAbilityAi;
-import forge.game.card.Card;
-import forge.game.player.Player;
-import forge.game.spellability.SpellAbility;
-
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
+import com.google.common.collect.Lists;
+
+import forge.ai.SpellAbilityAi;
+import forge.game.card.Card;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+
 public class ChooseCompanionAi extends SpellAbilityAi {
 
     /* (non-Javadoc)

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

@@ -1,14 +1,12 @@
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
 import forge.ai.SpellAbilityAi;
 import forge.game.Direction;
 import forge.game.Game;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardLists;
-import forge.game.card.CardPredicates;
+import forge.game.card.CardPredicates.Presets;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
@@ -20,14 +18,14 @@ public class ChooseDirectionAi extends SpellAbilityAi {
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected AiAbilityDecision canPlay(Player ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final String logic = sa.getParam("AILogic");
         final Game game = sa.getActivatingPlayer().getGame();
         if (logic == null) {
-            return new AiAbilityDecision(0, AiPlayDecision.MissingLogic);
+            return false;
         } else {
             if ("Aminatou".equals(logic)) {
-                CardCollection all = CardLists.filter(game.getCardsIn(ZoneType.Battlefield), CardPredicates.NONLAND_PERMANENTS);
+                CardCollection all = CardLists.filter(game.getCardsIn(ZoneType.Battlefield), Presets.NONLAND_PERMANENTS);
                 CardCollection aiPermanent = CardLists.filterControlledBy(all, ai);
                 aiPermanent.remove(sa.getHostCard());
                 int aiValue = Aggregates.sum(aiPermanent, Card::getCMC);
@@ -35,24 +33,19 @@ public class ChooseDirectionAi extends SpellAbilityAi {
                 CardCollection right = CardLists.filterControlledBy(all, game.getNextPlayerAfter(ai, Direction.Right));
                 int leftValue = Aggregates.sum(left, Card::getCMC);
                 int rightValue = Aggregates.sum(right, Card::getCMC);
-                if (aiValue <= leftValue && aiValue <= rightValue) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                }
+                return aiValue <= leftValue && aiValue <= rightValue;
             }
         }
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return true;
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player ai) {
-        return canPlay(ai, sa);
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
+        return canPlayAI(ai, sa);
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        if (mandatory) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-        return canPlay(ai, sa);
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
+        return mandatory || canPlayAI(ai, sa);
     }
 }

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

@@ -1,18 +1,17 @@
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
 import forge.ai.AiAttackController;
-import forge.ai.AiPlayDecision;
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
+import forge.util.MyRandom;
 
 public class ChooseEvenOddAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision checkApiLogic(Player aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         if (!sa.hasParam("AILogic")) {
-            return new AiAbilityDecision(0, AiPlayDecision.MissingLogic);
+            return false;
         }
         if (sa.usesTargeting()) {
             sa.resetTargets();
@@ -20,17 +19,16 @@ public class ChooseEvenOddAi extends SpellAbilityAi {
             if (sa.canTarget(opp)) {
                 sa.getTargets().add(opp);
             } else {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
         }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        return chance;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        if (mandatory) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-        return canPlay(ai, sa);
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
+        return mandatory || canPlayAI(ai, sa);
     }
+
 }

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

@@ -1,12 +1,13 @@
 package forge.ai.ability;
 
+import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import forge.ai.*;
 import forge.card.MagicColor;
 import forge.game.Game;
-import forge.game.card.Card;
-import forge.game.card.CardCollectionView;
+import forge.game.card.*;
 import forge.game.cost.Cost;
+import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.AbilitySub;
@@ -17,7 +18,7 @@ import forge.util.collect.FCollection;
 
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
+
 
 public class ChooseGenericAi extends SpellAbilityAi {
 
@@ -27,10 +28,13 @@ public class ChooseGenericAi extends SpellAbilityAi {
             return true;
         } else if ("Pump".equals(aiLogic) || "BestOption".equals(aiLogic)) {
             for (AbilitySub sb : sa.getAdditionalAbilityList("Choices")) {
-                if (SpellApiToAi.Converter.get(sb).canPlayWithSubs(ai, sb).willingToPlay()) {
+                if (SpellApiToAi.Converter.get(sb.getApi()).canPlayAIWithSubs(ai, sb)) {
                     return true;
                 }
             }
+        } else if ("AtOppEOT".equals(aiLogic)) {
+            PhaseHandler ph = ai.getGame().getPhaseHandler();
+            return ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn() == ai;
         } else if ("Always".equals(aiLogic)) {
             return true;
         }
@@ -38,50 +42,40 @@ public class ChooseGenericAi extends SpellAbilityAi {
     }
 
     @Override
-    protected AiAbilityDecision checkApiLogic(final Player ai, final SpellAbility sa) {
-        if (sa.hasParam("AILogic")) {
-            // This is equivilant to what was here before but feels bad
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+    protected boolean checkApiLogic(final Player ai, final SpellAbility sa) {
+        return sa.hasParam("AILogic");
     }
 
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
      */
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player aiPlayer) {
-        AiAbilityDecision decision;
-        if (sa.isTrigger()) {
-            decision = doTriggerNoCost(aiPlayer, sa, sa.isMandatory());
-        } else {
-            decision = checkApiLogic(aiPlayer, sa);
-        }
-
-        return decision;
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
+        return sa.isTrigger() ? doTriggerAINoCost(aiPlayer, sa, sa.isMandatory()) : checkApiLogic(aiPlayer, sa);
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
+    protected boolean doTriggerAINoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
         if ("CombustibleGearhulk".equals(sa.getParam("AILogic")) || "SoulEcho".equals(sa.getParam("AILogic"))) {
             for (final Player p : aiPlayer.getOpponents()) {
                 if (p.canBeTargetedBy(sa)) {
                     sa.resetTargets();
                     sa.getTargets().add(p);
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay); // perhaps the opponent(s) had Sigarda, Heron's Grace or another effect giving hexproof in play, still play the creature as 6/6
+            return true; // perhaps the opponent(s) had Sigarda, Heron's Grace or another effect giving hexproof in play, still play the creature as 6/6
         }
         if (ComputerUtilAbility.getAbilitySourceName(sa).equals("Deathmist Raptor")) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
-        return super.doTriggerNoCost(aiPlayer, sa, mandatory);
+
+        return super.doTriggerAINoCost(aiPlayer, sa, mandatory);
     }
 
     @Override
-    public SpellAbility chooseSingleSpellAbility(Player player, SpellAbility sa, List<SpellAbility> spells, Map<String, Object> params) {
+    public SpellAbility chooseSingleSpellAbility(Player player, SpellAbility sa, List<SpellAbility> spells,
+            Map<String, Object> params) {
         Card host = sa.getHostCard();
         final Game game = host.getGame();
         final String logic = sa.getParam("AILogic");
@@ -90,17 +84,17 @@ public class ChooseGenericAi extends SpellAbilityAi {
         } else if ("Random".equals(logic)) {
             return Aggregates.random(spells);
         } else if ("Phasing".equals(logic)) { // Teferi's Realm : keep aggressive
-            List<SpellAbility> filtered = spells.stream()
-                    .filter(sp -> !sp.getDescription().contains("Creature") && !sp.getDescription().contains("Land"))
-                    .collect(Collectors.toList());
+            List<SpellAbility> filtered = Lists.newArrayList(Iterables.filter(spells, sp -> !sp.getDescription().contains("Creature") && !sp.getDescription().contains("Land")));
             return Aggregates.random(filtered);
         } 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);
-                if (SpellApiToAi.Converter.get(sp).willPayUnlessCost(sp, player, unless, false, new FCollection<>(player))
-                        && ComputerUtilCost.canPayCost(unless, sp, player, true)) {
+                SpellAbility paycost = new SpellAbility.EmptySa(sa.getHostCard(), player);
+                paycost.setPayCosts(unless);
+                if (ComputerUtilCost.willPayUnlessCost(sp, player, unless, false, new FCollection<>(player))
+                        && ComputerUtilCost.canPayCost(paycost, player, true)) {
                     return sp;
                 }
             }
@@ -167,10 +161,10 @@ public class ChooseGenericAi extends SpellAbilityAi {
                 }
             }
             // FatespinnerSkipDraw,FatespinnerSkipMain,FatespinnerSkipCombat
-            if (game.getReplacementHandler().wouldPhaseBeSkipped(player, PhaseType.DRAW)) {
+            if (game.getReplacementHandler().wouldPhaseBeSkipped(player, "Draw")) {
                 return skipDraw;
             }
-            if (game.getReplacementHandler().wouldPhaseBeSkipped(player, PhaseType.COMBAT_BEGIN)) {
+            if (game.getReplacementHandler().wouldPhaseBeSkipped(player, "BeginCombat")) {
                 return skipCombat;
             }
 
@@ -268,7 +262,7 @@ public class ChooseGenericAi extends SpellAbilityAi {
             List<SpellAbility> filtered = Lists.newArrayList();
             // filter first for the spells which can be done
             for (SpellAbility sp : spells) {
-                if (SpellApiToAi.Converter.get(sp).canPlayWithSubs(player, sp).willingToPlay()) {
+                if (SpellApiToAi.Converter.get(sp.getApi()).canPlayAIWithSubs(player, sp)) {
                     filtered.add(sp);
                 }
             }

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

@@ -1,18 +1,21 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import forge.ai.AiAttackController;
+import forge.ai.ComputerUtilCard;
+import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
+import forge.util.MyRandom;
 
 public class ChooseNumberAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision checkApiLogic(Player aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         String aiLogic = sa.getParamOrDefault("AILogic", "");
 
         if (aiLogic.isEmpty()) {
-            return new AiAbilityDecision(0, AiPlayDecision.MissingLogic);
+            return false;
         } else if (aiLogic.equals("SweepCreatures")) {
             int maxChoiceLimit = AbilityUtils.calculateAmount(sa.getHostCard(), sa.getParam("Max"), sa);
             int ownCreatureCount = aiPlayer.getCreaturesInPlay().size();
@@ -27,24 +30,17 @@ public class ChooseNumberAi extends SpellAbilityAi {
             }
 
             if (refOpp == null) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false; // no opponent has any creatures
             }
 
             int evalAI = ComputerUtilCard.evaluateCreatureList(aiPlayer.getCreaturesInPlay());
             int evalOpp = ComputerUtilCard.evaluateCreatureList(refOpp.getCreaturesInPlay());
 
             if (aiPlayer.getLifeLostLastTurn() + aiPlayer.getLifeLostThisTurn() == 0 && evalAI > evalOpp) {
-                // we're not pressured and our stuff seems better, don't do it yet
-                return new AiAbilityDecision(0, AiPlayDecision.AnotherTime);
+                return false; // we're not pressured and our stuff seems better, don't do it yet
             }
 
-            if (ownCreatureCount > oppMaxCreatureCount + 2 || ownCreatureCount < Math.min(oppMaxCreatureCount, maxChoiceLimit)) {
-                // we have more creatures than the opponent, or we have less than the opponent but more than the max choice limit
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            } else {
-                // we have less creatures than the opponent and less than the max choice limit
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
+            return ownCreatureCount > oppMaxCreatureCount + 2 || ownCreatureCount < Math.min(oppMaxCreatureCount, maxChoiceLimit);
         }
 
         if (sa.usesTargeting()) {
@@ -53,17 +49,16 @@ public class ChooseNumberAi extends SpellAbilityAi {
             if (sa.canTarget(opp)) {
                 sa.getTargets().add(opp);
             } else {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
         }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+        return chance;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        if (mandatory) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-        return canPlay(ai, sa);
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
+        return mandatory || canPlayAI(ai, sa);
     }
+
 }

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

@@ -1,9 +1,11 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+
 import forge.ai.ComputerUtil;
 import forge.ai.SpellAbilityAi;
 import forge.game.player.Player;
@@ -12,23 +14,20 @@ import forge.game.player.PlayerPredicates;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.List;
-import java.util.Map;
-
 public class ChoosePlayerAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision canPlay(Player ai, SpellAbility sa) {
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
+        return true;
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player ai) {
-        return canPlay(ai, sa);
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
+        return canPlayAI(ai, sa);
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
-        return canPlay(ai, sa);
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
+        return canPlayAI(ai, sa);
     }
 
     @Override

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

@@ -1,7 +1,15 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
-import forge.ai.*;
+
+import forge.ai.AiAttackController;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.GameObject;
 import forge.game.ability.AbilityUtils;
@@ -11,6 +19,7 @@ import forge.game.card.CardCollectionView;
 import forge.game.card.CardLists;
 import forge.game.card.CardPredicates;
 import forge.game.combat.Combat;
+import forge.game.cost.Cost;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
@@ -18,23 +27,27 @@ import forge.game.spellability.SpellAbilityStackInstance;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 
-import java.util.List;
-import java.util.Map;
-import java.util.function.Predicate;
-
 public class ChooseSourceAi extends SpellAbilityAi {
 
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
      */
     @Override
-    protected AiAbilityDecision checkApiLogic(final Player ai, SpellAbility sa) {
+    protected boolean canPlayAI(final Player ai, SpellAbility sa) {
         // TODO: AI Support! Currently this is copied from AF ChooseCard.
         //       When implementing AI, I believe AI also needs to be made aware of the damage sources chosen
         //       to be prevented (e.g. so the AI doesn't attack with a creature that will not deal any damage
         //       to the player because a CoP was pre-activated on it - unless, of course, there's another
         //       possible reason to attack with that creature).
         final Card host = sa.getHostCard();
+        final Cost abCost = sa.getPayCosts();
+        final Card source = sa.getHostCard();
+
+        if (abCost != null) {
+            if (!willPayCosts(ai, sa, abCost, source)) {
+                return false;
+            }
+        }
 
         if (sa.usesTargeting()) {
             sa.resetTargets();
@@ -42,7 +55,7 @@ public class ChooseSourceAi extends SpellAbilityAi {
             if (sa.canTarget(opp)) {
                 sa.getTargets().add(opp);
             } else {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
         }
         if (sa.hasParam("AILogic")) {
@@ -51,11 +64,11 @@ public class ChooseSourceAi extends SpellAbilityAi {
                 if (!game.getStack().isEmpty()) {
                     final SpellAbility topStack = game.getStack().peekAbility();
                     if (sa.hasParam("Choices") && !topStack.matchesValid(topStack.getHostCard(), sa.getParam("Choices").split(","))) {
-                        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                        return false;
                     }
                     final ApiType threatApi = topStack.getApi();
                     if (threatApi != ApiType.DealDamage && threatApi != ApiType.DamageAll) {
-                        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                        return false;
                     }
 
                     final Card threatSource = topStack.getHostCard();
@@ -67,17 +80,13 @@ public class ChooseSourceAi extends SpellAbilityAi {
                     }
 
                     if (!objects.contains(ai) || topStack.hasParam("NoPrevention")) {
-                        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                        return false;
                     }
                     int dmg = AbilityUtils.calculateAmount(threatSource, topStack.getParam("NumDmg"), topStack);
-                    if (ComputerUtilCombat.predictDamageTo(ai, dmg, threatSource, false) > 0) {
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                    } else {
-                        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                    }
+                    return ComputerUtilCombat.predictDamageTo(ai, dmg, threatSource, false) > 0;
                 }
                 if (game.getPhaseHandler().getPhase() != PhaseType.COMBAT_DECLARE_BLOCKERS) {
-                    return new AiAbilityDecision(0, AiPlayDecision.AnotherTime);
+                    return false;
                 }
                 CardCollectionView choices = game.getCardsIn(ZoneType.Battlefield);
                 if (sa.hasParam("Choices")) {
@@ -90,13 +99,11 @@ public class ChooseSourceAi extends SpellAbilityAi {
                     }
                     return ComputerUtilCombat.damageIfUnblocked(c, ai, combat, true) > 0;
                 });
-                if (choices.isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
+                return !choices.isEmpty();
             }
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     @Override
@@ -128,14 +135,10 @@ public class ChooseSourceAi extends SpellAbilityAi {
             }
             // No optimal creature was found above, so try to broaden the choice.
             if (!Iterables.isEmpty(options)) {
-                List<Card> oppCreatures = CardLists.filter(options, Predicate.not(
-                        CardPredicates.CREATURES.and(CardPredicates.isOwner(aiChoser))
-                ));
-                List<Card> aiNonCreatures = CardLists.filter(options,
-                        CardPredicates.NON_CREATURES
-                                .and(CardPredicates.PERMANENTS)
-                                .and(CardPredicates.isOwner(aiChoser))
-                );
+                List<Card> oppCreatures = CardLists.filter(options, Predicates.and(CardPredicates.Presets.CREATURES,
+                        Predicates.not(CardPredicates.isOwner(aiChoser))));
+                List<Card> aiNonCreatures = CardLists.filter(options, Predicates.and(Predicates.not(CardPredicates.Presets.CREATURES),
+                        CardPredicates.Presets.PERMANENTS, CardPredicates.isOwner(aiChoser)));
 
                 if (!oppCreatures.isEmpty()) {
                     return ComputerUtilCard.getBestCreatureAI(oppCreatures);

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

@@ -1,11 +1,24 @@
 package forge.ai.ability;
 
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
 import com.google.common.collect.Iterables;
-import forge.ai.*;
+import forge.ai.AiCardMemory;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilMana;
+import forge.ai.SpellAbilityAi;
 import forge.card.CardType;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.card.*;
+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.keyword.Keyword;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -14,44 +27,25 @@ import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
 public class ChooseTypeAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision canPlay(Player aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         String aiLogic = sa.getParamOrDefault("AILogic", "");
 
         if (aiLogic.isEmpty()) {
-            return new AiAbilityDecision(0, AiPlayDecision.MissingLogic);
+            return false;
         } else if ("MostProminentComputerControls".equals(aiLogic)) {
             if (ComputerUtilAbility.getAbilitySourceName(sa).equals("Mirror Entity Avatar")) {
-                if (doMirrorEntityLogic(aiPlayer, sa)) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
-            }
-
-
-            if (!chooseType(sa, aiPlayer.getCardsIn(ZoneType.Battlefield)).isEmpty()) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            } else {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return doMirrorEntityLogic(aiPlayer, sa);
             }
+            return !chooseType(sa, aiPlayer.getCardsIn(ZoneType.Battlefield)).isEmpty();
         } else if ("MostProminentComputerControlsOrOwns".equals(aiLogic)) {
-            return !chooseType(sa, aiPlayer.getCardsIn(Arrays.asList(ZoneType.Hand, ZoneType.Battlefield))).isEmpty()
-                    ? new AiAbilityDecision(100, AiPlayDecision.WillPlay)
-                    : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return !chooseType(sa, aiPlayer.getCardsIn(Arrays.asList(ZoneType.Hand, ZoneType.Battlefield))).isEmpty();
         } else if ("MostProminentOppControls".equals(aiLogic)) {
-            return !chooseType(sa, aiPlayer.getOpponents().getCardsIn(ZoneType.Battlefield)).isEmpty()
-                    ? new AiAbilityDecision(100, AiPlayDecision.WillPlay)
-                    : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return !chooseType(sa, aiPlayer.getOpponents().getCardsIn(ZoneType.Battlefield)).isEmpty();
         }
 
-        return doTriggerNoCost(aiPlayer, sa, false);
+        return doTriggerAINoCost(aiPlayer, sa, false);
     }
 
     private boolean doMirrorEntityLogic(Player aiPlayer, SpellAbility sa) {
@@ -71,7 +65,7 @@ public class ChooseTypeAi extends SpellAbilityAi {
         int avgPower = 0;
         
         // predict the opposition
-        CardCollection oppCreatures = CardLists.filter(aiPlayer.getOpponents().getCreaturesInPlay(), CardPredicates.UNTAPPED);
+        CardCollection oppCreatures = CardLists.filter(aiPlayer.getOpponents().getCreaturesInPlay(), CardPredicates.Presets.UNTAPPED);
         int maxOppPower = 0;
         int maxOppToughness = 0;
         int oppUsefulCreatures = 0;
@@ -91,7 +85,7 @@ public class ChooseTypeAi extends SpellAbilityAi {
 
         if (maxX > 1) {
             CardCollection cre = CardLists.filter(aiPlayer.getCardsIn(ZoneType.Battlefield),
-                    CardPredicates.isType(chosenType), CardPredicates.UNTAPPED);
+                    CardPredicates.isType(chosenType), CardPredicates.Presets.UNTAPPED);
             if (!cre.isEmpty()) {
                 for (Card c: cre) {
                     avgPower += c.getNetPower();
@@ -115,7 +109,7 @@ public class ChooseTypeAi extends SpellAbilityAi {
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         boolean isCurse = sa.isCurse();
 
         if (sa.usesTargeting()) {
@@ -147,16 +141,16 @@ public class ChooseTypeAi extends SpellAbilityAi {
             }
 
             if (!sa.isTargetNumberValid()) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false; // nothing to target?
             }
         } else {
             for (final Player p : AbilityUtils.getDefinedPlayers(sa.getHostCard(), sa.getParam("Defined"), sa)) {
                 if (p.isOpponentOf(ai) && !mandatory && !isCurse) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
             }
         }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     private String chooseType(SpellAbility sa, CardCollectionView cards) {

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

@@ -1,9 +1,10 @@
 package forge.ai.ability;
 
 
+import java.util.Map;
+
 import com.google.common.collect.Iterables;
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
@@ -16,23 +17,20 @@ import forge.game.player.PlayerPredicates;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.Map;
-
 public class ClashAi extends SpellAbilityAi {
 
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#doTriggerAINoCost(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility, boolean)
      */
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         boolean legalAction = true;
 
         if (sa.usesTargeting()) {
             legalAction = selectTarget(aiPlayer, sa);
         }
 
-        return legalAction ? new AiAbilityDecision(100, AiPlayDecision.WillPlay)
-                : new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+        return legalAction;
     }
 
     /*
@@ -42,17 +40,14 @@ public class ClashAi extends SpellAbilityAi {
      * forge.game.spellability.SpellAbility)
      */
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+    protected boolean checkApiLogic(Player ai, SpellAbility sa) {
         boolean legalAction = true;
 
         if (sa.usesTargeting()) {
             legalAction = selectTarget(ai, sa);
-            if (!legalAction) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
-            }
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return legalAction;
     }
 
     /*
@@ -98,7 +93,7 @@ public class ClashAi extends SpellAbilityAi {
             // Springjack Knight
             // TODO: Whirlpool Whelm also uses creature targeting but it's trickier to support
             CardCollectionView aiCreats = ai.getCreaturesInPlay();
-            CardCollectionView oppCreats = CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Battlefield), CardPredicates.CREATURES);
+            CardCollectionView oppCreats = CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.CREATURES);
 
             Card tgt = aiCreats.isEmpty() ? ComputerUtilCard.getWorstCreatureAI(oppCreats) : ComputerUtilCard.getBestCreatureAI(aiCreats);
 
@@ -110,6 +105,7 @@ public class ClashAi extends SpellAbilityAi {
             }
         }
 
-        return !sa.getTargets().isEmpty();
+        return sa.getTargets().size() > 0;
     }
+
 }

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

@@ -1,39 +0,0 @@
-package forge.ai.ability;
-
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
-import forge.ai.SpellAbilityAi;
-import forge.ai.SpellApiToAi;
-import forge.game.ability.AbilityUtils;
-import forge.game.card.Card;
-import forge.game.player.Player;
-import forge.game.spellability.SpellAbility;
-import forge.game.staticability.StaticAbility;
-import forge.game.trigger.Trigger;
-import forge.game.trigger.TriggerType;
-
-public class ClassLevelUpAi extends SpellAbilityAi {
-    @Override
-    protected AiAbilityDecision canPlay(Player aiPlayer, SpellAbility sa) {
-        // TODO does leveling up affect combat? Otherwise wait for Main2
-        Card host = sa.getHostCard();
-        final int level = host.getClassLevel() + 1;
-        for (StaticAbility stAb : host.getStaticAbilities()) {
-            if (!stAb.hasParam("AddTrigger") || !stAb.isClassLevelNAbility(level)) {
-                continue;
-            }
-            for (String sTrig : stAb.getParam("AddTrigger").split(" & ")) {
-                Trigger t = host.getTriggerForStaticAbility(AbilityUtils.getSVar(stAb, sTrig), stAb);
-                if (t.getMode() != TriggerType.ClassLevelGained) {
-                    continue;
-                }
-                SpellAbility effect = t.ensureAbility();
-                if (!SpellApiToAi.Converter.get(effect).doTrigger(aiPlayer, effect, false)) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
-            }
-        }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-    }
-
-}

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

@@ -14,7 +14,7 @@ public class CloakAi extends ManifestBaseAi {
         // (e.g. Grafdigger's Cage)
         Card topCopy = CardCopyService.getLKICopy(card);
         topCopy.turnFaceDownNoUpdate();
-        topCopy.setCloaked(sa);
+        topCopy.setCloaked(true);
 
         if (ComputerUtil.isETBprevented(topCopy)) {
             return false;

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

@@ -1,12 +1,19 @@
 package forge.ai.ability;
 
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.base.Predicates;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+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.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -14,13 +21,10 @@ import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.List;
-import java.util.Map;
-
 public class CloneAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         final Card source = sa.getHostCard();
         final Game game = source.getGame();
 
@@ -38,6 +42,10 @@ public class CloneAi extends SpellAbilityAi {
         // TODO - add some kind of check for during human turn to answer
         // "Can I use this to block something?"
 
+        if (!checkPhaseRestrictions(ai, sa, game.getPhaseHandler())) {
+            return false;
+        }
+
         PhaseHandler phase = game.getPhaseHandler();
 
         if (!sa.usesTargeting()) {
@@ -64,19 +72,18 @@ public class CloneAi extends SpellAbilityAi {
             }
 
             if (!bFlag) { // All of the defined stuff is cloned, not very useful
-                return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+                return false;
             }
         } else {
             sa.resetTargets();
             useAbility &= cloneTgtAI(sa);
         }
 
-        return useAbility ? new AiAbilityDecision(100, AiPlayDecision.WillPlay)
-                : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-    }
+        return useAbility;
+    } // end cloneCanPlayAI()
 
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         // AI should only activate this during Human's turn
         boolean chance = true;
 
@@ -84,22 +91,17 @@ public class CloneAi extends SpellAbilityAi {
             chance = cloneTgtAI(sa);
         }
 
-        return chance ? new AiAbilityDecision(100, AiPlayDecision.WillPlay)
-                : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return chance;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         Card host = sa.getHostCard();
         boolean chance = true;
 
         if (sa.usesTargeting()) {
             chance = cloneTgtAI(sa);
         } else {
-            if (sa.isReplacementAbility() && host.isCloned()) {
-                // prevent StackOverflow from infinite loop copying another ETB RE
-                return new AiAbilityDecision(0, AiPlayDecision.StopRunawayActivations);
-            }
             if (sa.hasParam("Choices")) {
                 CardCollectionView choices = CardLists.getValidCards(host.getGame().getCardsIn(ZoneType.Battlefield),
                         sa.getParam("Choices"), host.getController(), host, sa);
@@ -115,11 +117,7 @@ public class CloneAi extends SpellAbilityAi {
         // Eventually, we can call the trigger of ETB abilities with
         // not mandatory as part of the checks to cast something
 
-        if (mandatory || chance) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return chance || mandatory;
     }
 
     /**
@@ -192,7 +190,7 @@ public class CloneAi extends SpellAbilityAi {
         final boolean canCloneLegendary = "True".equalsIgnoreCase(sa.getParam("NonLegendary"));
 
         String filter = !isVesuva ? "Permanent.YouDontCtrl,Permanent.nonLegendary"
-                : "Permanent.YouDontCtrl+!named" + name + ",Permanent.nonLegendary+!named" + name;
+                : "Permanent.YouDontCtrl+notnamed" + name + ",Permanent.nonLegendary+notnamed" + name;
 
         // TODO: rewrite this block so that this is done somehow more elegantly
         if (canCloneLegendary) {
@@ -213,7 +211,7 @@ public class CloneAi extends SpellAbilityAi {
 
         // prevent loop of choosing copy of same card
         if (isVesuva) {
-            options = CardLists.filter(options, CardPredicates.sharesNameWith(host).negate());
+            options = CardLists.filter(options, Predicates.not(CardPredicates.sharesNameWith(host)));
         }
 
         Card choice = isOpp ? ComputerUtilCard.getWorstAI(options) : ComputerUtilCard.getBestAI(options);

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

@@ -1,7 +1,9 @@
 package forge.ai.ability;
 
-import forge.ai.*;
-import forge.game.ability.AbilityUtils;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilMana;
+import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardLists;
@@ -11,16 +13,9 @@ import forge.game.zone.ZoneType;
 
 public class ConniveAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision canPlay(Player ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         if (!ai.canDraw()) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-        }
-
-        Card host = sa.getHostCard();
-
-        final int num = AbilityUtils.calculateAmount(host, sa.getParamOrDefault("ConniveNum", "1"), sa);
-        if (num == 0) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false; // can't draw anything
         }
 
         CardCollection list = CardLists.getTargetableCards(ai.getCardsIn(ZoneType.Battlefield), sa);
@@ -38,7 +33,7 @@ public class ConniveAi extends SpellAbilityAi {
         sa.resetTargets();
         while (sa.canAddMoreTarget()) {
             if ((list.isEmpty() && sa.isTargetNumberValid() && !sa.getTargets().isEmpty())) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
 
             if (list.isEmpty()) {
@@ -50,7 +45,7 @@ public class ConniveAi extends SpellAbilityAi {
             if (list.isEmpty()) {
                 // Not mandatory, or the the list was regenerated and is still empty,
                 // so return whether or not we found enough targets
-                return new AiAbilityDecision(sa.isTargetNumberValid() ? 100 : 0, sa.isTargetNumberValid() ? AiPlayDecision.WillPlay : AiPlayDecision.CantPlayAi);
+                return sa.isTargetNumberValid();
             }
 
             Card choice = ComputerUtilCard.getBestCreatureAI(list);
@@ -63,17 +58,13 @@ public class ConniveAi extends SpellAbilityAi {
                 list.clear();
             }
         }
-        if (!sa.getTargets().isEmpty() && sa.isTargetNumberValid()) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        } else {
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
-        }
+        return !sa.getTargets().isEmpty() && sa.isTargetNumberValid();
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         if (!ai.canDraw() && !mandatory) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false; // can't draw anything
         }
 
         boolean preferred = true;
@@ -86,7 +77,7 @@ public class ConniveAi extends SpellAbilityAi {
         while (sa.canAddMoreTarget()) {
             if (mandatory) {
                 if ((list.isEmpty() || !preferred) && sa.isTargetNumberValid()) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
 
                 if (list.isEmpty() && preferred) {
@@ -99,13 +90,14 @@ public class ConniveAi extends SpellAbilityAi {
                     // Still an empty list, but we have to choose something (mandatory); expand targeting to
                     // include AI's own cards to see if there's anything targetable (e.g. Plague Belcher).
                     list = CardLists.getTargetableCards(ai.getCardsIn(ZoneType.Battlefield), sa);
+                    preferred = false;
                 }
             }
 
             if (list.isEmpty()) {
                 // Not mandatory, or the the list was regenerated and is still empty,
                 // so return whether or not we found enough targets
-                return new AiAbilityDecision(sa.isTargetNumberValid() ? 100 : 0, sa.isTargetNumberValid() ? AiPlayDecision.WillPlay : AiPlayDecision.CantPlayAi);
+                return sa.isTargetNumberValid();
             }
 
             Card choice = ComputerUtilCard.getBestCreatureAI(list);
@@ -118,10 +110,7 @@ public class ConniveAi extends SpellAbilityAi {
                 list.clear();
             }
         }
-        return new AiAbilityDecision(
-                sa.isTargetNumberValid() ? 100 : 0,
-                sa.isTargetNumberValid() ? AiPlayDecision.WillPlay : AiPlayDecision.TargetingFailed
-        );
+        return true;
     }
 
 }

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

@@ -1,7 +1,10 @@
 package forge.ai.ability;
 
 import com.google.common.collect.Lists;
-import forge.ai.*;
+
+import forge.ai.ComputerUtilCard;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
@@ -11,6 +14,7 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
+import forge.util.MyRandom;
 
 public class ControlExchangeAi extends SpellAbilityAi {
 
@@ -18,7 +22,7 @@ public class ControlExchangeAi extends SpellAbilityAi {
  * @see forge.card.abilityfactory.SpellAiLogic#canPlayAI(forge.game.player.Player, java.util.Map, forge.card.spellability.SpellAbility)
  */
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, final SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, final SpellAbility sa) {
         Card object1 = null;
         Card object2 = null;
         final TargetRestrictions tgt = sa.getTargetRestrictions();
@@ -38,38 +42,35 @@ public class ControlExchangeAi extends SpellAbilityAi {
             sa.getTargets().add(object2);
         }
         if (object1 == null || object2 == null) {
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
         }
         if (ComputerUtilCard.evaluateCreature(object1) > ComputerUtilCard.evaluateCreature(object2) + 40) {
             sa.getTargets().add(object1);
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
         }
-        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+        return false;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         if (!sa.usesTargeting()) {
             if (mandatory) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
-        } else if (mandatory) {
-            AiAbilityDecision decision = chkDrawback(sa, aiPlayer);
-            if (sa.isTargetNumberValid()) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            }
-
-            return decision;
         } else {
-            return canPlay(aiPlayer, sa);
+            if (mandatory) {
+                return chkAIDrawback(sa, aiPlayer) || sa.isTargetNumberValid();
+            } else {
+                return canPlayAI(aiPlayer, sa);
+            }
         }
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player aiPlayer) {
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
         if (!sa.usesTargeting()) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
 
         final TargetRestrictions tgt = sa.getTargetRestrictions();
@@ -90,7 +91,7 @@ public class ControlExchangeAi extends SpellAbilityAi {
         list = CardLists.getTargetableCards(list, sa);
 
         if (list.isEmpty())
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
 
         Card best = ComputerUtilCard.getBestAI(list);
 
@@ -106,7 +107,7 @@ public class ControlExchangeAi extends SpellAbilityAi {
 
             // Defined card is better than this one, try to avoid trade
             if (!best.equals(realBest)) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
         }
 
@@ -115,10 +116,10 @@ public class ControlExchangeAi extends SpellAbilityAi {
             return doTrigTwoTargetsLogic(aiPlayer, sa, best);
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }   
 
-    private AiAbilityDecision doTrigTwoTargetsLogic(Player ai, SpellAbility sa, Card bestFirstTgt) {
+    private boolean doTrigTwoTargetsLogic(Player ai, SpellAbility sa, Card bestFirstTgt) {
         final TargetRestrictions tgt = sa.getTargetRestrictions();
         final int creatureThreshold = 100; // TODO: make this configurable from the AI profile
         final int nonCreatureThreshold = 2;
@@ -130,30 +131,30 @@ public class ControlExchangeAi extends SpellAbilityAi {
         list = CardLists.getTargetableCards(list, sa);
 
         if (list.isEmpty()) {
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
         }
 
         Card aiWorst = ComputerUtilCard.getWorstAI(list);
         if (aiWorst == null) {
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
         }
 
         if (aiWorst != bestFirstTgt) {
             if (bestFirstTgt.isCreature() && aiWorst.isCreature()) {
                 if ((ComputerUtilCard.evaluateCreature(bestFirstTgt) > ComputerUtilCard.evaluateCreature(aiWorst) + creatureThreshold) || sa.isMandatory()) {
                     sa.getTargets().add(aiWorst);
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             } else {
                 // TODO: compare non-creatures by CMC - can be improved, at least shouldn't give control of things like the Power Nine
                 if ((bestFirstTgt.getCMC() > aiWorst.getCMC() + nonCreatureThreshold) || sa.isMandatory()) {
                     sa.getTargets().add(aiWorst);
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
         }
 
         sa.clearTargets();
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return false;
     }
 }

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

@@ -17,16 +17,23 @@
  */
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-import forge.ai.*;
+
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardCollectionView;
 import forge.game.card.CardLists;
-import forge.game.cost.Cost;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.player.PlayerCollection;
@@ -36,10 +43,6 @@ import forge.game.spellability.TargetRestrictions;
 import forge.game.staticability.StaticAbilityMustTarget;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
-import forge.util.collect.FCollectionView;
-
-import java.util.List;
-import java.util.Map;
 
 
 //AB:GainControl|ValidTgts$Creature|TgtPrompt$Select target legendary creature|LoseControl$Untap,LoseControl|SpellDescription$Gain control of target xxxxxxx
@@ -65,7 +68,7 @@ import java.util.Map;
  */
 public class ControlGainAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision canPlay(final Player ai, final SpellAbility sa) {
+    protected boolean canPlayAI(final Player ai, final SpellAbility sa) {
         final List<String> lose = Lists.newArrayList();
 
         if (sa.hasParam("LoseControl")) {
@@ -81,30 +84,22 @@ public class ControlGainAi extends SpellAbilityAi {
             if (sa.hasParam("AllValid")) {
                 CardCollectionView tgtCards = opponents.getCardsIn(ZoneType.Battlefield);
                 tgtCards = AbilityUtils.filterListByType(tgtCards, sa.getParam("AllValid"), sa);
-
-                if (tgtCards.isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
-                }
-
+                return !tgtCards.isEmpty();
             }
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         } else {
             sa.resetTargets();
             if (sa.hasParam("TargetingPlayer")) {
                 Player targetingPlayer = AbilityUtils.getDefinedPlayers(sa.getHostCard(), sa.getParam("TargetingPlayer"), sa).get(0);
                 sa.setTargetingPlayer(targetingPlayer);
-                if (targetingPlayer.getController().chooseTargetsFor(sa)) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
-                }
+                return targetingPlayer.getController().chooseTargetsFor(sa);
             }
 
             if (tgt.canOnlyTgtOpponent()) {
                 List<Player> oppList = opponents.filter(PlayerPredicates.isTargetableBy(sa));
 
                 if (oppList.isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                    return false;
                 }
 
                 if (tgt.isRandomTarget()) {
@@ -119,12 +114,12 @@ public class ControlGainAi extends SpellAbilityAi {
         if (lose.contains("EOT")
                 && game.getPhaseHandler().getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS)
                 && !sa.isTrigger()) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         if (sa.hasParam("Defined")) {
             // no need to target, we'll pick up the target from Defined
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
 
         CardCollection list = opponents.getCardsIn(ZoneType.Battlefield);
@@ -173,7 +168,7 @@ public class ControlGainAi extends SpellAbilityAi {
         });
 
         if (list.isEmpty()) {
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
         }
 
         int creatures = 0, artifacts = 0, planeswalkers = 0, lands = 0, enchantments = 0;
@@ -202,7 +197,7 @@ public class ControlGainAi extends SpellAbilityAi {
             if (list.isEmpty()) {
                 if ((sa.getTargets().size() < tgt.getMinTargets(sa.getHostCard(), sa)) || (sa.getTargets().size() == 0)) {
                     sa.resetTargets();
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                    return false;
                 } else {
                     // TODO is this good enough? for up to amounts?
                     break;
@@ -213,9 +208,6 @@ public class ControlGainAi extends SpellAbilityAi {
             while (t == null) {
                 // filter by MustTarget requirement
                 CardCollection originalList = new CardCollection(list);
-
-                list = CardLists.canSubsequentlyTarget(list, sa);
-
                 boolean mustTargetFiltered = StaticAbilityMustTarget.filterMustTargetCards(ai, list, sa);
 
                 if (planeswalkers > 0) {
@@ -265,41 +257,39 @@ public class ControlGainAi extends SpellAbilityAi {
             }
         }
 
-        return new AiAbilityDecision(
-                sa.isTargetNumberValid() ? 100 : 0,
-                sa.isTargetNumberValid() ? AiPlayDecision.WillPlay : AiPlayDecision.TargetingFailed);
+        return true;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         if (!sa.usesTargeting()) {
             if (mandatory) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
         } else {
-            if (sa.hasParam("TargetingPlayer") || (mandatory && !this.canPlay(ai, sa).willingToPlay())) {
+            if (sa.hasParam("TargetingPlayer") || (!this.canPlayAI(ai, sa) && mandatory)) {
                 if (sa.getTargetRestrictions().canOnlyTgtOpponent()) {
                     List<Player> oppList = ai.getOpponents().filter(PlayerPredicates.isTargetableBy(sa));
                     if (oppList.isEmpty()) {
-                        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                        return false;
                     }
                     sa.getTargets().add(Aggregates.random(oppList));
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
 
                 List<Card> list = CardLists.getTargetableCards(ai.getCardsIn(ZoneType.Battlefield), sa);
                 if (list.isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                    return false;
                 }
                 sa.getTargets().add(ComputerUtilCard.getWorstAI(list));
             }
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, final Player ai) {
+    public boolean chkAIDrawback(SpellAbility sa, final Player ai) {
         final Game game = ai.getGame();
 
         // Special card logic that is processed elsewhere
@@ -315,7 +305,7 @@ public class ControlGainAi extends SpellAbilityAi {
                 CardCollectionView tgtCards = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
                 tgtCards = AbilityUtils.filterListByType(tgtCards, sa.getParam("AllValid"), sa);
                 if (tgtCards.isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+                    return false;
                 }
             }
             final List<String> lose = Lists.newArrayList();
@@ -324,14 +314,10 @@ public class ControlGainAi extends SpellAbilityAi {
                 lose.addAll(Lists.newArrayList(sa.getParam("LoseControl").split(",")));
             }
 
-            if (lose.contains("EOT")
-                    && game.getPhaseHandler().getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS)) {
-                return new AiAbilityDecision(0, AiPlayDecision.AnotherTime);
-            } else {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            }
+            return !lose.contains("EOT")
+                    || !game.getPhaseHandler().getPhase().isAfter(PhaseType.COMBAT_DECLARE_ATTACKERS);
         } else {
-            return this.canPlay(ai, sa);
+            return this.canPlayAI(ai, sa);
         }
     }
 
@@ -344,22 +330,4 @@ public class ControlGainAi extends SpellAbilityAi {
         Card chosen = ComputerUtilCard.getBestCreatureAI(cards);
         return chosen != null ? chosen.getController() : Iterables.getFirst(options, null);
     }
-
-    @Override
-    public boolean willPayUnlessCost(SpellAbility sa, Player payer, Cost cost, boolean alreadyPaid, FCollectionView<Player> payers) {
-        // Pay to gain Control
-        if (sa.hasParam("UnlessSwitched")) {
-            final Card host = sa.getHostCard();
-
-            final Card gameCard = host.getGame().getCardState(host, null);
-            if (gameCard == null
-                    || !gameCard.isInPlay() // not in play
-                    || payer.equals(gameCard.getController()) // already in control
-                    ) {
-                return false;
-            }
-        }
-
-        return super.willPayUnlessCost(sa, payer, cost, alreadyPaid, payers);
-    }
 }

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

@@ -17,9 +17,12 @@
  */
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
 import forge.game.card.Card;
@@ -29,9 +32,6 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.List;
-import java.util.Map;
-
 
 /**
  * <p>
@@ -43,27 +43,29 @@ import java.util.Map;
  */
 public class ControlGainVariantAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision canPlay(final Player ai, final SpellAbility sa) {
+    protected boolean canPlayAI(final Player ai, final SpellAbility sa) {
+
         String logic = sa.getParam("AILogic");
 
         if ("GainControlOwns".equals(logic)) {
             List<Card> list = CardLists.filter(ai.getGame().getCardsIn(ZoneType.Battlefield), crd -> crd.isCreature() && !crd.getController().equals(crd.getOwner()));
             if (list.isEmpty()) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
             for (final Card c : list) {
                 if (ai.equals(c.getController())) {
-                    return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+                    return false;
                 }
             }
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
+
     }
 
     @Override
     public Card chooseSingleCard(Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
-        Iterable<Card> otherCtrl = CardLists.filter(options, CardPredicates.isController(ai).negate());
+        Iterable<Card> otherCtrl = CardLists.filter(options, Predicates.not(CardPredicates.isController(ai)));
         if (Iterables.isEmpty(otherCtrl)) {
             return ComputerUtilCard.getWorstAI(options);
         } else {

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

@@ -1,12 +1,31 @@
 package forge.ai.ability;
 
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
-import forge.ai.*;
+
+import forge.ai.AiPlayDecision;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.GameEntity;
 import forge.game.ability.AbilityKey;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+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.CardPredicates.Presets;
+import forge.game.card.CardUtil;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -15,59 +34,47 @@ import forge.game.player.PlayerCollection;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Predicate;
-
 public class CopyPermanentAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision checkApiLogic(Player aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         Card source = sa.getHostCard();
         PhaseHandler ph = aiPlayer.getGame().getPhaseHandler();
         String aiLogic = sa.getParamOrDefault("AILogic", "");
 
+        if (ComputerUtil.preventRunAwayActivations(sa)) {
+            return false;
+        }
+
         if ("MomirAvatar".equals(aiLogic)) {
             return SpecialCardAi.MomirVigAvatar.consider(aiPlayer, sa);
         } else if ("MimicVat".equals(aiLogic)) {
             return SpecialCardAi.MimicVat.considerCopy(aiPlayer, sa);
         } else if ("AtEOT".equals(aiLogic)) {
-            if (ph.is(PhaseType.END_OF_TURN)) {
-                if (ph.getPlayerTurn() == aiPlayer) {
-                    // If it's the AI's turn, it can activate at EOT
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                } else {
-                    // If it's not the AI's turn, it can't activate at EOT
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
-            } else {
-                // Not at EOT phase
-                return new AiAbilityDecision(0, AiPlayDecision.WaitForEndOfTurn);
-            }
+            return ph.is(PhaseType.END_OF_TURN);
+        } else if ("AtOppEOT".equals(aiLogic)) {
+            return ph.is(PhaseType.END_OF_TURN) && ph.getPlayerTurn() != aiPlayer;
         } else if ("DuplicatePerms".equals(aiLogic)) {
             final List<Card> valid = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
             if (valid.size() < 2) {
-                return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+                return false;
             }
         }
 
         if (sa.hasParam("AtEOT") && !ph.is(PhaseType.MAIN1)) {
-            return new AiAbilityDecision(0, AiPlayDecision.AnotherTime);
+            return false;
         }
 
         if (sa.hasParam("Defined")) {
             // If there needs to be an imprinted card, don't activate the ability if nothing was imprinted yet (e.g. Mimic Vat)
             if (sa.getParam("Defined").equals("Imprinted.ExiledWithSource") && source.getImprintedCards().isEmpty()) {
-                return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+                return false;
             }
         }
 
         if (sa.isEmbalm() || sa.isEternalize()) {
             // E.g. Vizier of Many Faces: check to make sure it makes sense to make the token now
-            AiPlayDecision decision = ComputerUtilCard.checkNeedsToPlayReqs(sa.getHostCard(), sa);
-
-            if (decision != AiPlayDecision.WillPlay) {
-                return new AiAbilityDecision(0, decision);
+            if (ComputerUtilCard.checkNeedsToPlayReqs(sa.getHostCard(), sa) != AiPlayDecision.WillPlay) {
+                return false;
             }
         }
 
@@ -82,45 +89,37 @@ public class CopyPermanentAi extends SpellAbilityAi {
             sa.resetTargets();
             Player targetingPlayer = AbilityUtils.getDefinedPlayers(source, sa.getParam("TargetingPlayer"), sa).get(0);
             sa.setTargetingPlayer(targetingPlayer);
-            if (targetingPlayer.getController().chooseTargetsFor(sa)) {
-                if (sa.isTargetNumberValid()) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
-                }
-            } else {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
+            return targetingPlayer.getController().chooseTargetsFor(sa);
         } else if (sa.usesTargeting() && sa.getTargetRestrictions().canTgtPlayer()) {
                 if (!sa.isCurse()) {
                     if (sa.canTarget(aiPlayer)) {
                         sa.getTargets().add(aiPlayer);
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
                     } else {
                         for (Player p : aiPlayer.getYourTeam()) {
                             if (sa.canTarget(p)) {
                                 sa.getTargets().add(p);
-                                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                                return true;
                             }
                         }
-                        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                        return false;
                     }
                 } else {
                     for (Player p : aiPlayer.getOpponents()) {
                         if (sa.canTarget(p)) {
                             sa.getTargets().add(p);
-                            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                            return true;
                         }
                     }
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                    return false;
                 }
         } else {
-            return doTriggerNoCost(aiPlayer, sa, false);
+            return doTriggerAINoCost(aiPlayer, sa, false);
         }
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(final Player aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(final Player aiPlayer, SpellAbility sa, boolean mandatory) {
         final Card host = sa.getHostCard();
         final Player activator = sa.getActivatingPlayer();
         final Game game = host.getGame();
@@ -137,19 +136,18 @@ public class CopyPermanentAi extends SpellAbilityAi {
                 // TODO: possibly improve the check, currently only checks if the name is the same
                 // Possibly also check if the card is threatened, and then allow to copy (this will, however, require a bit
                 // of a rewrite in canPlayAI to allow a response form of CopyPermanentAi)
-                Predicate<Card> nameEquals = CardPredicates.nameEquals(host.getName());
-                list = CardLists.filter(list, nameEquals.negate());
+                list = CardLists.filter(list, Predicates.not(CardPredicates.nameEquals(host.getName())));
             }
 
             //Nothing to target
             if (list.isEmpty()) {
-            	return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            	return false;
             }
 
-            CardCollection betterList = CardLists.filter(list, CardPredicates.isRemAIDeck().negate());
+            CardCollection betterList = CardLists.filter(list, Predicates.not(CardPredicates.isRemAIDeck()));
             if (betterList.isEmpty()) {
                 if (!mandatory) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
             } else {
                 list = betterList;
@@ -161,18 +159,16 @@ public class CopyPermanentAi extends SpellAbilityAi {
                 if (felidarGuardian.size() > 0) {
                     // can copy a Felidar Guardian and combo off, so let's do it
                     sa.getTargets().add(felidarGuardian.get(0));
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
 
             // target loop
             while (sa.canAddMoreTarget()) {
-                list = CardLists.canSubsequentlyTarget(list, sa);
-
                 if (list.isEmpty()) {
-                    if (!sa.isTargetNumberValid() || sa.getTargets().isEmpty()) {
+                    if (!sa.isTargetNumberValid() || sa.getTargets().size() == 0) {
                         sa.resetTargets();
-                        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                        return false;
                     } else {
                         // TODO is this good enough? for up to amounts?
                         break;
@@ -181,7 +177,7 @@ public class CopyPermanentAi extends SpellAbilityAi {
 
                 list = CardLists.filter(list, c -> (!c.getType().isLegendary() || canCopyLegendary) || !c.getController().equals(aiPlayer));
                 Card choice;
-                if (list.stream().anyMatch(CardPredicates.CREATURES)) {
+                if (Iterables.any(list, Presets.CREATURES)) {
                     if (sa.hasParam("TargetingPlayer")) {
                         choice = ComputerUtilCard.getWorstCreatureAI(list);
                     } else {
@@ -192,9 +188,9 @@ public class CopyPermanentAi extends SpellAbilityAi {
                 }
 
                 if (choice == null) { // can't find anything left
-                    if (!sa.isTargetNumberValid() || sa.getTargets().isEmpty()) {
+                    if (!sa.isTargetNumberValid() || sa.getTargets().size() == 0) {
                         sa.resetTargets();
-                        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                        return false;
                     } else {
                         // TODO is this good enough? for up to amounts?
                         break;
@@ -209,22 +205,20 @@ public class CopyPermanentAi extends SpellAbilityAi {
             choices = CardLists.getValidCards(choices, sa.getParam("Choices"), activator, host, sa);
             Collection<Card> betterChoices = getBetterOptions(aiPlayer, sa, choices, !mandatory);
             if (betterChoices.isEmpty()) {
-                if (mandatory) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
-                }
+                return mandatory;
             }
+        } else {
+            // if no targeting, it should always be ok
         }
 
         if ("TriggeredCardController".equals(sa.getParam("Controller"))) {
             Card trigCard = (Card)sa.getTriggeringObject(AbilityKey.Card);
             if (!mandatory && trigCard != null && trigCard.getController().isOpponentOf(aiPlayer)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
     
     /* (non-Javadoc)

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

@@ -1,31 +1,34 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import java.util.List;
+import java.util.Map;
+
+import forge.ai.AiCardMemory;
+import forge.ai.AiPlayDecision;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtilCard;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.ApiType;
-import forge.game.cost.Cost;
 import forge.game.player.Player;
 import forge.game.player.PlayerActionConfirmMode;
 import forge.game.spellability.Spell;
 import forge.game.spellability.SpellAbility;
 import forge.util.MyRandom;
-import forge.util.collect.FCollectionView;
-
-import java.util.List;
-import java.util.Map;
 
 public class CopySpellAbilityAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision checkApiLogic(Player aiPlayer, SpellAbility sa) {
+    protected boolean canPlayAI(Player aiPlayer, SpellAbility sa) {
         Game game = aiPlayer.getGame();
         int chance = ((PlayerControllerAi)aiPlayer.getController()).getAi().getIntProperty(AiProps.CHANCE_TO_COPY_OWN_SPELL_WHILE_ON_STACK);
         int diff = ((PlayerControllerAi)aiPlayer.getController()).getAi().getIntProperty(AiProps.ALWAYS_COPY_SPELL_IF_CMC_DIFF);
         String logic = sa.getParamOrDefault("AILogic", "");
 
         if (game.getStack().isEmpty()) {
-            boolean result = sa.isMandatory() || "Always".equals(logic);
-            return result ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return sa.isMandatory();
         }
 
         final SpellAbility top = game.getStack().peekAbility();
@@ -42,40 +45,47 @@ public class CopySpellAbilityAi extends SpellAbilityAi {
         }
 
         if (!MyRandom.percentTrue(chance)
-                && !"Always".equals(logic)
+                && !"AlwaysIfViable".equals(logic)
+                && !"OnceIfViable".equals(logic)
                 && !"AlwaysCopyActivatedAbilities".equals(logic)) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
+        }
+
+        if ("OnceIfViable".equals(logic)) {
+            if (AiCardMemory.isRememberedCard(aiPlayer, sa.getHostCard(), AiCardMemory.MemorySet.ACTIVATED_THIS_TURN)) {
+                return false;
+            }
         }
 
         if (sa.usesTargeting()) {
             // Filter AI-specific targets if provided
             if ("OnlyOwned".equals(sa.getParam("AITgts"))) {
                 if (!top.getActivatingPlayer().equals(aiPlayer)) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
             }
 
             if (top.isWrapper() || top.isActivatedAbility()) {
                 // Shouldn't even try with triggered or wrapped abilities at this time, will crash
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             } else if (top.getApi() == ApiType.CopySpellAbility) {
                 // Don't try to copy a copy ability, too complex for the AI to handle
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             } else if (top.getApi() == ApiType.Mana) {
                 // would lead to Stack Overflow by trying to play this again
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             } else if (top.getApi() == ApiType.DestroyAll || top.getApi() == ApiType.SacrificeAll || top.getApi() == ApiType.ChangeZoneAll || top.getApi() == ApiType.TapAll || top.getApi() == ApiType.UnattachAll) {
                 if (!top.usesTargeting() || top.getActivatingPlayer().equals(aiPlayer)) {
                     // If we activated a mass removal / mass tap / mass bounce / etc. spell, or if the opponent activated it but
                     // it can't be retargeted, no reason to copy this spell since it'll probably do the same thing and is useless as a copy
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
             } else if (top.hasParam("ConditionManaSpent") || top.getHostCard().hasSVar("AINoCopy")) {
                 // Mana spent is not copied, so these spells generally do nothing when copied.
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             } else if (ComputerUtilCard.isCardRemAIDeck(top.getHostCard())) {
                 // Don't try to copy anything you can't understand how to handle
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
 
             // A copy is necessary to properly test the SA before targeting the copied spell, otherwise the copy SA will fizzle.
@@ -93,49 +103,32 @@ public class CopySpellAbilityAi extends SpellAbilityAi {
                 }
                 if (decision == AiPlayDecision.WillPlay) {
                     sa.getTargets().add(top);
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    AiCardMemory.rememberCard(aiPlayer, sa.getHostCard(), AiCardMemory.MemorySet.ACTIVATED_THIS_TURN);
+                    return true;
                 }
-                return new AiAbilityDecision(0, decision);
             }
         }
 
         // the AI should not miss mandatory activations
-        boolean result = sa.isMandatory() || "Always".equals(logic);
-        return result ? new AiAbilityDecision(100, AiPlayDecision.WillPlay) : new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return sa.isMandatory() || "Always".equals(logic);
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         // the AI should not miss mandatory activations (e.g. Precursor Golem trigger)
         String logic = sa.getParamOrDefault("AILogic", "");
-
-        if (mandatory) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-
-        if (logic.contains("Always")) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return mandatory || logic.contains("Always"); // this includes logic like AlwaysIfViable
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(final SpellAbility sa, final Player aiPlayer) {
+    public boolean chkAIDrawback(final SpellAbility sa, final Player aiPlayer) {
         if ("ChainOfSmog".equals(sa.getParam("AILogic"))) {
             return SpecialCardAi.ChainOfSmog.consider(aiPlayer, sa);
-        }
-        if ("ChainOfAcid".equals(sa.getParam("AILogic"))) {
+        } else if ("ChainOfAcid".equals(sa.getParam("AILogic"))) {
             return SpecialCardAi.ChainOfAcid.consider(aiPlayer, sa);
         }
 
-        AiAbilityDecision decision = canPlay(aiPlayer, sa);
-        if (!decision.willingToPlay()) {
-            if (sa.isMandatory()) {
-                return super.chkDrawback(sa, aiPlayer);
-            }
-        }
-        return decision;
+        return canPlayAI(aiPlayer, sa) || (sa.isMandatory() && super.chkAIDrawback(sa, aiPlayer));
     }
 
     @Override
@@ -149,29 +142,10 @@ public class CopySpellAbilityAi extends SpellAbilityAi {
         // 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"))) {
-            return SpecialCardAi.ChainOfAcid.consider(player, sa).willingToPlay();
+            return SpecialCardAi.ChainOfAcid.consider(player, sa);
         }
 
         return true;
     }
 
-    @Override
-    public boolean willPayUnlessCost(SpellAbility sa, Player payer, Cost cost, boolean alreadyPaid, FCollectionView<Player> payers) {
-        final String aiLogic = sa.getParam("UnlessAI");
-        if ("Never".equals(aiLogic)) { return false; }
-
-        if (sa.hasParam("UnlessSwitched")) {
-            // TODO try without AI Logic flag
-            if ("ChainOfVapor".equals(aiLogic)) {
-                if (payer.getLandsInPlay().size() < 3) {
-                    return false;
-                }
-                // TODO make better logic in to pick which opponent
-                if (payer.getOpponents().getCreaturesInPlay().size() < 0) {
-                    return false;
-                }
-            }
-        }
-        return super.willPayUnlessCost(sa, payer, cost, alreadyPaid, payers);
-    }
 }

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

@@ -1,20 +1,24 @@
 package forge.ai.ability;
 
 import java.util.Iterator;
-import java.util.List;
 
+import forge.game.ability.effects.CounterEffect;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
 
-import forge.ai.*;
+import forge.ai.AiController;
+import forge.ai.AiProps;
+import forge.ai.ComputerUtilAbility;
+import forge.ai.ComputerUtilCost;
+import forge.ai.ComputerUtilMana;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpecialCardAi;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.ability.ApiType;
-import forge.game.ability.effects.CounterEffect;
 import forge.game.card.Card;
-import forge.game.card.CardCollectionView;
-import forge.game.card.CardPredicates;
 import forge.game.cost.Cost;
 import forge.game.cost.CostDiscard;
 import forge.game.cost.CostExile;
@@ -24,13 +28,13 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.SpellAbilityStackInstance;
 import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
-import forge.util.collect.FCollectionView;
 
 public class CounterAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         boolean toReturn = true;
+        final Cost abCost = sa.getPayCosts();
         final Card source = sa.getHostCard();
         final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
         final Game game = ai.getGame();
@@ -38,12 +42,22 @@ public class CounterAi extends SpellAbilityAi {
         SpellAbility tgtSA = null;
 
         if (game.getStack().isEmpty()) {
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
+        }
+
+        if (abCost != null) {
+            // AI currently disabled for these costs
+            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa)) {
+                return false;
+            }
+            if (!ComputerUtilCost.checkLifeCost(ai, abCost, source, 4, sa)) {
+                return false;
+            }
         }
 
         if ("Force of Will".equals(sourceName)) {
             if (!SpecialCardAi.ForceOfWill.consider(ai, sa)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
         }
 
@@ -51,32 +65,25 @@ public class CounterAi extends SpellAbilityAi {
             final SpellAbility topSA = ComputerUtilAbility.getTopSpellAbilityOnStack(game, sa);
             if ((topSA.isSpell() && !topSA.isCounterableBy(sa)) || ai.getYourTeam().contains(topSA.getActivatingPlayer())) {
                 // might as well check for player's friendliness
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             } else if (sa.hasParam("ConditionWouldDestroy") && !CounterEffect.checkForConditionWouldDestroy(sa, topSA)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+                return false;
             }
 
             // check if the top ability on the stack corresponds to the AI-specific targeting declaration, if provided
             if (sa.hasParam("AITgts") && (topSA.getHostCard() == null
                     || !topSA.getHostCard().isValid(sa.getParam("AITgts"), sa.getActivatingPlayer(), source, sa))) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
 
             if (sa.hasParam("CounterNoManaSpell") && topSA.getTotalManaSpent() > 0) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
 
-            if (sa.hasParam("UnlessCost") && "TargetedController".equals(sa.getParamOrDefault("UnlessPayer", "TargetedController"))) {
-                Cost unlessCost = AbilityUtils.calculateUnlessCost(sa, sa.getParam("UnlessCost"), false);
-                if (unlessCost.hasSpecificCostType(CostDiscard.class)) {
-                    CostDiscard discardCost = unlessCost.getCostPartByType(CostDiscard.class);
-                    if ("Hand".equals(discardCost.getType())) {
-                        if (topSA.getActivatingPlayer().getCardsIn(ZoneType.Hand).size() < 2) {
-                            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                        }
-                    }
+            if ("OppDiscardsHand".equals(sa.getParam("AILogic"))) {
+                if (topSA.getActivatingPlayer().getCardsIn(ZoneType.Hand).size() < 2) {
+                    return false;
                 }
-                // TODO check if Player can pay the unless cost?
             }
 
             sa.resetTargets();
@@ -88,11 +95,10 @@ public class CounterAi extends SpellAbilityAi {
                     tgtCMC += topSA.getPayCosts().getTotalMana().countX() > 0 ? 3 : 0; // TODO: somehow determine the value of X paid and account for it?
                 }
             } else {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
         } else {
-            // This spell doesn't target. Must be a "Coutner All" or "Counter trigger" type of ability.
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         String unlessCost = sa.hasParam("UnlessCost") ? sa.getParam("UnlessCost").trim() : null;
@@ -111,13 +117,13 @@ public class CounterAi extends SpellAbilityAi {
             }
 
             if (toPay == 0) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantAffordX);
+                return false;
             }
 
             if (toPay <= usableManaSources) {
                 // If this is a reusable Resource, feel free to play it most of the time
                 if (!playReusable(ai, sa)) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantAfford);
+                    return false;
                 }
             }
 
@@ -136,15 +142,15 @@ public class CounterAi extends SpellAbilityAi {
         if (sa.hasParam("AILogic")) {
             String logic = sa.getParam("AILogic");
             if ("Never".equals(logic)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             } else if (logic.startsWith("MinCMC.")) { // TODO fix Daze and fold into AITgts
                 int minCMC = Integer.parseInt(logic.substring(7));
                 if (tgtCMC < minCMC) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
             } else if ("NullBrooch".equals(logic)) {
                 if (!SpecialCardAi.NullBrooch.consider(ai, sa)) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
             }
         }
@@ -223,40 +229,37 @@ public class CounterAi extends SpellAbilityAi {
         }
 
         if (dontCounter) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return toReturn;
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player aiPlayer) {
-        return doTriggerNoCost(aiPlayer, sa, true);
+    public boolean chkAIDrawback(SpellAbility sa, Player aiPlayer) {
+        return doTriggerAINoCost(aiPlayer, sa, true);
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Game game = ai.getGame();
 
         if (sa.usesTargeting()) {
             if (game.getStack().isEmpty()) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
 
             sa.resetTargets();
-            if (mandatory && !sa.canAddMoreTarget()) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            }
             Pair<SpellAbility, Boolean> pair = chooseTargetSpellAbility(game, sa, ai, mandatory);
             SpellAbility tgtSA = pair.getLeft();
 
             if (tgtSA == null) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
             sa.getTargets().add(tgtSA);
             if (!mandatory && !pair.getRight()) {
                 // If not mandatory and not preferred, bail out after setting target
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
 
             String unlessCost = sa.hasParam("UnlessCost") ? sa.getParam("UnlessCost").trim() : null;
@@ -277,13 +280,14 @@ public class CounterAi extends SpellAbilityAi {
 
                 if (!mandatory) {
                     if (toPay == 0) {
-                        return new AiAbilityDecision(0, AiPlayDecision.CantAffordX);
+                        return false;
                     }
 
                     if (toPay <= usableManaSources) {
-                        // If this is a reusable Resource, feel free to play it most of the time
+                        // If this is a reusable Resource, feel free to play it most
+                        // of the time
                         if (!playReusable(ai,sa) || (MyRandom.getRandom().nextFloat() < .4)) {
-                            return new AiAbilityDecision(0, AiPlayDecision.CantAfford);
+                            return false;
                         }
                     }
                 }
@@ -300,7 +304,7 @@ public class CounterAi extends SpellAbilityAi {
         // force the Human into making decisions)
 
         // But really it should be more picky about how it counters things
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     public Pair<SpellAbility, Boolean> chooseTargetSpellAbility(Game game, SpellAbility sa, Player ai, boolean mandatory) {
@@ -347,51 +351,4 @@ public class CounterAi extends SpellAbilityAi {
 
         return new ImmutablePair<>(bestOption != null ? bestOption : leastBadOption, bestOption != null);
     }
-
-    @Override
-    public boolean willPayUnlessCost(SpellAbility sa, Player payer, Cost cost, boolean alreadyPaid, FCollectionView<Player> payers) {
-        final Card source = sa.getHostCard();
-        final Game game = source.getGame();
-        List<SpellAbility> spells = AbilityUtils.getDefinedSpellAbilities(source, sa.getParamOrDefault("Defined", "Targeted"), sa);
-        for (SpellAbility toBeCountered : spells) {
-            // ward or human misplay
-            if (!toBeCountered.isCounterableBy(sa)) {
-                return false;
-            }
-
-            if (toBeCountered.isSpell()) {
-                Card spellHost = toBeCountered.getHostCard();
-                Card gameCard = game.getCardState(spellHost, null);
-                // Spell Host already left the Stack Zone
-                if (gameCard == null || !gameCard.isInZone(ZoneType.Stack) || !gameCard.equalsWithGameTimestamp(spellHost)) {
-                    return false;
-                }
-            }
-
-            // no reason to pay if we don't plan to confirm
-            if (toBeCountered.isOptionalTrigger() && !SpellApiToAi.Converter.get(toBeCountered).doTriggerNoCostWithSubs(payer, toBeCountered, false).willingToPlay()) {
-                return false;
-            }
-            // TODO check hasFizzled
-        }
-        CardCollectionView hand = payer.getCardsIn(ZoneType.Hand);
-        if (cost.hasSpecificCostType(CostDiscard.class)) {
-            CostDiscard discard = cost.getCostPartByType(CostDiscard.class);
-            String type = discard.getType();
-            if (type.equals("Hand")) {
-                if (hand.isEmpty()) {
-                    return true;
-                }
-
-                // TODO how to check if the Spell on the Stack is more valuable than the Cards in Hand?
-                int spellSum = spells.stream().map(SpellAbility::getHostCard).filter(CardPredicates.CREATURES).mapToInt(ComputerUtilCard::evaluateCreature).sum();
-                int handSum = hand.stream().filter(CardPredicates.CREATURES).mapToInt(ComputerUtilCard::evaluateCreature).sum();
-                if (spellSum <= handSum) {
-                    return false;
-                }
-            }
-        }
-
-        return super.willPayUnlessCost(sa, payer, cost, alreadyPaid, payers);
-    }
 }

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

@@ -17,16 +17,24 @@
  */
 package forge.ai.ability;
 
+import java.util.List;
+
+import com.google.common.collect.Iterables;
+
 import forge.ai.ComputerUtilCard;
 import forge.ai.SpellAbilityAi;
-import forge.game.card.*;
+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.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.keyword.Keyword;
 import forge.game.player.Player;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
 
-import java.util.List;
-
 
 /**
  * <p>
@@ -45,19 +53,19 @@ public abstract class CountersAi extends SpellAbilityAi {
      * </p>
      *
      * @param list
-     *            a {@link CardCollectionView} object.
+     *            a {@link forge.CardList} object.
      * @param type
-     *            a {@link String} object.
+     *            a {@link java.lang.String} object.
      * @param amount
      *            a int.
-     * @param ai a {@link Player} object.
-     * @return a {@link Card} object.
+     * @param newParam TODO
+     * @return a {@link forge.game.card.Card} object.
      */
     public static Card chooseCursedTarget(final CardCollectionView list, final String type, final int amount, final Player ai) {
         Card choice;
 
         // opponent can always order it so that he gets 0
-        if (amount == 1 && ai.getOpponents().getCardsIn(ZoneType.Battlefield).anyMatch(CardPredicates.nameEquals("Vorinclex, Monstrous Raider"))) {
+        if (amount == 1 && Iterables.any(ai.getOpponents().getCardsIn(ZoneType.Battlefield), CardPredicates.nameEquals("Vorinclex, Monstrous Raider"))) {
             return null;
         }
 
@@ -65,7 +73,7 @@ public abstract class CountersAi extends SpellAbilityAi {
             // try to kill the best killable creature, or reduce the best one
             // but try not to target a Undying Creature
             final List<Card> killable = CardLists.getNotKeyword(CardLists.filterToughness(list, amount), Keyword.UNDYING);
-            if (!killable.isEmpty()) {
+            if (killable.size() > 0) {
                 choice = ComputerUtilCard.getBestCreatureAI(killable);
             } else {
                 choice = ComputerUtilCard.getBestCreatureAI(list);
@@ -83,10 +91,10 @@ public abstract class CountersAi extends SpellAbilityAi {
      * </p>
      *
      * @param list
-     *            a {@link CardCollectionView} object.
+     *            a {@link forge.CardList} object.
      * @param type
-     *            a {@link String} object.
-     * @return a {@link Card} object.
+     *            a {@link java.lang.String} object.
+     * @return a {@link forge.game.card.Card} object.
      */
     public static Card chooseBoonTarget(final CardCollectionView list, final String type) {
         Card choice = null;
@@ -102,7 +110,7 @@ public abstract class CountersAi extends SpellAbilityAi {
         } else if (type.equals("DIVINITY")) {
             final CardCollection boon = CardLists.filter(list, c -> c.getCounters(CounterEnumType.DIVINITY) == 0);
             choice = ComputerUtilCard.getMostExpensivePermanentAI(boon);
-        } else if (CounterType.getType(type).isKeywordCounter()) {
+        } else if (CounterType.get(type).isKeywordCounter()) {
             choice = ComputerUtilCard.getBestCreatureAI(CardLists.getNotKeyword(list, type));
         } else {
             // The AI really should put counters on cards that can use it.

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

@@ -1,7 +1,13 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.collect.Iterables;
-import forge.ai.*;
+
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.*;
@@ -14,30 +20,21 @@ import forge.game.zone.ZoneType;
 import forge.util.MyRandom;
 import forge.util.collect.FCollection;
 
-import java.util.List;
-import java.util.Map;
-
 public class CountersMoveAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision checkApiLogic(final Player ai, final SpellAbility sa) {
-        AiAbilityDecision decision = new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+    protected boolean checkApiLogic(final Player ai, final SpellAbility sa) {
         if (sa.usesTargeting()) {
             sa.resetTargets();
-            decision = moveTgtAI(ai, sa);
-            if (!decision.willingToPlay()) {
-                return decision;
+            if (!moveTgtAI(ai, sa)) {
+                return false;
             }
         }
 
         if (!playReusable(ai, sa)) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
-        if (MyRandom.getRandom().nextFloat() < .8f) {
-            return decision;
-        }
-
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return MyRandom.getRandom().nextFloat() < .8f; // random success
     }
 
     @Override
@@ -113,13 +110,12 @@ public class CountersMoveAi extends SpellAbilityAi {
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(final Player ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(final Player ai, SpellAbility sa, boolean mandatory) {
         if (sa.usesTargeting()) {
             sa.resetTargets();
 
-            AiAbilityDecision decision = moveTgtAI(ai, sa);
-            if (!decision.willingToPlay() && !mandatory) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            if (!moveTgtAI(ai, sa) && !mandatory) {
+                return false;
             }
 
             if (!sa.isTargetNumberValid() && mandatory) {
@@ -127,18 +123,18 @@ public class CountersMoveAi extends SpellAbilityAi {
                 List<Card> tgtCards = CardLists.getTargetableCards(game.getCardsIn(ZoneType.Battlefield), sa);
 
                 if (tgtCards.isEmpty()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                    return false;
                 }
 
                 final Card card = ComputerUtilCard.getWorstAI(tgtCards);
                 sa.getTargets().add(card);
             }
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         } else {
             // no target Probably something like Graft
 
             if (mandatory) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
 
             final Card host = sa.getHostCard();
@@ -150,7 +146,7 @@ public class CountersMoveAi extends SpellAbilityAi {
             final List<Card> destCards = AbilityUtils.getDefinedCards(host, sa.getParam("Defined"), sa);
 
             if (srcCards.isEmpty() || destCards.isEmpty()) {
-                return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+                return false;
             }
 
             final Card src = srcCards.get(0);
@@ -158,21 +154,21 @@ public class CountersMoveAi extends SpellAbilityAi {
 
             // for such Trigger, do not move counter to another players creature
             if (!dest.getController().equals(ai)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             } else if (ComputerUtilCard.isUselessCreature(ai, dest)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             } else if (dest.hasSVar("EndOfTurnLeavePlay")) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
 
             if (cType != null) {
                 if (!dest.canReceiveCounters(cType)) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
                 final int amount = calcAmount(sa, cType);
                 int a = src.getCounters(cType);
                 if (a < amount) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
 
                 final Card srcCopy = CardCopyService.getLKICopy(src);
@@ -186,31 +182,27 @@ public class CountersMoveAi extends SpellAbilityAi {
                 int newEval = ComputerUtilCard.evaluateCreature(srcCopy) + ComputerUtilCard.evaluateCreature(destCopy);
 
                 if (newEval < oldEval) {
-                    return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+                    return false;
                 }
 
                 // check for some specific AI preferences
                 if ("DontMoveCounterIfLethal".equals(sa.getParam("AILogic"))) {
-                    if  (!cType.is(CounterEnumType.P1P1) || src.getNetToughness() - src.getTempToughnessBoost() - 1 > 0) {
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                    } else {
-                        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                    }
+                    return !cType.is(CounterEnumType.P1P1) || src.getNetToughness() - src.getTempToughnessBoost() - 1 > 0;
                 }
             }
             // no target
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return true;
         }
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         if (sa.usesTargeting()) {
             sa.resetTargets();
             return moveTgtAI(ai, sa);
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     private static int calcAmount(final SpellAbility sa, final CounterType cType) {
@@ -235,7 +227,7 @@ public class CountersMoveAi extends SpellAbilityAi {
         return amount;
     }
 
-    private AiAbilityDecision moveTgtAI(final Player ai, final SpellAbility sa) {
+    private boolean moveTgtAI(final Player ai, final SpellAbility sa) {
         final Card host = sa.getHostCard();
         final Game game = ai.getGame();
         final String type = sa.getParam("CounterType");
@@ -253,7 +245,7 @@ public class CountersMoveAi extends SpellAbilityAi {
 
             if (destCards.isEmpty()) {
                 // something went wrong
-                return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+                return false;
             }
 
             final Card dest = destCards.get(0);
@@ -262,7 +254,7 @@ public class CountersMoveAi extends SpellAbilityAi {
             tgtCards.remove(dest);
 
             if (cType != null && !dest.canReceiveCounters(cType)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
 
             // prefered logic for this: try to steal counter
@@ -294,7 +286,7 @@ public class CountersMoveAi extends SpellAbilityAi {
 
                 if (card != null) {
                     sa.getTargets().add(card);
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
 
             }
@@ -338,14 +330,14 @@ public class CountersMoveAi extends SpellAbilityAi {
 
                 if (card != null) {
                     sa.getTargets().add(card);
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
 
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
         } else if (sa.getMaxTargets() == 2) {
             // TODO
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
         } else {
             // SA uses target for Defined
             // Source => Targeted
@@ -353,12 +345,12 @@ public class CountersMoveAi extends SpellAbilityAi {
 
             if (srcCards.isEmpty()) {
                 // something went wrong
-                return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+                return false;
             }
 
             final Card src = srcCards.get(0);
             if (cType != null && src.getCounters(cType) <= 0) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
 
             Card lkiWithCounters = CardCopyService.getLKICopy(src);
@@ -411,14 +403,14 @@ public class CountersMoveAi extends SpellAbilityAi {
 
                     if (card != null) {
                         sa.getTargets().add(card);
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
                     }
                 }
                 final boolean isMandatoryTrigger = (sa.isTrigger() && !sa.isOptionalTrigger())
                         || (sa.getRootAbility().isTrigger() && !sa.getRootAbility().isOptionalTrigger());
                 if (!isMandatoryTrigger) {
                     // no good target
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                    return false;
                 }
             }
 
@@ -448,10 +440,10 @@ public class CountersMoveAi extends SpellAbilityAi {
 
                 if (card != null) {
                     sa.getTargets().add(card);
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
         }
     }
 

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

@@ -1,10 +1,24 @@
 package forge.ai.ability;
 
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import com.google.common.base.Predicates;
+import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
-import forge.ai.*;
+
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCost;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+import forge.game.card.Card;
+import forge.game.card.CardCollection;
+import forge.game.card.CardLists;
+import forge.game.card.CardPredicates;
+import forge.game.card.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -12,48 +26,45 @@ import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
 
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-
 public class CountersMultiplyAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
-        if (sa.usesTargeting()) {
-            return setTargets(ai, sa);
-        }
-
+    protected boolean checkApiLogic(Player ai, SpellAbility sa) {
         final CounterType counterType = getCounterType(sa);
-        // defined are mostly Self or Creatures you control
-        CardCollection list = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa);
 
-        list = CardLists.filter(list, c -> {
-            if (!c.hasCounters()) {
-                return false;
-            }
+        if (!sa.usesTargeting()) {
+            // defined are mostly Self or Creatures you control
+            CardCollection list = AbilityUtils.getDefinedCards(sa.getHostCard(), sa.getParam("Defined"), sa);
 
-            if (counterType != null) {
-                if (c.getCounters(counterType) <= 0) {
+            list = CardLists.filter(list, c -> {
+                if (!c.hasCounters()) {
                     return false;
                 }
-                if (!c.canReceiveCounters(counterType)) {
-                    return false;
-                }
-            } else {
-                for (Map.Entry<CounterType, Integer> e : c.getCounters().entrySet()) {
-                    // has negative counter it would double
-                    if (ComputerUtil.isNegativeCounter(e.getKey(), c)) {
+
+                if (counterType != null) {
+                    if (c.getCounters(counterType) <= 0) {
                         return false;
                     }
+                    if (!c.canReceiveCounters(counterType)) {
+                        return false;
+                    }
+                } else {
+                    for (Map.Entry<CounterType, Integer> e : c.getCounters().entrySet()) {
+                        // has negative counter it would double
+                        if (ComputerUtil.isNegativeCounter(e.getKey(), c)) {
+                            return false;
+                        }
+                    }
                 }
+
+                return true;
+            });
+
+            if (list.isEmpty()) {
+                return false;
             }
-
-            return true;
-        });
-
-        if (list.isEmpty()) {
-            return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+        } else {
+            return setTargets(ai, sa);
         }
 
         return super.checkApiLogic(ai, sa);
@@ -82,27 +93,22 @@ public class CountersMultiplyAi extends SpellAbilityAi {
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         if (!sa.usesTargeting()) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
-
-        AiAbilityDecision decision = setTargets(ai, sa);
-        if (decision.willingToPlay()) {
-            return decision;
+        if (setTargets(ai, sa)) {
+            return true;
         } else if (mandatory) {
             CardCollection list = CardLists.getTargetableCards(ai.getGame().getCardsIn(ZoneType.Battlefield), sa);
             if (list.isEmpty()) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
-            Card safeMatch = list.stream()
-                    .filter(CardPredicates.hasCounters().negate())
-                    .findFirst().orElse(null);
+            Card safeMatch = Iterables.getFirst(Iterables.filter(list, Predicates.not(CardPredicates.hasCounters())), null);
             sa.getTargets().add(safeMatch == null ? list.getFirst() : safeMatch);
-            return new AiAbilityDecision(50, AiPlayDecision.MandatoryPlay);
+            return true;
         }
-
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return mandatory;
     }
 
     private CounterType getCounterType(SpellAbility sa) {
@@ -117,7 +123,7 @@ public class CountersMultiplyAi extends SpellAbilityAi {
         return null;
     }
 
-    private AiAbilityDecision setTargets(Player ai, SpellAbility sa) {
+    private boolean setTargets(Player ai, SpellAbility sa) {
         final CounterType counterType = getCounterType(sa);
 
         final Game game = ai.getGame();
@@ -154,7 +160,7 @@ public class CountersMultiplyAi extends SpellAbilityAi {
                 }
 
                 if (counterType == null || counterType.is(type)) {
-                    addTargetsByCounterType(ai, sa, aiList, type);
+                    addTargetsByCounterType(ai, sa, aiList, CounterType.get(type));
                 }
             }
         }
@@ -163,7 +169,7 @@ public class CountersMultiplyAi extends SpellAbilityAi {
         if (!oppList.isEmpty()) {
             // not enough targets
             if (sa.canAddMoreTarget()) {
-                final CounterType type = CounterEnumType.M1M1;
+                final CounterType type = CounterType.get(CounterEnumType.M1M1);
                 if (counterType == null || counterType == type) {
                     addTargetsByCounterType(ai, sa, oppList, type);
                 }
@@ -173,10 +179,10 @@ public class CountersMultiplyAi extends SpellAbilityAi {
         // targeting does failed
         if (!sa.isTargetNumberValid() || sa.getTargets().size() == 0) {
             sa.resetTargets();
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     private void addTargetsByCounterType(final Player ai, final SpellAbility sa, final CardCollection list,

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

@@ -1,22 +1,27 @@
 package forge.ai.ability;
 
-import com.google.common.collect.Lists;
-import forge.ai.*;
-import forge.game.GameEntity;
-import forge.game.card.*;
-import forge.game.player.Player;
-import forge.game.spellability.SpellAbility;
-import forge.game.zone.ZoneType;
-import forge.util.IterableUtil;
-
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+
+import forge.ai.AiProps;
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.PlayerControllerAi;
+import forge.ai.SpellAbilityAi;
+import forge.game.GameEntity;
+import forge.game.card.*;
+import forge.game.player.Player;
+import forge.game.spellability.SpellAbility;
+import forge.game.zone.ZoneType;
+
 public class CountersProliferateAi extends SpellAbilityAi {
 
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+    protected boolean checkApiLogic(Player ai, SpellAbility sa) {
         final List<Card> cperms = Lists.newArrayList();
         boolean allyExpOrEnergy = false;
 
@@ -68,34 +73,25 @@ public class CountersProliferateAi extends SpellAbilityAi {
             }));
         }
 
-        if (!cperms.isEmpty() || !hperms.isEmpty() || opponentPoison || allyExpOrEnergy) {
-            // AI will play it if there are any counters to proliferate
-            // or if there are no counters, but AI has experience or energy counters
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return !cperms.isEmpty() || !hperms.isEmpty() || opponentPoison || allyExpOrEnergy;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         boolean chance = true;
 
         // TODO Make sure Human has poison counters or there are some counters
         // we want to proliferate
-        return new AiAbilityDecision(
-            chance ? 100 : 0,
-            chance ? AiPlayDecision.WillPlay : AiPlayDecision.CantPlayAi
-        );
+        return chance;
     }
 
     /* (non-Javadoc)
      * @see forge.card.abilityfactory.SpellAiLogic#chkAIDrawback(java.util.Map, forge.card.spellability.SpellAbility, forge.game.player.Player)
      */
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         if ("Always".equals(sa.getParam("AILogic"))) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
 
         return checkApiLogic(ai, sa);
@@ -110,11 +106,11 @@ public class CountersProliferateAi extends SpellAbilityAi {
     public <T extends GameEntity> T chooseSingleEntity(Player ai, SpellAbility sa, Collection<T> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         // Proliferate is always optional for all, no need to select best
 
-        final CounterType poison = CounterEnumType.POISON;
+        final CounterType poison = CounterType.get(CounterEnumType.POISON);
 
         boolean aggroAI = (((PlayerControllerAi) ai.getController()).getAi()).getBooleanProperty(AiProps.PLAY_AGGRO);
         // because countertype can't be chosen anymore, only look for poison counters
-        for (final Player p : IterableUtil.filter(options, Player.class)) {
+        for (final Player p : Iterables.filter(options, Player.class)) {
             if (p.isOpponentOf(ai)) {
                 if (p.getCounters(poison) > 0 && p.canReceiveCounters(poison)) {
                     return (T)p;
@@ -127,7 +123,7 @@ public class CountersProliferateAi extends SpellAbilityAi {
             }
         }
 
-        for (final Card c : IterableUtil.filter(options, Card.class)) {
+        for (final Card c : Iterables.filter(options, Card.class)) {
             // AI planeswalker always, opponent planeswalkers never
             if (c.isPlaneswalker()) {
                 if (c.getController().isOpponentOf(ai)) {

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

@@ -1,5 +1,6 @@
 package forge.ai.ability;
 
+import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import forge.ai.*;
@@ -25,13 +26,11 @@ import forge.game.trigger.Trigger;
 import forge.game.trigger.TriggerType;
 import forge.game.zone.ZoneType;
 import forge.util.Aggregates;
-import forge.util.IterableUtil;
 import forge.util.MyRandom;
 
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import java.util.function.Predicate;
 
 public class CountersPutAi extends CountersAi {
 
@@ -53,7 +52,8 @@ public class CountersPutAi extends CountersAi {
 
         // disable moving counters (unless a specialized AI logic supports it)
         for (final CostPart part : cost.getCostParts()) {
-            if (part instanceof CostRemoveCounter remCounter) {
+            if (part instanceof CostRemoveCounter) {
+                final CostRemoveCounter remCounter = (CostRemoveCounter) part;
                 final CounterType counterType = remCounter.counter;
                 if (counterType.getName().equals(type) && !aiLogic.startsWith("MoveCounter")) {
                     return false;
@@ -92,11 +92,12 @@ public class CountersPutAi extends CountersAi {
                     return false;
                 }
                 return chance > MyRandom.getRandom().nextFloat();
+            } else {
+                return false;
             }
-            return false;
         }
 
-        if (sa.isKeyword(Keyword.LEVEL_UP)) {
+        if (sa.hasParam("LevelUp")) {
             // creatures enchanted by curse auras have low priority
             if (ph.getPhase().isBefore(PhaseType.MAIN2)) {
                 for (Card aura : source.getEnchantedBy()) {
@@ -117,12 +118,13 @@ public class CountersPutAi extends CountersAi {
     }
 
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, final SpellAbility sa) {
+    protected boolean checkApiLogic(Player ai, final SpellAbility sa) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what the expected targets could be
         final Cost abCost = sa.getPayCosts();
         final Card source = sa.getHostCard();
         final String sourceName = ComputerUtilAbility.getAbilitySourceName(sa);
+        CardCollection list;
         Card choice = null;
         final String amountStr = sa.getParamOrDefault("CounterNum", "1");
         final boolean divided = sa.isDividedAsYouChoose();
@@ -157,7 +159,7 @@ public class CountersPutAi extends CountersAi {
                     PlayerCollection poisonList = oppList.filter(PlayerPredicates.hasCounter(CounterEnumType.POISON, 9));
                     if (!poisonList.isEmpty()) {
                         sa.getTargets().add(poisonList.max(PlayerPredicates.compareByLife()));
-                        return new AiAbilityDecision(1000, AiPlayDecision.WillPlay);
+                        return true;
                     }
                 }
 
@@ -168,12 +170,12 @@ public class CountersPutAi extends CountersAi {
                     CardCollection oppCreatM1 = CardLists.filter(oppCreat, CardPredicates.hasCounter(CounterEnumType.M1M1));
                     oppCreatM1 = CardLists.getNotKeyword(oppCreatM1, Keyword.UNDYING);
 
-                    oppCreatM1 = CardLists.filter(oppCreatM1, input -> input.getNetToughness() <= 1 && input.canReceiveCounters(CounterEnumType.M1M1));
+                    oppCreatM1 = CardLists.filter(oppCreatM1, input -> input.getNetToughness() <= 1 && input.canReceiveCounters(CounterType.get(CounterEnumType.M1M1)));
 
                     Card best = ComputerUtilCard.getBestAI(oppCreatM1);
                     if (best != null) {
                         sa.getTargets().add(best);
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
                     }
 
                     CardCollection aiCreat = CardLists.getTargetableCards(ai.getCreaturesInPlay(), sa);
@@ -193,7 +195,7 @@ public class CountersPutAi extends CountersAi {
                     best = ComputerUtilCard.getBestAI(aiCreat);
                     if (best != null) {
                         sa.getTargets().add(best);
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
                     }
                 }
 
@@ -202,22 +204,28 @@ public class CountersPutAi extends CountersAi {
                     if (!ai.getCounters().isEmpty()) {
                         if (!eachExisting || ai.getPoisonCounters() < 5) {
                             sa.getTargets().add(ai);
-                            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                            return true;
                         }
                     }
                 }
 
             }
 
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
-        if ("AlwaysWithNoTgt".equals(logic)) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        if (ComputerUtil.preventRunAwayActivations(sa)) {
+            return false;
+        }
+
+        if ("Never".equals(logic)) {
+            return false;
+        } else if ("AlwaysWithNoTgt".equals(logic)) {
+            return true;
         } else if ("AristocratCounters".equals(logic)) {
             return SpecialAiLogic.doAristocratWithCountersLogic(ai, sa);
         } else if ("PayEnergy".equals(logic)) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         } else if ("PayEnergyConservatively".equals(logic)) {
             boolean onlyInCombat = ai.getController().isAI()
                     && ((PlayerControllerAi) ai.getController()).getAi().getBooleanProperty(AiProps.CONSERVATIVE_ENERGY_PAYMENT_ONLY_IN_COMBAT);
@@ -226,10 +234,10 @@ public class CountersPutAi extends CountersAi {
 
             if (playAggro) {
                 // aggro profiles ignore conservative play for this AI logic
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             } else if (ph.inCombat() && source != null) {
                 if (ai.getGame().getCombat().isAttacking(source) && !onlyDefensive) {
-                    return new AiAbilityDecision(100, AiPlayDecision.ImpactCombat);
+                    return true;
                 } else if (ai.getGame().getCombat().isBlocking(source)) {
                     // when blocking, consider this if it's possible to save the blocker and/or kill at least one attacker
                     CardCollection blocked = ai.getGame().getCombat().getAttackersBlockedBy(source);
@@ -239,44 +247,44 @@ public class CountersPutAi extends CountersAi {
                     int numActivations = ai.getCounters(CounterEnumType.ENERGY) / sa.getPayCosts().getCostEnergy().convertAmount();
                     if (source.getNetToughness() + numActivations > totBlkPower
                             || source.getNetPower() + numActivations >= totBlkToughness) {
-                        return new AiAbilityDecision(100, AiPlayDecision.ImpactCombat);
+                        return true;
                     }
                 }
             } else if (sa.getSubAbility() != null
                         && "Self".equals(sa.getSubAbility().getParam("Defined"))
                         && sa.getSubAbility().getParamOrDefault("KW", "").contains("Hexproof")
-                        && !source.getAbilityActivatedThisTurn().getActivators(sa).contains(ai)) {
+                        && !AiCardMemory.isRememberedCard(ai, source, AiCardMemory.MemorySet.ANIMATED_THIS_TURN)) {
                     // Bristling Hydra: save from death using a ping activation
                     if (ComputerUtil.predictThreatenedObjects(sa.getActivatingPlayer(), sa).contains(source)) {
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        AiCardMemory.rememberCard(ai, source, AiCardMemory.MemorySet.ACTIVATED_THIS_TURN);
+                        return true;
                     }
             } else if (ai.getCounters(CounterEnumType.ENERGY) > ComputerUtilCard.getMaxSAEnergyCostOnBattlefield(ai) + sa.getPayCosts().getCostEnergy().convertAmount()) {
                 // outside of combat, this logic only works if the relevant AI profile option is enabled
                 // and if there is enough energy saved
                 if (!onlyInCombat) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
         } else if (logic.equals("MarkOppCreature")) {
             if (!ph.is(PhaseType.END_OF_TURN)) {
-                return new AiAbilityDecision(0, AiPlayDecision.WaitForEndOfTurn);
+                return false;
             }
 
-            Predicate<Card> predicate = CardPredicates.hasCounter(CounterType.getType(type));
             CardCollection oppCreats = CardLists.filter(ai.getOpponents().getCreaturesInPlay(),
-                    predicate.negate(),
+                    Predicates.not(CardPredicates.hasCounter(CounterType.getType(type))),
                             CardPredicates.isTargetableBy(sa));
 
             if (!oppCreats.isEmpty()) {
                 Card bestCreat = ComputerUtilCard.getBestCreatureAI(oppCreats);
                 sa.resetTargets();
                 sa.getTargets().add(bestCreat);
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
         } else if (logic.equals("CheckDFC")) {
             // for cards like Ludevic's Test Subject
             if (!source.canTransform(null)) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
         } else if (logic.startsWith("MoveCounter")) {
             return doMoveCounterLogic(ai, sa, ph);
@@ -285,13 +293,8 @@ public class CountersPutAi extends CountersAi {
             if (willActivate && ph.getPhase().isBefore(PhaseType.MAIN2)) {
                 // don't use this for mana until after combat
                 AiCardMemory.rememberCard(ai, source, AiCardMemory.MemorySet.HELD_MANA_SOURCES_FOR_MAIN2);
-                return new AiAbilityDecision(25, AiPlayDecision.WaitForMain2);
             }
-
-            if (willActivate) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            }
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return willActivate;
         } else if (logic.equals("ChargeToBestCMC")) {
             return doChargeToCMCLogic(ai, sa);
         } else if (logic.equals("ChargeToBestOppControlledCMC")) {
@@ -300,11 +303,15 @@ public class CountersPutAi extends CountersAi {
             return SpecialCardAi.TheOneRing.consider(ai, sa);
         }
 
+        if (!sa.metConditions() && sa.getSubAbility() == null) {
+            return false;
+        }
+
         if (sourceName.equals("Feat of Resistance")) { // sub-ability should take precedence
             CardCollection prot = ProtectAi.getProtectCreatures(ai, sa.getSubAbility());
             if (!prot.isEmpty()) {
                 sa.getTargets().add(prot.get(0));
-                return new AiAbilityDecision(100, AiPlayDecision.ImpactCombat);
+                return true;
             }
         }
 
@@ -312,13 +319,13 @@ public class CountersPutAi extends CountersAi {
             CardCollection creatsYouCtrl = ai.getCreaturesInPlay();
             List<Card> leastToughness = Aggregates.listWithMin(creatsYouCtrl, Card::getNetToughness);
             if (leastToughness.isEmpty()) {
-                return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
+                return false;
             }
             // TODO If Creature that would be Bolstered for some reason is useless, also return False
         }
 
         if (sa.hasParam("Monstrosity") && source.isMonstrous()) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         // TODO handle proper calculation of X values based on Cost
@@ -332,8 +339,8 @@ public class CountersPutAi extends CountersAi {
             Game game = ai.getGame();
             Combat combat = game.getCombat();
 
-            if (!source.canReceiveCounters(CounterEnumType.P1P1) || source.getCounters(CounterEnumType.P1P1) > 0) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            if (!source.canReceiveCounters(CounterType.get(CounterEnumType.P1P1)) || source.getCounters(CounterEnumType.P1P1) > 0) {
+                return false;
             } else if (combat != null && ph.is(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
                 return doCombatAdaptLogic(source, amount, combat);
             }
@@ -344,7 +351,7 @@ public class CountersPutAi extends CountersAi {
             if (type.equals("P1P1")) {
                 nPump = amount;
             }
-            return FightAi.canFight(ai, sa, nPump, nPump);
+            return FightAi.canFightAi(ai, sa, nPump, nPump);
         }
 
         if (amountStr.equals("X")) {
@@ -360,31 +367,28 @@ public class CountersPutAi extends CountersAi {
 
                     // This will "rewind" clockwork cards when they fall to 50% power or below, consider improving
                     if (curCtrs > Math.ceil(maxCtrs / 2.0)) {
-                        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                        return false;
                     }
 
                     amount = Math.min(amount, maxCtrs - curCtrs);
                     if (amount <= 0) {
-                        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                        return false;
                     }
                 }
 
                 sa.setXManaCostPaid(amount);
             } else if ("ExiledCreatureFromGraveCMC".equals(logic)) {
                 // e.g. Necropolis
-                amount = ai.getCardsIn(ZoneType.Graveyard).stream()
-                        .filter(CardPredicates.CREATURES)
-                        .mapToInt(Card::getCMC)
-                        .max().orElse(0);
+                amount = Aggregates.max(CardLists.filter(ai.getCardsIn(ZoneType.Graveyard), CardPredicates.Presets.CREATURES), Card::getCMC);
                 if (amount > 0 && ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN)) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
         }
 
         // don't use it if no counters to add
         if (amount <= 0) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         if ("Polukranos".equals(logic)) {
@@ -399,7 +403,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()) {
@@ -411,14 +415,20 @@ public class CountersPutAi extends CountersAi {
                         }
                     }
                     if (!canSurvive) {
-                        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                        return false;
                     }
                 }
                 found = true;
                 break;
             }
             if (!found) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
+            }
+        }
+
+        if ("AtOppEOT".equals(logic)) {
+            if (ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn().equals(ai)) {
+                return true;
             }
         }
 
@@ -429,25 +439,24 @@ public class CountersPutAi extends CountersAi {
             if (!ai.getGame().getStack().isEmpty() && !isSorcerySpeed(sa, ai)) {
                 // only evaluates case where all tokens are placed on a single target
                 if (sa.getMinTargets() < 2) {
-                    AiAbilityDecision decision = ComputerUtilCard.canPumpAgainstRemoval(ai, sa);
-                    if (decision.willingToPlay()) {
+                    if (ComputerUtilCard.canPumpAgainstRemoval(ai, sa)) {
                         Card c = sa.getTargetCard();
                         if (sa.getTargets().size() > 1) {
                             sa.resetTargets();
                             sa.getTargets().add(c);
                         }
                         sa.addDividedAllocation(c, amount);
-                        return decision;
-                    } else if (!hasSacCost) {
-                        // for Sacrifice costs, evaluate further to see if it's worth using the ability before the card dies
-                        return decision;
+                        return true;
+                    } else {
+                        if (!hasSacCost) { // for Sacrifice costs, evaluate further to see if it's worth using the ability before the card dies
+                            return false;
+                        }
                     }
                 }
             }
 
             sa.resetTargets();
 
-            CardCollection list;
             if (sa.isCurse()) {
                 list = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
             } else {
@@ -484,7 +493,7 @@ public class CountersPutAi extends CountersAi {
             }
 
             if (list.size() < sa.getTargetRestrictions().getMinTargets(source, sa)) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
 
             // Activate +Loyalty planeswalker abilities even if they have no target (e.g. Vivien of the Arkbow),
@@ -493,9 +502,9 @@ public class CountersPutAi extends CountersAi {
                     && sa.isPwAbility()
                     && sa.getPayCosts().hasOnlySpecificCostType(CostPutCounter.class)
                     && sa.isTargetNumberValid()
-                    && sa.getTargets().isEmpty()
+                    && sa.getTargets().size() == 0
                     && ai.getGame().getPhaseHandler().is(PhaseType.MAIN2, ai)) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
 
             if (sourceName.equals("Abzan Charm")) {
@@ -517,11 +526,11 @@ public class CountersPutAi extends CountersAi {
                         }
                     }
                     if (left == 0) {
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
                     }
                     sa.resetTargets();
                 }
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
 
             // target loop
@@ -529,7 +538,7 @@ public class CountersPutAi extends CountersAi {
                 if (list.isEmpty()) {
                     if (!sa.isTargetNumberValid() || sa.getTargets().isEmpty()) {
                         sa.resetTargets();
-                        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                        return false;
                     } else {
                         // TODO is this good enough? for up to amounts?
                         break;
@@ -561,9 +570,10 @@ public class CountersPutAi extends CountersAi {
                                 // check if other choice will already be played
                                 increasesCharmOutcome = !choices.get(0).getTargets().isEmpty(); 
                             }
-                            if (source != null && !source.isSpell() || increasesCharmOutcome // does not cost a card or can buff charm for no expense
+                            if (!source.isSpell() || increasesCharmOutcome // does not cost a card or can buff charm for no expense
                                     || ph.getTurn() - source.getTurnInZone() >= source.getGame().getPlayers().size() * 2) {
-                                if (abCost == Cost.Zero || ph.is(PhaseType.END_OF_TURN) && ph.getPlayerTurn().isOpponentOf(ai)) {
+                                if (abCost == null || abCost == Cost.Zero
+                                        || (ph.is(PhaseType.END_OF_TURN) && ph.getPlayerTurn().isOpponentOf(ai))) {
                                     // only use at opponent EOT unless it is free
                                     choice = chooseBoonTarget(list, type);
                                 }
@@ -577,7 +587,7 @@ public class CountersPutAi extends CountersAi {
                 if (choice == null) { // can't find anything left
                     if (!sa.isTargetNumberValid() || sa.getTargets().isEmpty()) {
                         sa.resetTargets();
-                        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                        return false;
                     } else {
                         // TODO is this good enough? for up to amounts?
                         break;
@@ -593,79 +603,66 @@ public class CountersPutAi extends CountersAi {
                 choice = null;
             }
             if (sa.getTargets().isEmpty()) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
         } else {
             final List<Card> cards = AbilityUtils.getDefinedCards(source, sa.getParam("Defined"), sa);
             // Don't activate Curse abilities on my cards and non-curse abilities
             // on my opponents
             if (cards.isEmpty() || (cards.get(0).getController().isOpponentOf(ai) && !sa.isCurse())) {
-                return new AiAbilityDecision(0, AiPlayDecision.MissingNeededCards);
-            }
-
-            final int currCounters = cards.get(0).getCounters(CounterType.getType(type));
-
-            // adding counters would cause counter amount to overflow
-            if (Integer.MAX_VALUE - currCounters <= amount) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
-            if (type.equals("P1P1")) {
-                if (Integer.MAX_VALUE - cards.get(0).getNetPower() <= amount) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
-                if (Integer.MAX_VALUE - cards.get(0).getNetToughness() <= amount) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                }
+                return false;
             }
 
+            final int currCounters = cards.get(0).getCounters(CounterType.get(type));
             // each non +1/+1 counter on the card is a 10% chance of not
             // activating this ability.
 
             if (!(type.equals("P1P1") || type.equals("M1M1") || type.equals("ICE")) && (MyRandom.getRandom().nextFloat() < (.1 * currCounters))) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
             // Instant +1/+1
             if (type.equals("P1P1") && !isSorcerySpeed(sa, ai)) {
                 if (!hasSacCost && !(ph.getNextTurn() == ai && ph.is(PhaseType.END_OF_TURN) && abCost.isReusuableResource())) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false; // only if next turn and cost is reusable
                 }
             }
 
             // Useless since the card already has the keyword (or for another reason)
-            if (ComputerUtil.isUselessCounter(CounterType.getType(type), cards.get(0))) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            if (ComputerUtil.isUselessCounter(CounterType.get(type), cards.get(0))) {
+                return false;
             }
         }
 
         boolean immediately = ComputerUtil.playImmediately(ai, sa);
 
-        if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa, immediately)) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantAfford);
+        if (abCost != null && !ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa, immediately)) {
+            return false;
         }
 
         if (immediately) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
 
         if (!type.equals("P1P1") && !type.equals("M1M1") && !sa.hasParam("ActivationPhases")) {
             // Don't use non P1P1/M1M1 counters before main 2 if possible
             if (ph.getPhase().isBefore(PhaseType.MAIN2) && !ComputerUtil.castSpellInMain1(ai, sa)) {
-                return new AiAbilityDecision(0, AiPlayDecision.WaitForMain2);
+                return false;
             }
             if (ph.isPlayerTurn(ai) && !isSorcerySpeed(sa, ai)) {
-                return new AiAbilityDecision(0, AiPlayDecision.AnotherTime);
+                return false;
             }
         }
 
         if (ComputerUtil.waitForBlocking(sa)) {
-            return new AiAbilityDecision(0, AiPlayDecision.WaitForCombat);
+            return false;
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(final SpellAbility sa, Player ai) {
+    public boolean chkAIDrawback(final SpellAbility sa, Player ai) {
+        boolean chance = true;
         final Game game = ai.getGame();
         Card choice = null;
         final String type = sa.getParam("CounterType");
@@ -679,12 +676,14 @@ public class CountersPutAi extends CountersAi {
                 || (sa.getRootAbility().isTrigger() && !sa.getRootAbility().isOptionalTrigger());
 
         if (sa.usesTargeting()) {
-            CardCollection list;
+            CardCollection list = null;
+
             if (sa.isCurse()) {
                 list = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
             } else {
                 list = new CardCollection(ai.getCardsIn(ZoneType.Battlefield));
             }
+
             list = CardLists.getTargetableCards(list, sa);
 
             if (list.isEmpty() && isMandatoryTrigger) {
@@ -697,17 +696,18 @@ public class CountersPutAi extends CountersAi {
             while (sa.canAddMoreTarget()) {
                 if (list.isEmpty()) {
                     if (!sa.isTargetNumberValid()
-                            || sa.getTargets().isEmpty()) {
+                            || sa.getTargets().size() == 0) {
                         sa.resetTargets();
-                        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                        return false;
+                    } else {
+                        break;
                     }
-                    break;
                 }
 
                 if (sa.isCurse()) {
                     choice = chooseCursedTarget(list, type, amount, ai);
                 } else {
-                    CardCollection lands = CardLists.filter(list, CardPredicates.LANDS);
+                    CardCollection lands = CardLists.filter(list, CardPredicates.Presets.LANDS);
                     SpellAbility animate = sa.findSubAbilityByType(ApiType.Animate);
                     if (!lands.isEmpty() && animate != null) {
                         choice = ComputerUtilCard.getWorstLand(lands);
@@ -719,9 +719,9 @@ public class CountersPutAi extends CountersAi {
                 }
 
                 if (choice == null) { // can't find anything left
-                    if ((!sa.isTargetNumberValid()) || (sa.getTargets().isEmpty())) {
+                    if ((!sa.isTargetNumberValid()) || (sa.getTargets().size() == 0)) {
                         sa.resetTargets();
-                        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                        return false;
                     } else {
                         // TODO is this good enough? for up to amounts?
                         break;
@@ -736,14 +736,17 @@ public class CountersPutAi extends CountersAi {
             }
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return chance;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final SpellAbility root = sa.getRootAbility();
         final Card source = sa.getHostCard();
-        final String aiLogic = sa.getParam("AILogic");
+        final String aiLogic = sa.getParamOrDefault("AILogic", "");
+        // boolean chance = true;
+        boolean preferred = true;
+        CardCollection list;
         final String amountStr = sa.getParamOrDefault("CounterNum", "1");
         final boolean divided = sa.isDividedAsYouChoose();
         final int amount = AbilityUtils.calculateAmount(source, amountStr, sa);
@@ -762,10 +765,9 @@ public class CountersPutAi extends CountersAi {
         }
 
         if ("ChargeToBestCMC".equals(aiLogic)) {
-            if (mandatory) {
-                return new AiAbilityDecision(50, AiPlayDecision.MandatoryPlay);
-            }
-            return doChargeToCMCLogic(ai, sa);
+            return doChargeToCMCLogic(ai, sa) || mandatory;
+        } else if ("ChargeToBestOppControlledCMC".equals(aiLogic)) {
+            return doChargeToOppCtrlCMCLogic(ai, sa) || mandatory;
         }
 
         if (!sa.usesTargeting()) {
@@ -789,48 +791,50 @@ public class CountersPutAi extends CountersAi {
                 // things like Powder Keg, which are way too complex for the AI
             }
         } else if (sa.getTargetRestrictions().canOnlyTgtOpponent() && !sa.getTargetRestrictions().canTgtCreature()) {
-            PlayerCollection playerList = new PlayerCollection(IterableUtil.filter(
+            // can only target opponent
+            PlayerCollection playerList = new PlayerCollection(Iterables.filter(
                     sa.getTargetRestrictions().getAllCandidates(sa, true, true), Player.class));
 
             if (playerList.isEmpty()) {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                return false;
             }
 
             // try to choose player with less creatures
-            Player choice = playerList.min(PlayerPredicates.compareByZoneSize(ZoneType.Battlefield, CardPredicates.CREATURES));
+            Player choice = playerList.min(PlayerPredicates.compareByZoneSize(ZoneType.Battlefield, CardPredicates.Presets.CREATURES));
 
             if (choice != null) {
                 sa.getTargets().add(choice);
             }
         } else {
-            if ("Fight".equals(aiLogic) || "PowerDmg".equals(aiLogic)) {
+            String logic = sa.getParam("AILogic");
+            if ("Fight".equals(logic) || "PowerDmg".equals(logic)) {
                 int nPump = 0;
                 if (type.equals("P1P1")) {
                     nPump = amount;
                 }
-                AiAbilityDecision decision = FightAi.canFight(ai, sa, nPump, nPump);
-                if (decision.willingToPlay()) {
-                    return decision;
+                if (FightAi.canFightAi(ai, sa, nPump, nPump)) {
+                    return true;
                 }
             }
 
-            sa.resetTargets();
-
-            Iterable<Card> filteredField;
             if (sa.isCurse()) {
-                filteredField = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
+                list = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
             } else {
-                filteredField = ai.getCardsIn(ZoneType.Battlefield);
+                list = new CardCollection(ai.getCardsIn(ZoneType.Battlefield));
             }
-            CardCollection list = CardLists.getTargetableCards(filteredField, sa);
-            list = ComputerUtil.filterAITgts(sa, ai, list, false);
-            int totalTargets = list.size();
-            boolean preferred = true;
+            list = CardLists.getTargetableCards(list, sa);
 
+            // Filter AI-specific targets if provided
+            list = ComputerUtil.filterAITgts(sa, ai, list, false);
+
+            int totalTargets = list.size();
+
+            sa.resetTargets();
             while (sa.canAddMoreTarget()) {
                 if (mandatory) {
+                    // When things are mandatory, gotta handle a little differently
                     if ((list.isEmpty() || !preferred) && sa.isTargetNumberValid()) {
-                        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+                        return true;
                     }
 
                     if (list.isEmpty() && preferred) {
@@ -850,10 +854,10 @@ public class CountersPutAi extends CountersAi {
                 if (list.isEmpty()) {
                     // Not mandatory, or the the list was regenerated and is still empty,
                     // so return whether or not we found enough targets
-                    return new AiAbilityDecision(sa.isTargetNumberValid() ? 100 : 0, sa.isTargetNumberValid() ? AiPlayDecision.WillPlay : AiPlayDecision.CantPlayAi);
+                    return sa.isTargetNumberValid();
                 }
 
-                Card choice;
+                Card choice = null;
 
                 // Choose targets here:
                 if (sa.isCurse()) {
@@ -862,27 +866,33 @@ public class CountersPutAi extends CountersAi {
                         if (choice == null && mandatory) {
                             choice = Aggregates.random(list);
                         }
-                    } else if (type.equals("M1M1")) {
-                        choice = ComputerUtilCard.getWorstCreatureAI(list);
                     } else {
-                        choice = Aggregates.random(list);
+                        if (type.equals("M1M1")) {
+                            choice = ComputerUtilCard.getWorstCreatureAI(list);
+                        } else {
+                            choice = Aggregates.random(list);
+                        }
                     }
-                } else if (preferred) {
-                    list = ComputerUtil.getSafeTargets(ai, sa, list);
-                    choice = chooseBoonTarget(list, type);
-                    if (choice == null && mandatory) {
-                        choice = Aggregates.random(list);
-                    }
-                } else if (type.equals("P1P1")) {
-                    choice = ComputerUtilCard.getWorstCreatureAI(list);
                 } else {
-                    choice = Aggregates.random(list);
+                    if (preferred) {
+                        list = ComputerUtil.getSafeTargets(ai, sa, list);
+                        choice = chooseBoonTarget(list, type);
+                        if (choice == null && mandatory) {
+                            choice = Aggregates.random(list);
+                        }
+                    } else {
+                        if (type.equals("P1P1")) {
+                            choice = ComputerUtilCard.getWorstCreatureAI(list);
+                        } else {
+                            choice = Aggregates.random(list);
+                        }
+                    }
                 }
                 if (choice != null && divided) {
+                    int alloc = Math.max(amount / totalTargets, 1);
                     if (sa.getTargets().size() == Math.min(totalTargets, sa.getMaxTargets()) - 1) {
                         sa.addDividedAllocation(choice, left);
                     } else {
-                        int alloc = Math.max(amount / totalTargets, 1);
                         sa.addDividedAllocation(choice, alloc);
                         left -= alloc;
                     }
@@ -897,7 +907,7 @@ public class CountersPutAi extends CountersAi {
             }
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     @Override
@@ -952,8 +962,8 @@ public class CountersPutAi extends CountersAi {
     protected Card chooseSingleCard(final Player ai, SpellAbility sa, Iterable<Card> options, boolean isOptional, Player targetedPlayer, Map<String, Object> params) {
         // Bolster does use this
         // TODO need more or less logic there?
-        final CounterType m1m1 = CounterEnumType.M1M1;
-        final CounterType p1p1 = CounterEnumType.P1P1;
+        final CounterType m1m1 = CounterType.get(CounterEnumType.M1M1);
+        final CounterType p1p1 = CounterType.get(CounterEnumType.P1P1);
 
         // no logic if there is no options or no to choice
         if (!isOptional && Iterables.size(options) <= 1) {
@@ -972,7 +982,9 @@ public class CountersPutAi extends CountersAi {
         final String amountStr = sa.getParamOrDefault("CounterNum", "1");
         final int amount = AbilityUtils.calculateAmount(sa.getHostCard(), amountStr, sa);
 
-        if (sa.isCurse()) {
+        final boolean isCurse = sa.isCurse();
+
+        if (isCurse) {
             final CardCollection opponents = CardLists.filterControlledBy(options, ai.getOpponents());
 
             if (!opponents.isEmpty()) {
@@ -1069,10 +1081,11 @@ public class CountersPutAi extends CountersAi {
         Player ai = sa.getActivatingPlayer();
         GameEntity e = (GameEntity) params.get("Target");
         // for Card try to select not useless counter
-        if (e instanceof Card c) {
+        if (e instanceof Card) {
+            Card c = (Card) e;
             if (c.getController().isOpponentOf(ai)) {
-                if (options.contains(CounterEnumType.M1M1) && !c.hasKeyword(Keyword.UNDYING)) {
-                    return CounterEnumType.M1M1;
+                if (options.contains(CounterType.get(CounterEnumType.M1M1)) && !c.hasKeyword(Keyword.UNDYING)) {
+                    return CounterType.get(CounterEnumType.M1M1);
                 }
                 for (CounterType type : options) {
                     if (ComputerUtil.isNegativeCounter(type, c)) {
@@ -1086,14 +1099,15 @@ public class CountersPutAi extends CountersAi {
                     }
                 }
             }
-        } else if (e instanceof Player p) {
+        } else if (e instanceof Player) {
+            Player p = (Player) e;
             if (p.isOpponentOf(ai)) {
-                if (options.contains(CounterEnumType.POISON)) {
-                    return CounterEnumType.POISON;
+                if (options.contains(CounterType.get(CounterEnumType.POISON))) {
+                    return CounterType.get(CounterEnumType.POISON);
                 }
             } else {
-                if (options.contains(CounterEnumType.EXPERIENCE)) {
-                    return CounterEnumType.EXPERIENCE;
+                if (options.contains(CounterType.get(CounterEnumType.EXPERIENCE))) {
+                    return CounterType.get(CounterEnumType.EXPERIENCE);
                 }
             }
 
@@ -1101,7 +1115,7 @@ public class CountersPutAi extends CountersAi {
         return Iterables.getFirst(options, null);
     }
 
-    private AiAbilityDecision doMoveCounterLogic(final Player ai, SpellAbility sa, PhaseHandler ph) {
+    private boolean doMoveCounterLogic(final Player ai, SpellAbility sa, PhaseHandler ph) {
         // Spikes (Tempest)
 
         // Try not to do it unless at the end of opponent's turn or the creature is threatened
@@ -1114,7 +1128,7 @@ public class CountersPutAi extends CountersAi {
                 || (combat.isBlocking(source) && ComputerUtilCombat.blockerWouldBeDestroyed(ai, source, combat) && !ComputerUtilCombat.willKillAtLeastOne(ai, source, combat))));
 
         if (!(threatened || (ph.is(PhaseType.END_OF_TURN) && ph.getNextTurn() == ai))) {
-            return new AiAbilityDecision(0, AiPlayDecision.AnotherTime);
+            return false;
         }
 
         CardCollection targets = CardLists.getTargetableCards(ai.getCreaturesInPlay(), sa);
@@ -1132,45 +1146,45 @@ public class CountersPutAi extends CountersAi {
 
         if (bestTgt != null) {
             sa.getTargets().add(bestTgt);
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
 
-        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+        return false;
     }
 
-    private AiAbilityDecision doCombatAdaptLogic(Card source, int amount, Combat combat) {
+    private boolean doCombatAdaptLogic(Card source, int amount, Combat combat) {
         if (combat.isAttacking(source)) {
             if (!combat.isBlocked(source)) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             } else {
                 for (Card blockedBy : combat.getBlockers(source)) {
                     if (blockedBy.getNetToughness() > source.getNetPower()
                             && blockedBy.getNetToughness() <= source.getNetPower() + amount) {
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
                     }
                 }
 
                 int totBlkPower = Aggregates.sum(combat.getBlockers(source), Card::getNetPower);
                 if (source.getNetToughness() <= totBlkPower
                         && source.getNetToughness() + amount > totBlkPower) {
-                    return new AiAbilityDecision(100, AiPlayDecision.ImpactCombat);
+                    return true;
                 }
             }
         } else if (combat.isBlocking(source)) {
             for (Card blocked : combat.getAttackersBlockedBy(source)) {
                 if (blocked.getNetToughness() > source.getNetPower()
                         && blocked.getNetToughness() <= source.getNetPower() + amount) {
-                    return new AiAbilityDecision(100, AiPlayDecision.ImpactCombat);
+                    return true;
                 }
             }
 
             int totAtkPower = Aggregates.sum(combat.getAttackersBlockedBy(source), Card::getNetPower);
             if (source.getNetToughness() <= totAtkPower
                     && source.getNetToughness() + amount > totAtkPower) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
         }
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return false;
     }
 
     @Override
@@ -1181,9 +1195,9 @@ public class CountersPutAi extends CountersAi {
         return max;
     }
 
-    private AiAbilityDecision doChargeToCMCLogic(Player ai, SpellAbility sa) {
+    private boolean doChargeToCMCLogic(Player ai, SpellAbility sa) {
         Card source = sa.getHostCard();
-        CardCollectionView ownLib = CardLists.filter(ai.getCardsIn(ZoneType.Library), CardPredicates.CREATURES);
+        CardCollectionView ownLib = CardLists.filter(ai.getCardsIn(ZoneType.Library), CardPredicates.isType("Creature"));
         int numCtrs = source.getCounters(CounterEnumType.CHARGE);
         int maxCMC = Aggregates.max(ownLib, Card::getCMC);
         int optimalCMC = 0;
@@ -1196,15 +1210,12 @@ public class CountersPutAi extends CountersAi {
                 optimalCMC = cmc;
             }
         }
-        if (numCtrs < optimalCMC) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return numCtrs < optimalCMC;
     }
 
-    private AiAbilityDecision doChargeToOppCtrlCMCLogic(Player ai, SpellAbility sa) {
+    private boolean doChargeToOppCtrlCMCLogic(Player ai, SpellAbility sa) {
         Card source = sa.getHostCard();
-        CardCollectionView oppInPlay = CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Battlefield), CardPredicates.NONLAND_PERMANENTS);
+        CardCollectionView oppInPlay = CardLists.filter(ai.getOpponents().getCardsIn(ZoneType.Battlefield), CardPredicates.Presets.NONLAND_PERMANENTS);
         int numCtrs = source.getCounters(CounterEnumType.CHARGE);
         int maxCMC = Aggregates.max(oppInPlay, Card::getCMC);
         int optimalCMC = 0;
@@ -1216,11 +1227,6 @@ public class CountersPutAi extends CountersAi {
                 optimalCMC = cmc;
             }
         }
-        if (numCtrs < optimalCMC) {
-            // If the AI has less counters than the optimal CMC, it should play the ability.
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-        // If the AI has enough counters or more than the optimal CMC, it should not play the ability.
-        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+        return numCtrs < optimalCMC;
     }
 }

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

@@ -1,13 +1,16 @@
 package forge.ai.ability;
 
+import java.util.List;
+import java.util.Map;
+
 import com.google.common.collect.Lists;
-import forge.ai.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+
 import forge.ai.ComputerUtilCost;
 import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.card.CardLists;
+import forge.game.cost.Cost;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
@@ -16,15 +19,14 @@ import forge.game.spellability.AbilitySub;
 import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
-
-import java.util.List;
-import java.util.Map;
+import forge.util.MyRandom;
 
 public class CountersPutAllAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what the expected targets could be
+        final Cost abCost = sa.getPayCosts();
         final Card source = sa.getHostCard();
         List<Card> hList;
         List<Card> cList;
@@ -43,9 +45,28 @@ public class CountersPutAllAi extends SpellAbilityAi {
             cList = CardLists.getValidCards(ai.getCardsIn(ZoneType.Battlefield), valid, source.getController(), source, sa);
         }
 
+        if (abCost != null) {
+            // AI currently disabled for these costs
+            if (!ComputerUtilCost.checkLifeCost(ai, abCost, source, 8, sa)) {
+                return false;
+            }
+
+            if (!ComputerUtilCost.checkDiscardCost(ai, abCost, source, sa)) {
+                return false;
+            }
+
+            if (!ComputerUtilCost.checkSacrificeCost(ai, abCost, source, sa)) {
+                return false;
+            }
+        }
+
         if (logic.equals("AtEOTOrBlock")) {
             if (!ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN) && !ai.getGame().getPhaseHandler().is(PhaseType.COMBAT_DECLARE_BLOCKERS)) {
-                return new AiAbilityDecision(0, AiPlayDecision.AnotherTime);
+                return false;
+            }
+        } else if (logic.equals("AtOppEOT")) {
+            if (!(ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN) && ai.getGame().getPhaseHandler().getNextTurn() == ai)) {
+                return false;
             }
         }
 
@@ -68,23 +89,26 @@ public class CountersPutAllAi extends SpellAbilityAi {
             amount = AbilityUtils.calculateAmount(source, amountStr, sa);
         }
 
+        // prevent run-away activations - first time will always return true
+        boolean chance = MyRandom.getRandom().nextFloat() <= Math.pow(.6667, sa.getActivationsThisTurn());
+
         if (curse) {
             if (type.equals("M1M1")) {
                 final List<Card> killable = CardLists.filter(hList, c -> c.getNetToughness() <= amount);
-                if (killable.size() <= 2) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                if (!(killable.size() > 2)) {
+                    return false;
                 }
             } else {
                 // make sure compy doesn't harm his stuff more than human's
                 // stuff
                 if (cList.size() > hList.size()) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
             }
         } else {
             // human has more things that will benefit, don't play
             if (hList.size() >= cList.size()) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
 
             //Check for cards that could profit from the ability
@@ -102,21 +126,21 @@ public class CountersPutAllAi extends SpellAbilityAi {
                     }
                 }
                 if (!combatants) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                    return false;
                 }
             }
         }
 
         if (playReusable(ai, sa)) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return chance;
         }
 
-        return super.checkApiLogic(ai, sa);
+        return ((MyRandom.getRandom().nextFloat() < .6667) && chance);
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player ai) {
-        return canPlay(ai, sa);
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
+        return canPlayAI(ai, sa);
     }
     /* (non-Javadoc)
      * @see forge.card.ability.SpellAbilityAi#confirmAction(forge.game.player.Player, forge.card.spellability.SpellAbility, forge.game.player.PlayerActionConfirmMode, java.lang.String)
@@ -127,7 +151,7 @@ public class CountersPutAllAi extends SpellAbilityAi {
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
+    protected boolean doTriggerAINoCost(final Player aiPlayer, final SpellAbility sa, final boolean mandatory) {
         if (sa.usesTargeting()) {
             List<Player> players = Lists.newArrayList();
             if (!sa.isCurse()) {
@@ -145,23 +169,11 @@ public class CountersPutAllAi extends SpellAbilityAi {
                     preferred = (sa.isCurse() && p.isOpponentOf(aiPlayer)) || (!sa.isCurse() && p == aiPlayer);
                     sa.resetTargets();
                     sa.getTargets().add(p);
-                    if (preferred) {
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                    }
-
-                    if (mandatory) {
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                    } else {
-                        return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-                    }
+                    return preferred || mandatory;
                 }
             }
         }
 
-        if (mandatory) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        }
-
-        return canPlay(aiPlayer, sa);
+        return mandatory || canPlayAI(aiPlayer, sa);
     }
 }

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

@@ -17,11 +17,24 @@
  */
 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.*;
+
+import forge.ai.ComputerUtil;
+import forge.ai.ComputerUtilCard;
+import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+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.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.keyword.Keyword;
 import forge.game.player.Player;
 import forge.game.player.PlayerController.BinaryChoiceType;
@@ -29,10 +42,6 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
-import java.util.List;
-import java.util.Map;
-import java.util.function.Predicate;
-
 /**
  * <p>
  * AbilityFactory_PutOrRemoveCountersAi class.
@@ -50,13 +59,9 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
      * forge.game.spellability.SpellAbility)
      */
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+    protected boolean checkApiLogic(Player ai, SpellAbility sa) {
         if (sa.usesTargeting()) {
-            if (doTgt(ai, sa, false)) {
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-            } else {
-                return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
-            }
+            return doTgt(ai, sa, false);
         }
         return super.checkApiLogic(ai, sa);
     }
@@ -117,7 +122,7 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
                 // with one touch
                 CardCollection planeswalkerList = CardLists.filter(
                         CardLists.filterControlledBy(countersList, ai.getOpponents()),
-                        CardPredicates.PLANESWALKERS,
+                        CardPredicates.Presets.PLANESWALKERS,
                         CardPredicates.hasLessCounter(CounterEnumType.LOYALTY, amount));
 
                 if (!planeswalkerList.isEmpty()) {
@@ -182,27 +187,11 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         if (sa.usesTargeting()) {
-            if (doTgt(ai, sa, mandatory)) {
-                // if we can target, then we can play it
-                if (sa.isTargetNumberValid()) {
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-                } else {
-                    return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
-                }
-            } else {
-                // if we can't target, then we can't play it
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-            }
-        }
-        if (mandatory) {
-            // if mandatory, just play it
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-        } else {
-            // if not mandatory, check if we can play it
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return doTgt(ai, sa, mandatory);
         }
+        return mandatory;
     }
 
     /*
@@ -218,18 +207,18 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
         Card tgt = (Card) params.get("Target");
 
         // planeswalker has high priority for loyalty counters
-        if (tgt.isPlaneswalker() && options.contains(CounterEnumType.LOYALTY)) {
-            return CounterEnumType.LOYALTY;
+        if (tgt.isPlaneswalker() && options.contains(CounterType.get(CounterEnumType.LOYALTY))) {
+            return CounterType.get(CounterEnumType.LOYALTY);
         }
 
         if (tgt.getController().isOpponentOf(ai)) {
             // creatures with BaseToughness below or equal zero might be
             // killed if their counters are removed
             if (tgt.isCreature() && tgt.getBaseToughness() <= 0) {
-                if (options.contains(CounterEnumType.P1P1)) {
-                    return CounterEnumType.P1P1;
-                } else if (options.contains(CounterEnumType.M1M1)) {
-                    return CounterEnumType.M1M1;
+                if (options.contains(CounterType.get(CounterEnumType.P1P1))) {
+                    return CounterType.get(CounterEnumType.P1P1);
+                } else if (options.contains(CounterType.get(CounterEnumType.M1M1))) {
+                    return CounterType.get(CounterEnumType.M1M1);
                 }
             }
 
@@ -241,17 +230,17 @@ public class CountersPutOrRemoveAi extends SpellAbilityAi {
             }
         } else {
             // this counters are treat first to be removed
-            if ("Dark Depths".equals(tgt.getName()) && options.contains(CounterEnumType.ICE)) {
+            if ("Dark Depths".equals(tgt.getName()) && options.contains(CounterType.get(CounterEnumType.ICE))) {
                 CardCollectionView marit = ai.getCardsIn(ZoneType.Battlefield, "Marit Lage");
                 boolean maritEmpty = marit.isEmpty() || Iterables.contains(marit, (Predicate<Card>) Card::ignoreLegendRule);
 
                 if (maritEmpty) {
-                    return CounterEnumType.ICE;
+                    return CounterType.get(CounterEnumType.ICE);
                 }
-            } else if (tgt.hasKeyword(Keyword.UNDYING) && options.contains(CounterEnumType.P1P1)) {
-                return CounterEnumType.P1P1;
-            } else if (tgt.hasKeyword(Keyword.PERSIST) && options.contains(CounterEnumType.M1M1)) {
-                return CounterEnumType.M1M1;
+            } else if (tgt.hasKeyword(Keyword.UNDYING) && options.contains(CounterType.get(CounterEnumType.P1P1))) {
+                return CounterType.get(CounterEnumType.P1P1);
+            } else if (tgt.hasKeyword(Keyword.PERSIST) && options.contains(CounterType.get(CounterEnumType.M1M1))) {
+                return CounterType.get(CounterEnumType.M1M1);
             }
 
             // fallback logic, select positive counter to add more

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

@@ -1,8 +1,12 @@
 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.AiAbilityDecision;
-import forge.ai.AiPlayDecision;
+
 import forge.ai.ComputerUtil;
 import forge.ai.ComputerUtilCard;
 import forge.ai.ComputerUtilCost;
@@ -10,7 +14,13 @@ import forge.ai.SpellAbilityAi;
 import forge.game.Game;
 import forge.game.GameEntity;
 import forge.game.ability.AbilityUtils;
-import forge.game.card.*;
+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.CounterEnumType;
+import forge.game.card.CounterType;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseHandler;
 import forge.game.phase.PhaseType;
@@ -19,12 +29,16 @@ import forge.game.spellability.SpellAbility;
 import forge.game.spellability.TargetRestrictions;
 import forge.game.zone.ZoneType;
 
-import java.util.List;
-import java.util.Map;
-import java.util.function.Predicate;
-
 public class CountersRemoveAi extends SpellAbilityAi {
 
+    @Override
+    protected boolean canPlayWithoutRestrict(final Player ai, final SpellAbility sa) {
+        if ("Always".equals(sa.getParam("AILogic"))) {
+            return true;
+        }
+        return super.canPlayWithoutRestrict(ai, sa);
+    }
+
     /*
      * (non-Javadoc)
      *
@@ -42,6 +56,24 @@ public class CountersRemoveAi extends SpellAbilityAi {
         return super.checkPhaseRestrictions(ai, sa, ph);
     }
 
+    /*
+     * (non-Javadoc)
+     *
+     * @see
+     * forge.ai.SpellAbilityAi#checkPhaseRestrictions(forge.game.player.Player,
+     * forge.game.spellability.SpellAbility, forge.game.phase.PhaseHandler,
+     * java.lang.String)
+     */
+    @Override
+    protected boolean checkPhaseRestrictions(Player ai, SpellAbility sa, PhaseHandler ph, String logic) {
+        if ("EndOfOpponentsTurn".equals(logic)) {
+            if (!ph.is(PhaseType.END_OF_TURN) || !ph.getNextTurn().equals(ai)) {
+                return false;
+            }
+        }
+        return super.checkPhaseRestrictions(ai, sa, ph, logic);
+    }
+
     /*
      * (non-Javadoc)
      *
@@ -49,7 +81,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
      * forge.game.spellability.SpellAbility)
      */
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+    protected boolean checkApiLogic(Player ai, SpellAbility sa) {
         final String type = sa.getParam("CounterType");
 
         if (sa.usesTargeting()) {
@@ -59,14 +91,14 @@ public class CountersRemoveAi extends SpellAbilityAi {
         if (!type.matches("Any") && !type.matches("All")) {
             final int currCounters = sa.getHostCard().getCounters(CounterType.getType(type));
             if (currCounters < 1) {
-                return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+                return false;
             }
         }
 
         return super.checkApiLogic(ai, sa);
     }
 
-    private AiAbilityDecision doTgt(Player ai, SpellAbility sa, boolean mandatory) {
+    private boolean doTgt(Player ai, SpellAbility sa, boolean mandatory) {
         final Card source = sa.getHostCard();
         final Game game = ai.getGame();
 
@@ -79,7 +111,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
         CardCollection list = CardLists.getTargetableCards(game.getCardsIn(tgt.getZone()), sa);
 
         if (list.isEmpty()) {
-            return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+            return false;
         }
 
         // Filter AI-specific targets if provided
@@ -97,7 +129,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
                         CardPredicates.hasCounter(CounterEnumType.ICE, 3));
                 if (!depthsList.isEmpty()) {
                     sa.getTargets().add(depthsList.getFirst());
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
 
@@ -105,12 +137,12 @@ public class CountersRemoveAi extends SpellAbilityAi {
             list = ai.getOpponents().getCardsIn(ZoneType.Battlefield);
             list = CardLists.filter(list, CardPredicates.isTargetableBy(sa));
 
-            CardCollection planeswalkerList = CardLists.filter(list, CardPredicates.PLANESWALKERS,
+            CardCollection planeswalkerList = CardLists.filter(list, CardPredicates.Presets.PLANESWALKERS,
                     CardPredicates.hasCounter(CounterEnumType.LOYALTY, 5));
 
             if (!planeswalkerList.isEmpty()) {
                 sa.getTargets().add(ComputerUtilCard.getBestPlaneswalkerAI(planeswalkerList));
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
         } else if (type.matches("Any")) {
             // variable amount for Hex Parasite
@@ -120,7 +152,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
                 final int manaLeft = ComputerUtilCost.getMaxXValue(sa, ai, sa.isTrigger());
 
                 if (manaLeft == 0) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantAffordX);
+                    return false;
                 }
                 amount = manaLeft;
                 xPay = true;
@@ -142,7 +174,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
                         if (xPay) {
                             sa.setXManaCostPaid(ice);
                         }
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
                     }
                 }
             }
@@ -152,7 +184,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
             list = CardLists.filter(list, CardPredicates.isTargetableBy(sa));
 
             CardCollection planeswalkerList = CardLists.filter(list,
-                    CardPredicates.PLANESWALKERS.and(CardPredicates.isControlledByAnyOf(ai.getOpponents())),
+                    Predicates.and(CardPredicates.Presets.PLANESWALKERS, CardPredicates.isControlledByAnyOf(ai.getOpponents())),
                     CardPredicates.hasLessCounter(CounterEnumType.LOYALTY, amount));
 
             if (!planeswalkerList.isEmpty()) {
@@ -161,7 +193,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
                 if (xPay) {
                     sa.setXManaCostPaid(best.getCurrentLoyalty());
                 }
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
 
             // some rules only for amount = 1
@@ -178,7 +210,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
 
                 if (!aiM1M1List.isEmpty()) {
                     sa.getTargets().add(ComputerUtilCard.getBestCreatureAI(aiM1M1List));
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
 
                 // do as P1P1 part
@@ -187,18 +219,18 @@ public class CountersRemoveAi extends SpellAbilityAi {
 
                 if (!aiUndyingList.isEmpty()) {
                     sa.getTargets().add(ComputerUtilCard.getBestCreatureAI(aiUndyingList));
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
   
                 // TODO stun counters with canRemoveCounters check
 
                 // remove P1P1 counters from opposing creatures
                 CardCollection oppP1P1List = CardLists.filter(list,
-                        CardPredicates.CREATURES.and(CardPredicates.isControlledByAnyOf(ai.getOpponents())),
+                        Predicates.and(CardPredicates.Presets.CREATURES, CardPredicates.isControlledByAnyOf(ai.getOpponents())),
                         CardPredicates.hasCounter(CounterEnumType.P1P1));
                 if (!oppP1P1List.isEmpty()) {
                     sa.getTargets().add(ComputerUtilCard.getBestCreatureAI(oppP1P1List));
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
 
                 // fallback to remove any counter from opponent
@@ -210,7 +242,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
                     for (final CounterType aType : best.getCounters().keySet()) {
                         if (!ComputerUtil.isNegativeCounter(aType, best)) {
                             sa.getTargets().add(best);
-                            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                            return true;
                         }
                     }
                 }
@@ -231,7 +263,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
 
             if (!aiList.isEmpty()) {
                 sa.getTargets().add(ComputerUtilCard.getBestCreatureAI(aiList));
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
         } else if (type.equals("P1P1")) {
             // no special amount for that one yet
@@ -249,7 +281,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
                 }
                 if (!aiList.isEmpty()) {
                     sa.getTargets().add(ComputerUtilCard.getBestCreatureAI(aiList));
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
 
@@ -263,7 +295,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
 
                 if (!oppList.isEmpty()) {
                     sa.getTargets().add(ComputerUtilCard.getWorstCreatureAI(oppList));
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
         } else if (type.equals("TIME")) {
@@ -274,7 +306,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
                 final int manaLeft = ComputerUtilCost.getMaxXValue(sa, ai, sa.isTrigger());
 
                 if (manaLeft == 0) {
-                    return new AiAbilityDecision(0, AiPlayDecision.CantAffordX);
+                    return false;
                 }
                 amount = manaLeft;
                 xPay = true;
@@ -292,7 +324,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
                 if (xPay) {
                     sa.setXManaCostPaid(timeCount);
                 }
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
         }
         if (mandatory) {
@@ -301,7 +333,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
                 CardCollection adaptCreats = CardLists.filter(list, CardPredicates.hasKeyword(Keyword.ADAPT));
                 if (!adaptCreats.isEmpty()) {
                     sa.getTargets().add(ComputerUtilCard.getWorstAI(adaptCreats));
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
 
                 // Outlast nice target
@@ -312,27 +344,26 @@ public class CountersRemoveAi extends SpellAbilityAi {
 
                     if (!betterTargets.isEmpty()) {
                         sa.getTargets().add(ComputerUtilCard.getWorstAI(betterTargets));
-                        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                        return true;
                     }
 
                     sa.getTargets().add(ComputerUtilCard.getWorstAI(outlastCreats));
-                    return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                    return true;
                 }
             }
 
             sa.getTargets().add(ComputerUtilCard.getWorstAI(list));
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
-        return new AiAbilityDecision(0, AiPlayDecision.TargetingFailed);
+        return false;
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player aiPlayer, SpellAbility sa, boolean mandatory) {
         if (sa.usesTargeting()) {
             return doTgt(aiPlayer, sa, mandatory);
         }
-        return mandatory ? new AiAbilityDecision(100, AiPlayDecision.MandatoryPlay)
-                         : new AiAbilityDecision(0, AiPlayDecision.CantPlaySa);
+        return mandatory;
     }
 
     /*
@@ -346,7 +377,8 @@ public class CountersRemoveAi extends SpellAbilityAi {
         GameEntity target = (GameEntity) params.get("Target");
         CounterType type = (CounterType) params.get("CounterType");
 
-        if (target instanceof Card targetCard) {
+        if (target instanceof Card) {
+            Card targetCard = (Card) target;
             if (targetCard.getController().isOpponentOf(player)) {
                 return !ComputerUtil.isNegativeCounter(type, targetCard) ? max : min;
             } else {
@@ -357,7 +389,8 @@ public class CountersRemoveAi extends SpellAbilityAi {
 
                 return ComputerUtil.isNegativeCounter(type, targetCard) ? max : min;
             }
-        } else if (target instanceof Player targetPlayer) {
+        } else if (target instanceof Player) {
+            Player targetPlayer = (Player) target;
             if (targetPlayer.isOpponentOf(player)) {
                 return !type.is(CounterEnumType.POISON) ? max : min;
             } else {
@@ -384,7 +417,7 @@ public class CountersRemoveAi extends SpellAbilityAi {
             if (targetCard.getController().isOpponentOf(ai)) {
                 // if its a Planeswalker try to remove Loyality first
                 if (targetCard.isPlaneswalker()) {
-                    return CounterEnumType.LOYALTY;
+                    return CounterType.get(CounterEnumType.LOYALTY);
                 }
                 for (CounterType type : options) {
                     if (!ComputerUtil.isNegativeCounter(type, targetCard)) {
@@ -392,10 +425,10 @@ public class CountersRemoveAi extends SpellAbilityAi {
                     }
                 }
             } else {
-                if (options.contains(CounterEnumType.M1M1) && targetCard.hasKeyword(Keyword.PERSIST)) {
-                    return CounterEnumType.M1M1;
-                } else if (options.contains(CounterEnumType.P1P1) && targetCard.hasKeyword(Keyword.UNDYING)) {
-                    return CounterEnumType.P1P1;
+                if (options.contains(CounterType.get(CounterEnumType.M1M1)) && targetCard.hasKeyword(Keyword.PERSIST)) {
+                    return CounterType.get(CounterEnumType.M1M1);
+                } else if (options.contains(CounterType.get(CounterEnumType.P1P1)) && targetCard.hasKeyword(Keyword.UNDYING)) {
+                    return CounterType.get(CounterEnumType.P1P1);
                 }
                 for (CounterType type : options) {
                     if (ComputerUtil.isNegativeCounter(type, targetCard)) {

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

@@ -1,28 +1,46 @@
 package forge.ai.ability;
 
-import forge.ai.*;
+import com.google.common.base.Predicate;
+
+import forge.ai.ComputerUtilCard;
+import forge.ai.ComputerUtilCombat;
+import forge.ai.ComputerUtilCost;
+import forge.ai.ComputerUtilMana;
+import forge.ai.SpellAbilityAi;
 import forge.game.ability.AbilityUtils;
 import forge.game.card.Card;
 import forge.game.card.CardCollection;
 import forge.game.card.CardLists;
+import forge.game.cost.Cost;
 import forge.game.keyword.Keyword;
 import forge.game.phase.PhaseType;
 import forge.game.player.Player;
 import forge.game.spellability.SpellAbility;
 import forge.game.zone.ZoneType;
-
-import java.util.function.Predicate;
+import forge.util.MyRandom;
 
 public class  DamageAllAi extends SpellAbilityAi {
     @Override
-    protected AiAbilityDecision checkApiLogic(Player ai, SpellAbility sa) {
+    protected boolean canPlayAI(Player ai, SpellAbility sa) {
         // AI needs to be expanded, since this function can be pretty complex
         // based on what the expected targets could be
         final Card source = sa.getHostCard();
 
+        // prevent run-away activations - first time will always return true
+        if (MyRandom.getRandom().nextFloat() > Math.pow(.9, sa.getActivationsThisTurn())) {
+            return false;
+        }
+        // abCost stuff that should probably be centralized...
+        final Cost abCost = sa.getPayCosts();
+        if (abCost != null) {
+            // AI currently disabled for some costs
+            if (!ComputerUtilCost.checkLifeCost(ai, abCost, source, 4, sa)) {
+                return false;
+            }
+        }
         // wait until stack is empty (prevents duplicate kills)
         if (!ai.getGame().getStack().isEmpty()) {
-            return new AiAbilityDecision(0, AiPlayDecision.StackNotEmpty);
+            return false;
         }
 
         int x = -1;
@@ -37,15 +55,11 @@ public class  DamageAllAi extends SpellAbilityAi {
         if (x == -1) {
             if (determineOppToKill(ai, sa, source, dmg) != null) {
                 // we already know we can kill a player, so go for it
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
             // look for other value in this (damaging creatures or
             // creatures + player, e.g. Pestilence, etc.)
-             if (evaluateDamageAll(ai, sa, source, dmg) > 0) {
-                 return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
-             } else {
-                 return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
-             }
+            return evaluateDamageAll(ai, sa, source, dmg) > 0;
         } else {
             int best = -1, best_x = -1;
             Player bestOpp = determineOppToKill(ai, sa, source, x);
@@ -71,9 +85,9 @@ public class  DamageAllAi extends SpellAbilityAi {
                 if (sa.getSVar(damage).equals("Count$xPaid")) {
                     sa.setXManaCostPaid(best_x);
                 }
-                return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+                return true;
             }
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
     }
 
@@ -133,9 +147,9 @@ public class  DamageAllAi extends SpellAbilityAi {
                     if (ComputerUtilCombat.predictDamageTo(opp, dmg, source, false) > 0) {
                         // When using Pestilence to hurt players, do it at
                         // the end of the opponent's turn only
-                        if (!"DmgAllCreaturesAndPlayers".equals(sa.getParam("AILogic"))
-                                || (ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN)
-                                && !ai.getGame().getPhaseHandler().isPlayerTurn(ai)))
+                        if ((!"DmgAllCreaturesAndPlayers".equals(sa.getParam("AILogic")))
+                                || ((ai.getGame().getPhaseHandler().is(PhaseType.END_OF_TURN)
+                                && (ai.getGame().getNonactivePlayers().contains(ai)))))
                         // Need further improvement : if able to kill immediately with repeated activations, do not wait
                         // for phases! Will also need to implement considering repeated activations for killed creatures!
                         // || (ai.sa.getPayCosts(). ??? )
@@ -175,7 +189,7 @@ public class  DamageAllAi extends SpellAbilityAi {
     }
 
     @Override
-    public AiAbilityDecision chkDrawback(SpellAbility sa, Player ai) {
+    public boolean chkAIDrawback(SpellAbility sa, Player ai) {
         final Card source = sa.getHostCard();
         final String validP = sa.getParamOrDefault("ValidPlayers", "");
 
@@ -201,21 +215,21 @@ public class  DamageAllAi extends SpellAbilityAi {
         }
         // Don't get yourself killed
         if (validP.equals("Player") && (ai.getLife() <= ComputerUtilCombat.predictDamageTo(ai, dmg, source, false))) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         // if we can kill human, do it
         if ((validP.equals("Player") || validP.equals("Opponent") || validP.contains("Targeted"))
                 && (enemy.getLife() <= ComputerUtilCombat.predictDamageTo(enemy, dmg, source, false))) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
 
         if (!computerList.isEmpty() && ComputerUtilCard.evaluateCreatureList(computerList) > ComputerUtilCard
                 .evaluateCreatureList(humanList)) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 
     /**
@@ -248,7 +262,7 @@ public class  DamageAllAi extends SpellAbilityAi {
     }
 
     @Override
-    protected AiAbilityDecision doTriggerNoCost(Player ai, SpellAbility sa, boolean mandatory) {
+    protected boolean doTriggerAINoCost(Player ai, SpellAbility sa, boolean mandatory) {
         final Card source = sa.getHostCard();
         final String validP = sa.getParamOrDefault("ValidPlayers", "");
 
@@ -277,24 +291,24 @@ public class  DamageAllAi extends SpellAbilityAi {
 
         // If it's not mandatory check a few things
         if (mandatory) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
         // Don't get yourself killed
         if (validP.equals("Player") && (ai.getLife() <= ComputerUtilCombat.predictDamageTo(ai, dmg, source, false))) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
         // if we can kill human, do it
         if ((validP.equals("Player") || validP.contains("Opponent") || validP.contains("Targeted"))
                 && (enemy.getLife() <= ComputerUtilCombat.predictDamageTo(enemy, dmg, source, false))) {
-            return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+            return true;
         }
 
         if (!computerList.isEmpty() && ComputerUtilCard.evaluateCreatureList(computerList) + 50 >= ComputerUtilCard
                 .evaluateCreatureList(humanList)) {
-            return new AiAbilityDecision(0, AiPlayDecision.CantPlayAi);
+            return false;
         }
 
-        return new AiAbilityDecision(100, AiPlayDecision.WillPlay);
+        return true;
     }
 }