ambidextrous/gemp-lotr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Introducing an extra sub-step for cards that require cost to be able to assign them by player.

Browse Source
This commit is contained in:
marcins78@gmail.com
2011-11-10 15:24:00 +00:00
parent ee875afea7
commit 3451f2db7b
4 changed files with 86 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/effects/AssignmentPhaseEffect.java
View File

@@ -29,10 +29,6 @@ public class AssignmentPhaseEffect extends AbstractEffect {
_text = text; _text = text;
} }
public AssignmentPhaseEffect(String playerId, PhysicalCard fpChar, List<PhysicalCard> minions, String text) {
this(playerId, Collections.singletonMap(fpChar, minions), text);
}
@Override @Override
public Effect.Type getType() { public Effect.Type getType() {
return null; return null;

2
gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/EffectResult.java
View File

@@ -4,6 +4,8 @@ public abstract class EffectResult {
public enum Type { public enum Type {
WOUND, KILL, HEAL, EXERT, DISCARD_FROM_PLAY, DISCARD_FROM_HAND, WOUND, KILL, HEAL, EXERT, DISCARD_FROM_PLAY, DISCARD_FROM_HAND,
FREE_PEOPLE_PLAYER_STARTS_ASSIGNING,
ASSIGNMENT, OVERWHELM_IN_SKIRMISH, RESOLVE_SKIRMISH, ASSIGNMENT, OVERWHELM_IN_SKIRMISH, RESOLVE_SKIRMISH,
ADD_TWILIGHT, ADD_TWILIGHT,

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

@@ -12,8 +12,11 @@ import com.gempukku.lotro.logic.actions.SystemQueueAction;
import com.gempukku.lotro.logic.decisions.DecisionResultInvalidException; import com.gempukku.lotro.logic.decisions.DecisionResultInvalidException;
import com.gempukku.lotro.logic.decisions.PlayerAssignMinionsDecision; import com.gempukku.lotro.logic.decisions.PlayerAssignMinionsDecision;
import com.gempukku.lotro.logic.effects.AssignmentPhaseEffect; import com.gempukku.lotro.logic.effects.AssignmentPhaseEffect;
import com.gempukku.lotro.logic.effects.TriggeringResultEffect;
import com.gempukku.lotro.logic.modifiers.ModifiersQuerying; import com.gempukku.lotro.logic.modifiers.ModifiersQuerying;
import com.gempukku.lotro.logic.timing.UnrespondableEffect;
import com.gempukku.lotro.logic.timing.processes.GameProcess; import com.gempukku.lotro.logic.timing.processes.GameProcess;
import com.gempukku.lotro.logic.timing.results.FreePlayerStartsAssigningResult;
import java.util.Collection; import java.util.Collection;
import java.util.LinkedList; import java.util.LinkedList;
@@ -21,87 +24,94 @@ import java.util.List;
import java.util.Map; import java.util.Map;
public class FreePeoplePlayerAssignsMinionsGameProcess implements GameProcess { public class FreePeoplePlayerAssignsMinionsGameProcess implements GameProcess {
private LotroGame _game;
private GameProcess _followingGameProcess; private GameProcess _followingGameProcess;
public FreePeoplePlayerAssignsMinionsGameProcess(LotroGame game, GameProcess followingGameProcess) { public FreePeoplePlayerAssignsMinionsGameProcess(LotroGame game, GameProcess followingGameProcess) {
_game = game;
_followingGameProcess = followingGameProcess; _followingGameProcess = followingGameProcess;
} }
@Override @Override
public void process(LotroGame game) { public void process(LotroGame game) {
final GameState gameState = _game.getGameState(); final SystemQueueAction action = new SystemQueueAction();
action.appendEffect(
new TriggeringResultEffect(new FreePlayerStartsAssigningResult(), "Free people player starts assigning"));
action.appendEffect(
new UnrespondableEffect() {
@Override
protected void doPlayEffect(final LotroGame game) {
final GameState gameState = game.getGameState();
Filter minionFilter = Filters.type(CardType.MINION); Filter minionFilter = Filters.type(CardType.MINION);
if (gameState.isFierceSkirmishes()) if (gameState.isFierceSkirmishes())
minionFilter = Filters.and( minionFilter = Filters.and(
Filters.keyword(Keyword.FIERCE), Filters.keyword(Keyword.FIERCE),
minionFilter); minionFilter);
final Collection<PhysicalCard> minions = Filters.filterActive(gameState, _game.getModifiersQuerying(), minionFilter, Filters.canBeAssignedToSkirmish(Side.FREE_PEOPLE)); final Collection<PhysicalCard> minions = Filters.filterActive(gameState, game.getModifiersQuerying(), minionFilter, Filters.canBeAssignedToSkirmish(Side.FREE_PEOPLE));
if (minions.size() > 0) { if (minions.size() > 0) {
final Collection<PhysicalCard> freePeopleTargets = Filters.filterActive(gameState, _game.getModifiersQuerying(), final Collection<PhysicalCard> freePeopleTargets = Filters.filterActive(gameState, game.getModifiersQuerying(),
Filters.or(
Filters.and(
Filters.type(CardType.COMPANION),
Filters.or(
Filters.not(Keyword.UNHASTY),
new Filter() {
@Override
public boolean accepts(GameState gameState, ModifiersQuerying modifiersQuerying, PhysicalCard physicalCard) {
return modifiersQuerying.isAllowedToParticipateInSkirmishes(gameState, Side.FREE_PEOPLE, physicalCard);
}
}
)
),
Filters.and(
Filters.type(CardType.ALLY),
Filters.or( Filters.or(
Filters.and( Filters.and(
Filters.allyAtHome, Filters.type(CardType.COMPANION),
new Filter() { Filters.or(
@Override Filters.not(Keyword.UNHASTY),
public boolean accepts(GameState gameState, ModifiersQuerying modifiersQuerying, PhysicalCard physicalCard) { new Filter() {
return !modifiersQuerying.isAllyPreventedFromParticipatingInSkirmishes(gameState, Side.FREE_PEOPLE, physicalCard); @Override
} public boolean accepts(GameState gameState, ModifiersQuerying modifiersQuerying, PhysicalCard physicalCard) {
}), return modifiersQuerying.isAllowedToParticipateInSkirmishes(gameState, Side.FREE_PEOPLE, physicalCard);
new Filter() { }
@Override }
public boolean accepts(GameState gameState, ModifiersQuerying modifiersQuerying, PhysicalCard physicalCard) { )
return modifiersQuerying.isAllowedToParticipateInSkirmishes(gameState, Side.FREE_PEOPLE, physicalCard); ),
} Filters.and(
Filters.type(CardType.ALLY),
Filters.or(
Filters.and(
Filters.allyAtHome,
new Filter() {
@Override
public boolean accepts(GameState gameState, ModifiersQuerying modifiersQuerying, PhysicalCard physicalCard) {
return !modifiersQuerying.isAllyPreventedFromParticipatingInSkirmishes(gameState, Side.FREE_PEOPLE, physicalCard);
}
}),
new Filter() {
@Override
public boolean accepts(GameState gameState, ModifiersQuerying modifiersQuerying, PhysicalCard physicalCard) {
return modifiersQuerying.isAllowedToParticipateInSkirmishes(gameState, Side.FREE_PEOPLE, physicalCard);
}
}
)
)
),
Filters.canBeAssignedToSkirmish(Side.FREE_PEOPLE));
game.getUserFeedback().sendAwaitingDecision(gameState.getCurrentPlayerId(),
new PlayerAssignMinionsDecision(1, "Assign minions to companions or allies at home", freePeopleTargets, minions) {
@Override
public void decisionMade(String result) throws DecisionResultInvalidException {
Map<PhysicalCard, List<PhysicalCard>> assignments = getAssignmentsBasedOnResponse(result);
List<PhysicalCard> unassignedMinions = new LinkedList<PhysicalCard>(minions);
// Validate minion count (Defender)
for (PhysicalCard freeCard : assignments.keySet()) {
List<PhysicalCard> minionsAssigned = assignments.get(freeCard);
if (minionsAssigned.size() > 1 + game.getModifiersQuerying().getKeywordCount(game.getGameState(), freeCard, Keyword.DEFENDER))
throw new DecisionResultInvalidException(freeCard.getBlueprint().getName() + " can't have so many minions assigned");
unassignedMinions.removeAll(minionsAssigned);
} }
)
)
),
Filters.canBeAssignedToSkirmish(Side.FREE_PEOPLE));
_game.getUserFeedback().sendAwaitingDecision(gameState.getCurrentPlayerId(), if (!game.getModifiersQuerying().isValidAssignments(game.getGameState(), Side.FREE_PEOPLE, assignments))
new PlayerAssignMinionsDecision(1, "Assign minions to companions or allies at home", freePeopleTargets, minions) { throw new DecisionResultInvalidException("Assignments are not valid for the effects affecting the cards");
@Override
public void decisionMade(String result) throws DecisionResultInvalidException {
Map<PhysicalCard, List<PhysicalCard>> assignments = getAssignmentsBasedOnResponse(result);
List<PhysicalCard> unassignedMinions = new LinkedList<PhysicalCard>(minions); action.appendEffect(
// Validate minion count (Defender) new AssignmentPhaseEffect(gameState.getCurrentPlayerId(), assignments, "Free People player assignments"));
for (PhysicalCard freeCard : assignments.keySet()) { }
List<PhysicalCard> minionsAssigned = assignments.get(freeCard); });
if (minionsAssigned.size() > 1 + _game.getModifiersQuerying().getKeywordCount(_game.getGameState(), freeCard, Keyword.DEFENDER))
throw new DecisionResultInvalidException(freeCard.getBlueprint().getName() + " can't have so many minions assigned");
unassignedMinions.removeAll(minionsAssigned);
}
if (!_game.getModifiersQuerying().isValidAssignments(_game.getGameState(), Side.FREE_PEOPLE, assignments))
throw new DecisionResultInvalidException("Assignments are not valid for the effects affecting the cards");
SystemQueueAction action = new SystemQueueAction();
action.appendEffect(
new AssignmentPhaseEffect(gameState.getCurrentPlayerId(), assignments, "Free People player assignments"));
_game.getActionsEnvironment().addActionToStack(action);
} }
});
} }
});
game.getActionsEnvironment().addActionToStack(action);
} }
@Override @Override

9
gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/results/FreePlayerStartsAssigningResult.java Normal file
View File

@@ -0,0 +1,9 @@
package com.gempukku.lotro.logic.timing.results;
import com.gempukku.lotro.logic.timing.EffectResult;
public class FreePlayerStartsAssigningResult extends EffectResult {
public FreePlayerStartsAssigningResult() {
super(Type.FREE_PEOPLE_PLAYER_STARTS_ASSIGNING);
}
}