Overhauled assignment definitions

- Assignments now require 3 flags: whether an assignment is to ignore existing assignments (false for actions, false for freeps assignments, true for shadow assignments, true for mordor assassin), whether an assignment is to ignore defender bonuses (true for actions, false for freeps assignments, true for shadow assignments, true for mordor assassin), and whether allies are to be considered valid targets (false for everything except for certain abilities)

gemp-lotr/gemp-lotr-cards/src/main/resources/cards/unofficial/pc/setV02/V2-Isengard.hjson

@@ -213,6 +213,7 @@
 						type: AssignFpCharacterToSkirmish
 						fpCharacter: choose(or(ally,and(unbound,companion)))
 						minion: choose(uruk-hai, MaxTwilight(memory(removed)))
+						ignoreAllyLocation: true
 					}
 				}
 			]

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/cards/build/field/effect/appender/AssignFpCharacterToSkirmish.java

@@ -21,7 +21,8 @@ import java.util.Collection;
 public class AssignFpCharacterToSkirmish implements EffectAppenderProducer {
     @Override
     public EffectAppender createEffectAppender(JSONObject effectObject, CardGenerationEnvironment environment) throws InvalidCardDefinitionException {
-        FieldUtils.validateAllowedFields(effectObject, "player", "fpCharacter", "minion", "memorizeMinion", "memorizeFPCharacter", "ignoreExistingAssignments", "preventCost", "preventText", "insteadEffect");
+        FieldUtils.validateAllowedFields(effectObject, "player", "fpCharacter", "minion", "memorizeMinion",
+                "memorizeFPCharacter", "ignoreExistingAssignments", "ignoreDefender", "ignoreAllyLocation", "preventCost", "preventText", "insteadEffect");
 
         final String player = FieldUtils.getString(effectObject.get("player"), "player", "you");
         final String fpCharacter = FieldUtils.getString(effectObject.get("fpCharacter"), "fpCharacter", "choose(any)");
@@ -40,6 +41,8 @@ public class AssignFpCharacterToSkirmish implements EffectAppenderProducer {
         final String minionMemory = FieldUtils.getString(effectObject.get("memorizeMinion"), "memorizeMinion", "_tempMinion");
         final String fpCharacterMemory = FieldUtils.getString(effectObject.get("memorizeFPCharacter"), "memorizeFPCharacter", "_tempFpCharacter");
         final boolean ignoreExistingAssignments = FieldUtils.getBoolean(effectObject.get("ignoreExistingAssignments"), "ignoreExistingAssignments", false);
+        final boolean ignoreDefender = FieldUtils.getBoolean(effectObject.get("ignoreDefender"), "ignoreDefender", true);
+        final boolean ignoreAllyLocation = FieldUtils.getBoolean(effectObject.get("ignoreAllyLocation"), "ignoreAllyLocation", false);
 
         final PlayerSource playerSource = PlayerResolver.resolvePlayer(player);
 
@@ -52,7 +55,7 @@ public class AssignFpCharacterToSkirmish implements EffectAppenderProducer {
                             final String assigningPlayer = playerSource.getPlayer(actionContext);
                             Side assigningSide = GameUtils.getSide(actionContext.getGame(), assigningPlayer);
                             final Filterable filter = minionFilter.getFilterable(actionContext);
-                            return Filters.assignableToSkirmishAgainst(assigningSide, filter, ignoreExistingAssignments, false);
+                            return Filters.assignableToSkirmishAgainst(assigningSide, filter, ignoreExistingAssignments, ignoreDefender, ignoreAllyLocation);
                         }, fpCharacterMemory, player, "Choose character to assign to skirmish", environment));
         result.addEffectAppender(
                 CardResolver.resolveCard(minion,
@@ -60,7 +63,7 @@ public class AssignFpCharacterToSkirmish implements EffectAppenderProducer {
                             final String assigningPlayer = playerSource.getPlayer(actionContext);
                             Side assigningSide = GameUtils.getSide(actionContext.getGame(), assigningPlayer);
                             final Collection<? extends PhysicalCard> fpChar = actionContext.getCardsFromMemory(fpCharacterMemory);
-                            return Filters.assignableToSkirmishAgainst(assigningSide, Filters.in(fpChar), ignoreExistingAssignments, false);
+                            return Filters.assignableToSkirmishAgainst(assigningSide, Filters.in(fpChar), ignoreExistingAssignments, ignoreDefender, ignoreAllyLocation);
                         }, minionMemory, player, "Choose minion to assign to character", environment));
 
         DelayedAppender assignAppender = new DelayedAppender() {
@@ -70,8 +73,7 @@ public class AssignFpCharacterToSkirmish implements EffectAppenderProducer {
                 final Collection<? extends PhysicalCard> fpChar = actionContext.getCardsFromMemory(fpCharacterMemory);
                 final Collection<? extends PhysicalCard> minion = actionContext.getCardsFromMemory(minionMemory);
                 if (fpChar.size() == 1 && minion.size() == 1) {
-                    AssignmentEffect effect = new AssignmentEffect(assigningPlayer, fpChar.iterator().next(), minion.iterator().next());
+                    AssignmentEffect effect = new AssignmentEffect(assigningPlayer, fpChar.iterator().next(), minion.iterator().next(), ignoreExistingAssignments, ignoreDefender, ignoreAllyLocation);
-                    effect.setIgnoreSingleMinionRestriction(ignoreExistingAssignments);
                     return effect;
                 } else {
                     return null;

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/cards/build/field/effect/appender/StartSkirmish.java

@@ -39,7 +39,7 @@ public class StartSkirmish implements EffectAppenderProducer {
                             final String assigningPlayer = playerSource.getPlayer(actionContext);
                             Side assigningSide = GameUtils.getSide(actionContext.getGame(), assigningPlayer);
                             final Filterable filter = minionFilter.getFilterable(actionContext);
-                            return Filters.assignableToSkirmishAgainst(assigningSide, filter, true, false);
+                            return Filters.assignableToSkirmishAgainst(assigningSide, filter, true, true, false);
                         }, "_fpCharacterTemp", "you", "Choose character to assign to skirmish", environment));
         result.addEffectAppender(
                 CardResolver.resolveCard(against,
@@ -47,7 +47,7 @@ public class StartSkirmish implements EffectAppenderProducer {
                             final String assigningPlayer = playerSource.getPlayer(actionContext);
                             Side assigningSide = GameUtils.getSide(actionContext.getGame(), assigningPlayer);
                             final Collection<? extends PhysicalCard> fpChar = actionContext.getCardsFromMemory("_tempFpCharacter");
-                            return Filters.assignableToSkirmishAgainst(assigningSide, Filters.in(fpChar), true, false);
+                            return Filters.assignableToSkirmishAgainst(assigningSide, Filters.in(fpChar), true, true, false);
                         }, "_minionTemp", "you", "Choose minion to assign to character", environment));
         result.addEffectAppender(
                 new DelayedAppender() {
@@ -55,7 +55,7 @@ public class StartSkirmish implements EffectAppenderProducer {
                     protected List<? extends Effect> createEffects(boolean cost, CostToEffectAction action, ActionContext actionContext) {
                         final Collection<? extends PhysicalCard> fpChar = actionContext.getCardsFromMemory("_fpCharacterTemp");
                         final Collection<? extends PhysicalCard> minions = actionContext.getCardsFromMemory("_minionTemp");
-                        if (fpChar.size() == 1 && minions.size() > 0) {
+                        if (fpChar.size() == 1 && !minions.isEmpty()) {
                             new AdditionalSkirmishPhaseEffect(fpChar.iterator().next(), minions);
                         }
                         return null;

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/filters/Filters.java

@@ -14,6 +14,7 @@ import com.gempukku.lotro.logic.modifiers.evaluator.Evaluator;
 import com.gempukku.lotro.logic.timing.RuleUtils;
 
 import java.util.*;
+import java.util.stream.Collectors;
 
 public class Filters {
     private static final Map<CardType, Filter> _typeFilterMap = new HashMap<>();
@@ -192,16 +193,17 @@ public class Filters {
     }
 
     public static Filter assignableToSkirmishAgainst(final Side assignedBySide, final Filterable againstFilter) {
-        return assignableToSkirmishAgainst(assignedBySide, againstFilter, false, false);
+        return assignableToSkirmishAgainst(assignedBySide, againstFilter, false, false, false);
     }
 
-    public static Filter assignableToSkirmishAgainst(final Side assignedBySide, final Filterable againstFilter, final boolean ignoreExistingAssignments, final boolean allowAllyToSkirmish) {
+    public static Filter assignableToSkirmishAgainst(final Side assignedBySide, final Filterable againstFilter,
+            final boolean ignoreExistingAssignments, final boolean ignoreDefender, final boolean allowAllyToSkirmish) {
         return Filters.and(
-                assignableToSkirmish(assignedBySide, ignoreExistingAssignments, allowAllyToSkirmish),
+                assignableToSkirmish(assignedBySide, ignoreExistingAssignments, ignoreDefender, allowAllyToSkirmish),
                 (Filter) (game, physicalCard) -> {
                     for (PhysicalCard card : Filters.filterActive(game, againstFilter)) {
                         if (card.getBlueprint().getSide() != physicalCard.getBlueprint().getSide()
-                                && Filters.assignableToSkirmish(assignedBySide, ignoreExistingAssignments, allowAllyToSkirmish).accepts(game, card)) {
+                                && Filters.assignableToSkirmish(assignedBySide, ignoreExistingAssignments, ignoreDefender, allowAllyToSkirmish).accepts(game, card)) {
                             Map<PhysicalCard, Set<PhysicalCard>> thisAssignment = new HashMap<>();
                             if (card.getBlueprint().getSide() == Side.FREE_PEOPLE) {
                                 if (thisAssignment.containsKey(card))
@@ -223,7 +225,8 @@ public class Filters {
                 });
     }
 
-    public static Filter assignableToSkirmish(final Side assignedBySide, final boolean ignoreExistingAssignments, final boolean allowAllyToSkirmish) {
+    public static Filter assignableToSkirmish(final Side assignedBySide, final boolean ignoreExistingAssignments,
+            final boolean ignoreDefender, final boolean allowAllyToSkirmish) {
         Filter assignableFilter = Filters.or(
                 Filters.and(
                         CardType.ALLY,
@@ -256,9 +259,20 @@ public class Filters {
                 (Filter) (game, physicalCard) -> {
                     if (!ignoreExistingAssignments) {
                         boolean assignedToSkirmish = Filters.assignedToSkirmish.accepts(game, physicalCard);
-                        int defender = game.getModifiersQuerying().getKeywordCount(game, physicalCard, Keyword.DEFENDER);
+
-                        if (assignedToSkirmish && defender == 0)
+                        if (assignedToSkirmish) {
-                            return false;
+                            if(!ignoreDefender) {
+                                int defender = game.getModifiersQuerying().getKeywordCount(game, physicalCard, Keyword.DEFENDER);
+                                var assignments = game.getGameState().getAssignments()
+                                        .stream().filter(x -> x.getFellowshipCharacter() == physicalCard || x.getShadowCharacters().contains(physicalCard)).collect(
+                                                Collectors.toSet());
+                                if(1 + defender <= assignments.size())
+                                    return false;
+                            }
+                            else {
+                                return false;
+                            }
+                        }
                     }
                     return game.getModifiersQuerying().canBeAssignedToSkirmish(game, assignedBySide, physicalCard);
                 });

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/effects/AssignmentEffect.java

@@ -14,24 +14,24 @@ import java.util.Collections;
 
 public class AssignmentEffect extends AbstractEffect {
     private final String _playerId;
-    private boolean _ignoreSingleMinionRestriction;
+    private boolean _ignoreExistingAssignments;
+    private boolean _ignoreDefender;
     private final boolean _skipAllyLocationCheck;
     private final PhysicalCard _fpChar;
     private final PhysicalCard _minion;
 
     public AssignmentEffect(String playerId, PhysicalCard fpChar, PhysicalCard minion) {
-        this(playerId, fpChar, minion, false);
+        this(playerId, fpChar, minion, false, false, false);
     }
 
-    public AssignmentEffect(String playerId, PhysicalCard fpChar, PhysicalCard minion, boolean skipAllyLocationCheck) {
+    public AssignmentEffect(String playerId, PhysicalCard fpChar, PhysicalCard minion, boolean ignoreExistingAssignments,
+            boolean ignoreDefender, boolean skipAllyLocationCheck) {
         _playerId = playerId;
         _fpChar = fpChar;
         _minion = minion;
         _skipAllyLocationCheck = skipAllyLocationCheck;
-    }
+        _ignoreExistingAssignments = ignoreExistingAssignments;
-
+        _ignoreDefender = ignoreDefender;
-    public void setIgnoreSingleMinionRestriction(boolean ignoreSingleMinionRestriction) {
-        _ignoreSingleMinionRestriction = ignoreSingleMinionRestriction;
     }
 
     @Override
@@ -47,7 +47,7 @@ public class AssignmentEffect extends AbstractEffect {
     @Override
     public boolean isPlayableInFull(LotroGame game) {
         Side side = _playerId.equals(game.getGameState().getCurrentPlayerId()) ? Side.FREE_PEOPLE : Side.SHADOW;
-        return Filters.assignableToSkirmishAgainst(side, _fpChar, _ignoreSingleMinionRestriction, _skipAllyLocationCheck).accepts(game, _minion);
+        return Filters.assignableToSkirmishAgainst(side, _fpChar, _ignoreExistingAssignments, _ignoreDefender, _skipAllyLocationCheck).accepts(game, _minion);
     }
 
     @Override

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/processes/turn/assign/FreePeoplePlayerAssignsMinionsGameProcess.java

@@ -45,14 +45,14 @@ public class FreePeoplePlayerAssignsMinionsGameProcess implements GameProcess {
                     protected void doPlayEffect(final LotroGame game) {
                         final GameState gameState = game.getGameState();
 
-                        final Collection<PhysicalCard> minions = Filters.filterActive(game, CardType.MINION, Filters.assignableToSkirmish(Side.FREE_PEOPLE, false, false));
+                        final Collection<PhysicalCard> minions = Filters.filterActive(game, CardType.MINION, Filters.assignableToSkirmish(Side.FREE_PEOPLE, false, false, false));
                         if (!minions.isEmpty()) {
                             final Collection<PhysicalCard> freePeopleTargets =
                                     Filters.filterActive(game,
                                             Filters.and(
                                                     Filters.or(
                                                             CardType.COMPANION, CardType.ALLY),
-                                                    Filters.assignableToSkirmish(Side.FREE_PEOPLE, false, false)));
+                                                    Filters.assignableToSkirmish(Side.FREE_PEOPLE, false, false, false)));
 
 
                             game.getUserFeedback().sendAwaitingDecision(gameState.getCurrentPlayerId(),

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/processes/turn/assign/ShadowPlayerAssignsHisMinionsGameProcess.java

@@ -36,14 +36,14 @@ public class ShadowPlayerAssignsHisMinionsGameProcess implements GameProcess {
         GameState gameState = game.getGameState();
         Filter minionFilter = Filters.and(CardType.MINION, Filters.owner(_playerId), Filters.in(_leftoverMinions));
 
-        final Collection<PhysicalCard> minions = Filters.filterActive(game, minionFilter, Filters.assignableToSkirmish(Side.SHADOW, false, false));
+        final Collection<PhysicalCard> minions = Filters.filterActive(game, minionFilter, Filters.assignableToSkirmish(Side.SHADOW, false, false, false));
         if (!minions.isEmpty()) {
             final Collection<PhysicalCard> freePeopleTargets =
                     Filters.filterActive(game,
                             Filters.and(
                                     Filters.or(
                                             CardType.COMPANION, CardType.ALLY),
-                                    Filters.assignableToSkirmish(Side.SHADOW, true, false)));
+                                    Filters.assignableToSkirmish(Side.SHADOW, true, true, false)));
 
             game.getUserFeedback().sendAwaitingDecision(_playerId,
                     new PlayerAssignMinionsDecision(1, "Assign minions to companions or allies at home", freePeopleTargets, minions) {

gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/at/ModifiersAtTest.java

@@ -373,9 +373,9 @@ public class ModifiersAtTest extends AbstractAtTest {
         DefaultActionContext actionContext = new DefaultActionContext(P1, _game, null, null, null);
 
         passUntil(Phase.FELLOWSHIP);
-        assertFalse(Filters.assignableToSkirmish(Side.FREE_PEOPLE, false, false).accepts(_game, birchseed));
+        assertFalse(Filters.assignableToSkirmish(Side.FREE_PEOPLE, false, false, false).accepts(_game, birchseed));
         addModifier(modifierSource.getModifier(actionContext));
-        assertTrue(Filters.assignableToSkirmish(Side.FREE_PEOPLE, false, false).accepts(_game, birchseed));
+        assertTrue(Filters.assignableToSkirmish(Side.FREE_PEOPLE, false, false, false).accepts(_game, birchseed));
     }
 
     @Test

gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/cards/GenericCardTestHelper.java

@@ -4,6 +4,7 @@ import com.gempukku.lotro.at.AbstractAtTest;
 import com.gempukku.lotro.cards.build.*;
 import com.gempukku.lotro.cards.build.field.effect.filter.FilterFactory;
 import com.gempukku.lotro.common.*;
+import com.gempukku.lotro.filters.Filters;
 import com.gempukku.lotro.game.*;
 import com.gempukku.lotro.game.state.Assignment;
 import com.gempukku.lotro.game.state.LotroGame;
@@ -1029,14 +1030,29 @@ public class GenericCardTestHelper extends AbstractAtTest {
         return  _game.getModifiersQuerying().isRace(_game, card, race);
     }
 
-    public Boolean CanBeAssigned(PhysicalCardImpl card)
+    public Boolean CanBeAssignedViaAction(PhysicalCardImpl card)
     {
-        return CanBeAssigned(card, Side.SHADOW) || CanBeAssigned(card, Side.FREE_PEOPLE);
+        return CanBeAssignedViaAction(card, Side.SHADOW) || CanBeAssignedViaAction(card, Side.FREE_PEOPLE);
     }
 
-    public Boolean CanBeAssigned(PhysicalCardImpl card, Side side)
+    public Boolean FreepsCanAssign(PhysicalCardImpl card)
     {
-        return _game.getModifiersQuerying().canBeAssignedToSkirmish(_game, side, card);
+        return CanBeAssignedNormally(card, Side.FREE_PEOPLE);
+    }
+
+    public Boolean ShadowCanAssign(PhysicalCardImpl card)
+    {
+        return CanBeAssignedViaAction(card, Side.FREE_PEOPLE);
+    }
+
+    public Boolean CanBeAssignedViaAction(PhysicalCardImpl card, Side side)
+    {
+        return Filters.assignableToSkirmish(side, false, true, false).accepts(_game, card);
+    }
+
+    public Boolean CanBeAssignedNormally(PhysicalCardImpl card, Side side)
+    {
+        return Filters.assignableToSkirmish(side, side == Side.SHADOW, side == Side.SHADOW, false).accepts(_game, card);
     }
 
 

gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/cards/official/set01/Card_01_262_Tests.java

@@ -85,12 +85,16 @@ public class Card_01_262_Tests
 		scn.ShadowUseCardAction(assassin);
 		assertEquals(2, scn.GetFreepsCardChoiceCount());
 
-		assertTrue(scn.CanBeAssigned(sam));
+		assertTrue(scn.CanBeAssignedViaAction(sam));
 		scn.FreepsChooseCard(sam);
 		assertTrue(scn.IsCharAssigned(sam));
 		assertTrue(scn.IsCharAssigned(assassin));
 
 		scn.PassCurrentPhaseActions();
+		assertFalse(scn.FreepsCanAssign(sam));
+		assertFalse(scn.FreepsCanAssign(assassin));
+		assertTrue(scn.FreepsCanAssign(runner));
+		assertTrue(scn.FreepsCanAssign(frodo));
 		scn.FreepsAssignToMinions(frodo, runner);
 		// If beginning skirmishes now fails, then there is some dangling minion that Gemp thinks
 		// is unassigned, which isn't right.
@@ -122,7 +126,7 @@ public class Card_01_262_Tests
 		scn.ShadowUseCardAction(assassin);
 		assertEquals(2, scn.GetFreepsCardChoiceCount());
 
-		assertTrue(scn.CanBeAssigned(sam));
+		assertTrue(scn.CanBeAssignedViaAction(sam));
 		scn.FreepsChooseCard(sam);
 		assertTrue(scn.IsCharAssigned(sam));
 		assertTrue(scn.IsCharAssigned(assassin));
@@ -131,7 +135,7 @@ public class Card_01_262_Tests
 
 		assertTrue(scn.hasKeyword(sam, Keyword.DEFENDER));
 		assertEquals(1, scn.GetKeywordCount(sam, Keyword.DEFENDER));
-		scn.CanBeAssigned(sam);
+		assertTrue(scn.FreepsCanAssign(sam));
 		scn.FreepsAssignToMinions(sam, runner);
 		assertTrue(scn.IsCharAssigned(sam));
 		assertTrue(scn.IsCharAssigned(assassin));

gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/cards/official/set03/Card_03_069_Tests.java

@@ -19,6 +19,7 @@ public class Card_03_069_Tests
 				{{
 					put("saruman", "3_69");
 					put("savage", "1_151");
+					put("shaman", "1_152");
 
 					put("sam", "2_114");
 
@@ -82,12 +83,61 @@ public class Card_03_069_Tests
 		scn.FreepsPassCurrentPhaseAction();
 
 		assertTrue(scn.ShadowActionAvailable(saruman));
-		assertTrue(scn.CanBeAssigned(sam));
+		assertTrue(scn.CanBeAssignedViaAction(sam));
-		assertTrue(scn.CanBeAssigned(savage));
+		assertTrue(scn.CanBeAssignedViaAction(savage));
 
 		scn.ShadowUseCardAction(saruman);
 		scn.FreepsChooseNo();
 		scn.PassCurrentPhaseActions();
+		assertTrue(scn.IsCharAssigned(sam));
+		assertTrue(scn.IsCharAssigned(savage));
+
+		scn.FreepsResolveSkirmish(sam);
+	}
+
+	@Test
+	public void SarumanCannotAssignMultipleMinionsToSameCompanionEvenWithDefender() throws DecisionResultInvalidException, CardNotFoundException {
+		//Pre-game setup
+		var scn = GetScenario();
+
+		var saruman = scn.GetShadowCard("saruman");
+		var savage = scn.GetShadowCard("savage");
+		var shaman = scn.GetShadowCard("shaman");
+		scn.ShadowMoveCharToTable(saruman, savage, shaman);
+
+		var frodo = scn.GetRingBearer();
+		var sam = scn.GetFreepsCard("sam");
+		scn.FreepsMoveCharToTable(sam);
+
+		scn.StartGame();
+
+		scn.SkipToPhase(Phase.MANEUVER);
+		scn.FreepsUseCardAction(sam);
+		scn.ShadowPassCurrentPhaseAction();
+		scn.FreepsPassCurrentPhaseAction();
+
+		scn.SkipToPhase(Phase.ASSIGNMENT);
+		scn.FreepsPassCurrentPhaseAction();
+
+		assertTrue(scn.ShadowActionAvailable(saruman));
+		assertTrue(scn.CanBeAssignedViaAction(sam));
+		assertTrue(scn.CanBeAssignedViaAction(savage));
+		assertTrue(scn.CanBeAssignedViaAction(shaman));
+
+		scn.ShadowUseCardAction(saruman);
+		scn.ShadowChooseCard(savage);
+		scn.FreepsChooseNo();
+		scn.FreepsPassCurrentPhaseAction();
+		assertTrue(scn.IsCharAssigned(sam));
+		assertTrue(scn.IsCharAssigned(savage));
+		assertFalse(scn.IsCharAssigned(shaman));
+		assertFalse(scn.CanBeAssignedViaAction(sam));
+		assertFalse(scn.CanBeAssignedViaAction(savage));
+		assertTrue(scn.CanBeAssignedViaAction(shaman));
+
+		scn.ShadowUseCardAction(saruman);
+		scn.PassCurrentPhaseActions();
+		scn.FreepsAssignToMinions(frodo, shaman);
 
 		scn.FreepsResolveSkirmish(sam);
 	}

gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/cards/unofficial/pc/vsets/set_v01/Card_V1_018_Tests.java

@@ -88,13 +88,13 @@ public class Card_V1_018_Tests
 
 		scn.StartGame();
 
-		assertFalse(scn.CanBeAssigned(saruman));
+		assertFalse(scn.CanBeAssignedViaAction(saruman));
 		scn.FreepsPlayCard(elrond);
-		assertFalse(scn.CanBeAssigned(saruman));
+		assertFalse(scn.CanBeAssignedViaAction(saruman));
 		scn.FreepsPlayCard(galadriel);
-		assertFalse(scn.CanBeAssigned(saruman));
+		assertFalse(scn.CanBeAssignedViaAction(saruman));
 		scn.FreepsPlayCard(gandalf);
-		assertTrue(scn.CanBeAssigned(saruman));
+		assertTrue(scn.CanBeAssignedViaAction(saruman));
 
 		scn.SkipToPhase(Phase.ASSIGNMENT);
 		scn.PassCurrentPhaseActions();