From db42b7fffd1fed7ef4d4cd81080f6b0ede9f910c Mon Sep 17 00:00:00 2001 From: BetaSteward Date: Sat, 20 Mar 2010 16:44:53 +0000 Subject: [PATCH] ... --- .../ai/simulators/CombatGroupSimulator.java | 175 ++++++++++++++++++ .../mage/ai/simulators/CombatSimulator.java | 115 ++++++++++++ .../mage/ai/simulators/CreatureSimulator.java | 68 +++++++ 3 files changed, 358 insertions(+) create mode 100644 Mage.AI/src/mage/ai/simulators/CombatGroupSimulator.java create mode 100644 Mage.AI/src/mage/ai/simulators/CombatSimulator.java create mode 100644 Mage.AI/src/mage/ai/simulators/CreatureSimulator.java diff --git a/Mage.AI/src/mage/ai/simulators/CombatGroupSimulator.java b/Mage.AI/src/mage/ai/simulators/CombatGroupSimulator.java new file mode 100644 index 00000000000..146ec0a373f --- /dev/null +++ b/Mage.AI/src/mage/ai/simulators/CombatGroupSimulator.java @@ -0,0 +1,175 @@ +/* + * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of BetaSteward_at_googlemail.com. + */ + +package mage.ai.simulators; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import mage.game.Game; +import mage.game.permanent.Permanent; + +/** + * + * @author BetaSteward_at_googlemail.com + */ +public class CombatGroupSimulator implements Serializable { + public List attackers = new ArrayList(); + public List blockers = new ArrayList(); + public UUID defenderId; + public boolean defenderIsPlaneswalker; + public int unblockedDamage; + private CreatureSimulator attacker; + + public CombatGroupSimulator(UUID defenderId, List attackers, List blockers, Game game) { + this.defenderId = defenderId; + for (UUID attackerId: attackers) { + Permanent permanent = game.getPermanent(attackerId); + this.attackers.add(new CreatureSimulator(permanent)); + } + for (UUID blockerId: blockers) { + Permanent permanent = game.getPermanent(blockerId); + this.blockers.add(new CreatureSimulator(permanent)); + } + //NOTE: assumes no banding + attacker = this.attackers.get(0); + } + + private boolean hasFirstOrDoubleStrike() { + for (CreatureSimulator creature: attackers) { + if (creature.hasDoubleStrike || creature.hasFirstStrike) + return true; + } + for (CreatureSimulator creature: blockers) { + if (creature.hasDoubleStrike || creature.hasFirstStrike) + return true; + } + return false; + } + + public boolean canBlock(Permanent blocker, Game game) { + return blocker.canBlock(attacker.id, game); + } + + public void simulateCombat() { + unblockedDamage = 0; + + if (hasFirstOrDoubleStrike()) + assignDamage(true); + assignDamage(false); + } + + private void assignDamage(boolean first) { + if (blockers.size() == 0) { + if (canDamage(attacker, first)) + unblockedDamage += attacker.power; + } + else if (blockers.size() == 1) { + CreatureSimulator blocker = blockers.get(0); + if (canDamage(attacker, first)) { + if (attacker.hasTrample) { + int lethalDamage = blocker.getLethalDamage(); + if (attacker.power > lethalDamage) { + blocker.damage += lethalDamage; + unblockedDamage += attacker.power - lethalDamage; + } + else { + blocker.damage += attacker.power; + } + } + } + if (canDamage(blocker, first)) { + attacker.damage += blocker.power; + } + } + else { + int damage = attacker.power; + for (CreatureSimulator blocker: blockers) { + if (damage > 0 && canDamage(attacker, first)) { + int lethalDamage = blocker.getLethalDamage(); + if (damage > lethalDamage) { + blocker.damage += lethalDamage; + damage -= lethalDamage; + } + else { + blocker.damage += damage; + damage = 0; + } + } + if (canDamage(blocker, first)) { + attacker.damage += blocker.power; + } + } + if (damage > 0) { + if (attacker.hasTrample) { + unblockedDamage += damage; + } + else { + blockers.get(0).damage += damage; + } + } + } + } + + private boolean canDamage(CreatureSimulator creature, boolean first) { + if (first && (creature.hasFirstStrike || creature.hasDoubleStrike)) + return true; + if (!first && (!creature.hasFirstStrike || creature.hasDoubleStrike)) + return true; + return false; + } + + /** + * returns 3 attacker survives blockers destroyed + * returns 2 both destroyed + * returns 1 both survive + * returns 0 attacker destroyed blockers survive + * + * @return int + */ + public int evaluateCombat() { + int survivingBlockers = 0; + for (CreatureSimulator blocker: blockers) { + if (blocker.damage < blocker.toughness) + survivingBlockers++; + } + if (attacker.isDead()) { + if (survivingBlockers > 0) { + return 0; + } + return 2; + } + else { + if (survivingBlockers > 0) { + return 1; + } + return 3; + } + } +} diff --git a/Mage.AI/src/mage/ai/simulators/CombatSimulator.java b/Mage.AI/src/mage/ai/simulators/CombatSimulator.java new file mode 100644 index 00000000000..b41dd81a321 --- /dev/null +++ b/Mage.AI/src/mage/ai/simulators/CombatSimulator.java @@ -0,0 +1,115 @@ +/* + * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of BetaSteward_at_googlemail.com. + */ + +package mage.ai.simulators; + +import java.io.Serializable; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.UUID; +import mage.game.Game; +import mage.game.combat.CombatGroup; +import mage.game.permanent.Permanent; +import mage.players.Player; + +/** + * + * @author BetaSteward_at_googlemail.com + */ +public class CombatSimulator implements Serializable { + + public List groups = new ArrayList(); + public List defenders = new ArrayList(); + public Map playersLife = new HashMap(); + public Map planeswalkerLoyalty = new HashMap(); + public UUID attackerId; + public int rating = 0; + + public static CombatSimulator load(Game game) { + CombatSimulator simCombat = new CombatSimulator(); + for (CombatGroup group: game.getCombat().getGroups()) { + simCombat.groups.add(new CombatGroupSimulator(group.getDefenderId(), group.getAttackers(), group.getBlockers(), game)); + } + for (UUID defenderId: game.getCombat().getDefenders()) { + simCombat.defenders.add(defenderId); + Player player = game.getPlayer(defenderId); + if (player != null) { + simCombat.playersLife.put(defenderId, player.getLife()); + } + else { + Permanent permanent = game.getPermanent(defenderId); + simCombat.planeswalkerLoyalty.put(defenderId, permanent.getLoyalty().getValue()); + } + } + return simCombat; + } + + public CombatSimulator() {} + + public void clear() { + groups.clear(); + defenders.clear(); + attackerId = null; + } + + public void simulate() { + for (CombatGroupSimulator group: groups) { + group.simulateCombat(); + } + } + + public int evaluate() { + Map damage = new HashMap(); + int result = 0; + for (CombatGroupSimulator group: groups) { + if (!damage.containsKey(group.defenderId)) { + damage.put(group.defenderId, group.unblockedDamage); + } + else { + damage.put(group.defenderId, damage.get(group.defenderId) + group.unblockedDamage); + } + } + for (Entry entry: playersLife.entrySet()) { + if (entry.getValue() <= damage.get(entry.getKey())) { + //TODO: check for protection + //NOTE: not applicable for mulitplayer games + return Integer.MAX_VALUE; + } + } + + for (CombatGroupSimulator group: groups) { + result += group.evaluateCombat(); + } + + rating = result; + return result; + } +} diff --git a/Mage.AI/src/mage/ai/simulators/CreatureSimulator.java b/Mage.AI/src/mage/ai/simulators/CreatureSimulator.java new file mode 100644 index 00000000000..cfc1bb86a11 --- /dev/null +++ b/Mage.AI/src/mage/ai/simulators/CreatureSimulator.java @@ -0,0 +1,68 @@ +/* + * Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of BetaSteward_at_googlemail.com. + */ + +package mage.ai.simulators; + +import java.io.Serializable; +import java.util.UUID; +import mage.abilities.keyword.DoubleStrikeAbility; +import mage.abilities.keyword.FirstStrikeAbility; +import mage.abilities.keyword.TrampleAbility; +import mage.game.permanent.Permanent; + +/** + * + * @author BetaSteward_at_googlemail.com + */ +public class CreatureSimulator implements Serializable { + public UUID id; + public int damage; + public int power; + public int toughness; + public boolean hasFirstStrike; + public boolean hasDoubleStrike; + public boolean hasTrample; + + public CreatureSimulator(Permanent permanent) { + this.id = permanent.getId(); + this.damage = permanent.getDamage(); + this.power = permanent.getPower().getValue(); + this.toughness = permanent.getToughness().getValue(); + this.hasDoubleStrike = permanent.getAbilities().containsKey(DoubleStrikeAbility.getInstance().getId()); + this.hasFirstStrike = permanent.getAbilities().containsKey(FirstStrikeAbility.getInstance().getId()); + this.hasTrample = permanent.getAbilities().containsKey(TrampleAbility.getInstance().getId()); + } + + public boolean isDead() { + return damage >= toughness; + } + + public int getLethalDamage() { + return toughness - damage; + } +}