Failure/foul-magics
1
0
Fork 0
forked from External/mage
Code Pull requests Releases Packages Activity Actions

refactor: common logic for "at..." triggered abilities (#13045)

Browse source 
* add new common framework for at step triggered abilities

* move postcombat main and second main triggers to it

* update draw step triggers

* refactor BeginningOfCombatTriggeredAbility

* refactor BeginningOfFirstMainTriggeredAbility

* move Pronoun to constants package

* cleanup some cards to use simpler constructors

* package reorganization
This commit is contained in:
xenohedron 2024-10-27 21:03:40 -04:00 • committed by GitHub
parent c9cc398b48
commit eee0fee79e
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
329 changed files with 1149 additions and 1331 deletions
Download patch file Download diff file Expand all files Collapse all files

92
Mage/src/main/java/mage/abilities/common/BeginningOfCombatTriggeredAbility.java
View file

@ -1,92 +0,0 @@
package mage.abilities.common;
import mage.abilities.TriggeredAbilityImpl;
import mage.abilities.effects.Effect;
import mage.constants.TargetController;
import mage.constants.Zone;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.target.targetpointer.FixedTarget;
public class BeginningOfCombatTriggeredAbility extends TriggeredAbilityImpl {
private final TargetController targetController;
private final boolean setTargetPointer;
public BeginningOfCombatTriggeredAbility(Effect effect, TargetController targetController, boolean isOptional) {
this(Zone.BATTLEFIELD, effect, targetController, isOptional, false);
}
public BeginningOfCombatTriggeredAbility(Zone zone, Effect effect, TargetController targetController, boolean isOptional, boolean setTargetPointer) {
super(zone, effect, isOptional);
this.targetController = targetController;
this.setTargetPointer = setTargetPointer;
setTriggerPhrase(generateTriggerPhrase());
}
protected BeginningOfCombatTriggeredAbility(final BeginningOfCombatTriggeredAbility ability) {
super(ability);
this.targetController = ability.targetController;
this.setTargetPointer = ability.setTargetPointer;
}
@Override
public BeginningOfCombatTriggeredAbility copy() {
return new BeginningOfCombatTriggeredAbility(this);
}
@Override
public boolean checkEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.BEGIN_COMBAT_STEP_PRE;
}
@Override
public boolean checkTrigger(GameEvent event, Game game) {
switch (targetController) {
case YOU:
boolean yours = event.getPlayerId().equals(this.controllerId);
if (yours && setTargetPointer) {
if (getTargets().isEmpty()) {
this.getEffects().forEach(effect -> {
effect.setTargetPointer(new FixedTarget(event.getPlayerId()));
});
}
}
return yours;
case OPPONENT:
if (game.getPlayer(this.controllerId).hasOpponent(event.getPlayerId(), game)) {
if (setTargetPointer) {
this.getEffects().forEach(effect -> {
effect.setTargetPointer(new FixedTarget(event.getPlayerId()));
});
}
return true;
}
break;
case EACH_PLAYER:
case ANY:
if (setTargetPointer) {
this.getEffects().forEach(effect -> {
effect.setTargetPointer(new FixedTarget(event.getPlayerId()));
});
}
return true;
}
return false;
}
private String generateTriggerPhrase() {
switch (targetController) {
case YOU:
return "At the beginning of combat on your turn, ";
case OPPONENT:
return "At the beginning of combat on each opponent's turn, ";
case EACH_PLAYER:
return "At the beginning of combat on each player's turn, ";
case ANY:
return "At the beginning of each combat, ";
}
return "";
}
}

120
Mage/src/main/java/mage/abilities/common/BeginningOfDrawTriggeredAbility.java
View file

@ -1,120 +0,0 @@
package mage.abilities.common;
import mage.abilities.TriggeredAbilityImpl;
import mage.abilities.effects.Effect;
import mage.constants.TargetController;
import mage.constants.Zone;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.game.permanent.Permanent;
import mage.target.targetpointer.FixedTarget;
public class BeginningOfDrawTriggeredAbility extends TriggeredAbilityImpl {
private final TargetController targetController;
/**
* The Ability sets if no target is defined the target pointer to the active
* player of the current draw phase
*/
public BeginningOfDrawTriggeredAbility(Effect effect, TargetController targetController, boolean isOptional) {
this(Zone.BATTLEFIELD, effect, targetController, isOptional);
}
public BeginningOfDrawTriggeredAbility(Zone zone, Effect effect, TargetController targetController, boolean isOptional) {
super(zone, effect, isOptional);
this.targetController = targetController;
setTriggerPhrase(generateTriggerPhrase());
}
protected BeginningOfDrawTriggeredAbility(final BeginningOfDrawTriggeredAbility ability) {
super(ability);
this.targetController = ability.targetController;
}
@Override
public BeginningOfDrawTriggeredAbility copy() {
return new BeginningOfDrawTriggeredAbility(this);
}
@Override
public boolean checkEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.DRAW_STEP_PRE;
}
@Override
public boolean checkTrigger(GameEvent event, Game game) {
switch (targetController) {
case YOU:
boolean yours = event.getPlayerId().equals(this.controllerId);
if (yours && getTargets().isEmpty()) {
this.getEffects().setTargetPointer(new FixedTarget(event.getPlayerId()));
}
return yours;
case OPPONENT:
if (game.getPlayer(this.controllerId).hasOpponent(event.getPlayerId(), game)) {
if (getTargets().isEmpty()) {
this.getEffects().setTargetPointer(new FixedTarget(event.getPlayerId()));
}
return true;
}
break;
case NOT_YOU:
if (!this.controllerId.equals(event.getPlayerId())) {
if (getTargets().isEmpty()) {
this.getEffects().setTargetPointer(new FixedTarget(event.getPlayerId()));
}
return true;
}
break;
case CONTROLLER_ATTACHED_TO:
Permanent attachment = game.getPermanent(sourceId);
if (attachment != null && attachment.getAttachedTo() != null) {
Permanent attachedTo = game.getPermanent(attachment.getAttachedTo());
if (attachedTo != null && attachedTo.isControlledBy(event.getPlayerId())) {
if (getTargets().isEmpty()) {
this.getEffects().setTargetPointer(new FixedTarget(event.getPlayerId()));
}
return true;
}
}
break;
case ENCHANTED:
Permanent permanent = getSourcePermanentIfItStillExists(game);
if (permanent == null || !game.isActivePlayer(permanent.getAttachedTo())) {
break;
}
if (getTargets().isEmpty()) {
this.getEffects().setTargetPointer(new FixedTarget(event.getPlayerId()));
}
return true;
case ANY:
case ACTIVE:
if (getTargets().isEmpty()) {
this.getEffects().setTargetPointer(new FixedTarget(event.getPlayerId()));
}
return true;
}
return false;
}
private String generateTriggerPhrase() {
switch (targetController) {
case ACTIVE:
case YOU:
return "At the beginning of your draw step, ";
case OPPONENT:
return "At the beginning of each opponent's draw step, ";
case NOT_YOU:
return "At the beginning of each other player's draw step, ";
case ANY:
return "At the beginning of each player's draw step, ";
case CONTROLLER_ATTACHED_TO:
return "At the beginning of the draw step of enchanted creature's controller, ";
case ENCHANTED:
return "At the beginning of enchanted player's draw step, ";
}
return "";
}
}

93
Mage/src/main/java/mage/abilities/common/BeginningOfFirstMainTriggeredAbility.java
View file

@ -1,93 +0,0 @@
package mage.abilities.common;
import mage.abilities.TriggeredAbilityImpl;
import mage.abilities.effects.Effect;
import mage.constants.TargetController;
import mage.constants.Zone;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.target.targetpointer.FixedTarget;
/**
* @author LevelX2
*/
public class BeginningOfFirstMainTriggeredAbility extends TriggeredAbilityImpl {
private final TargetController targetController;
private final boolean setTargetPointer;
public BeginningOfFirstMainTriggeredAbility(Effect effect, TargetController targetController, boolean isOptional) {
this(Zone.BATTLEFIELD, effect, targetController, isOptional, false);
}
public BeginningOfFirstMainTriggeredAbility(Zone zone, Effect effect, TargetController targetController, boolean isOptional, boolean setTargetPointer) {
super(zone, effect, isOptional);
this.targetController = targetController;
this.setTargetPointer = setTargetPointer;
setTriggerPhrase(generateTriggerPhrase());
}
protected BeginningOfFirstMainTriggeredAbility(final BeginningOfFirstMainTriggeredAbility ability) {
super(ability);
this.targetController = ability.targetController;
this.setTargetPointer = ability.setTargetPointer;
}
@Override
public BeginningOfFirstMainTriggeredAbility copy() {
return new BeginningOfFirstMainTriggeredAbility(this);
}
@Override
public boolean checkEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.PRECOMBAT_MAIN_PHASE_PRE;
}
@Override
public boolean checkTrigger(GameEvent event, Game game) {
switch (targetController) {
case YOU:
boolean yours = event.getPlayerId().equals(this.controllerId);
if (yours && setTargetPointer) {
if (getTargets().isEmpty()) {
for (Effect effect : this.getEffects()) {
effect.setTargetPointer(new FixedTarget(event.getPlayerId()));
}
}
}
return yours;
case OPPONENT:
if (game.getPlayer(this.controllerId).hasOpponent(event.getPlayerId(), game)) {
if (setTargetPointer) {
for (Effect effect : this.getEffects()) {
effect.setTargetPointer(new FixedTarget(event.getPlayerId()));
}
}
return true;
}
break;
case ANY:
if (setTargetPointer) {
for (Effect effect : this.getEffects()) {
effect.setTargetPointer(new FixedTarget(event.getPlayerId()));
}
}
return true;
}
return false;
}
private String generateTriggerPhrase() {
switch (targetController) {
case YOU:
return "At the beginning of your first main phase, ";
case OPPONENT:
return "At the beginning of each opponent's first main phase, ";
case ANY:
return "At the beginning of each player's first main phase, ";
}
return "";
}
}

104
Mage/src/main/java/mage/abilities/common/BeginningOfPostCombatMainTriggeredAbility.java
View file

@ -1,104 +0,0 @@
package mage.abilities.common;
import mage.abilities.TriggeredAbilityImpl;
import mage.abilities.effects.Effect;
import mage.constants.TargetController;
import mage.constants.Zone;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.game.permanent.Permanent;
import mage.target.targetpointer.FixedTarget;
/**
* @author LevelX2
*/
public class BeginningOfPostCombatMainTriggeredAbility extends TriggeredAbilityImpl {
private final TargetController targetController;
private final boolean setTargetPointer;
public BeginningOfPostCombatMainTriggeredAbility(Effect effect, TargetController targetController, boolean isOptional) {
this(Zone.BATTLEFIELD, effect, targetController, isOptional, false);
}
public BeginningOfPostCombatMainTriggeredAbility(Zone zone, Effect effect, TargetController targetController, boolean isOptional, boolean setTargetPointer) {
super(zone, effect, isOptional);
this.targetController = targetController;
this.setTargetPointer = setTargetPointer;
setTriggerPhrase(generateTriggerPhrase());
}
protected BeginningOfPostCombatMainTriggeredAbility(final BeginningOfPostCombatMainTriggeredAbility ability) {
super(ability);
this.targetController = ability.targetController;
this.setTargetPointer = ability.setTargetPointer;
}
@Override
public BeginningOfPostCombatMainTriggeredAbility copy() {
return new BeginningOfPostCombatMainTriggeredAbility(this);
}
@Override
public boolean checkEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.POSTCOMBAT_MAIN_PHASE_PRE;
}
@Override
public boolean checkTrigger(GameEvent event, Game game) {
switch (targetController) {
case YOU:
if (!isControlledBy(event.getPlayerId())) {
return false;
}
if (setTargetPointer && getTargets().isEmpty()) {
for (Effect effect : this.getEffects()) {
effect.setTargetPointer(new FixedTarget(event.getPlayerId()));
}
}
return true;
case OPPONENT:
if (!game.getOpponents(this.controllerId).contains(event.getPlayerId())) {
return false;
}
if (setTargetPointer) {
for (Effect effect : this.getEffects()) {
effect.setTargetPointer(new FixedTarget(event.getPlayerId()));
}
}
return true;
case ANY:
if (setTargetPointer) {
for (Effect effect : this.getEffects()) {
effect.setTargetPointer(new FixedTarget(event.getPlayerId()));
}
}
return true;
case ENCHANTED:
Permanent permanent = getSourcePermanentIfItStillExists(game);
if (permanent == null || !game.isActivePlayer(permanent.getAttachedTo())) {
return false;
}
if (getTargets().isEmpty()) {
this.getEffects().setTargetPointer(new FixedTarget(event.getPlayerId()));
}
return true;
}
return false;
}
private String generateTriggerPhrase() {
switch (targetController) {
case YOU:
return "At the beginning of each of your postcombat main phases, ";
case OPPONENT:
return "At the beginning of each of your opponent's postcombat main phases, ";
case ANY:
return "At the beginning of each postcombat main phase, ";
case ENCHANTED:
return "At the beginning of each of enchanted player's postcombat main phases, ";
}
return "";
}
}

146
Mage/src/main/java/mage/abilities/common/BeginningOfSecondMainTriggeredAbility.java
View file

@ -1,146 +0,0 @@
package mage.abilities.common;
import mage.abilities.TriggeredAbilityImpl;
import mage.abilities.effects.Effect;
import mage.constants.TargetController;
import mage.constants.WatcherScope;
import mage.constants.Zone;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.game.permanent.Permanent;
import mage.target.targetpointer.FixedTarget;
import mage.watchers.Watcher;
/**
* @author TheElk801
*/
public class BeginningOfSecondMainTriggeredAbility extends TriggeredAbilityImpl {
private final TargetController targetController;
private final boolean setTargetPointer;
public BeginningOfSecondMainTriggeredAbility(Effect effect, TargetController targetController, boolean isOptional) {
this(Zone.BATTLEFIELD, effect, targetController, isOptional, false);
}
public BeginningOfSecondMainTriggeredAbility(Zone zone, Effect effect, TargetController targetController, boolean isOptional, boolean setTargetPointer) {
super(zone, effect, isOptional);
this.targetController = targetController;
this.setTargetPointer = setTargetPointer;
setTriggerPhrase(generateTriggerPhrase());
this.addWatcher(new MainPhaseWatcher());
}
protected BeginningOfSecondMainTriggeredAbility(final BeginningOfSecondMainTriggeredAbility ability) {
super(ability);
this.targetController = ability.targetController;
this.setTargetPointer = ability.setTargetPointer;
}
@Override
public BeginningOfSecondMainTriggeredAbility copy() {
return new BeginningOfSecondMainTriggeredAbility(this);
}
@Override
public boolean checkEventType(GameEvent event, Game game) {
switch (event.getType()) {
case PRECOMBAT_MAIN_PHASE_PRE:
case POSTCOMBAT_MAIN_PHASE_PRE:
return true;
}
return false;
}
@Override
public boolean checkTrigger(GameEvent event, Game game) {
if (!MainPhaseWatcher.checkCount(game)) {
return false;
}
switch (targetController) {
case YOU:
if (!isControlledBy(event.getPlayerId())) {
return false;
}
if (setTargetPointer && getTargets().isEmpty()) {
for (Effect effect : this.getEffects()) {
effect.setTargetPointer(new FixedTarget(event.getPlayerId()));
}
}
return true;
case OPPONENT:
if (!game.getOpponents(this.controllerId).contains(event.getPlayerId())) {
return false;
}
if (setTargetPointer) {
for (Effect effect : this.getEffects()) {
effect.setTargetPointer(new FixedTarget(event.getPlayerId()));
}
}
return true;
case ANY:
if (setTargetPointer) {
for (Effect effect : this.getEffects()) {
effect.setTargetPointer(new FixedTarget(event.getPlayerId()));
}
}
return true;
case ENCHANTED:
Permanent permanent = getSourcePermanentIfItStillExists(game);
if (permanent == null || !game.isActivePlayer(permanent.getAttachedTo())) {
return false;
}
if (getTargets().isEmpty()) {
this.getEffects().setTargetPointer(new FixedTarget(event.getPlayerId()));
}
return true;
}
return false;
}
private String generateTriggerPhrase() {
switch (targetController) {
case YOU:
return "At the beginning of your second main phase, ";
case OPPONENT:
return "At the beginning of each opponent's second main phase, ";
case ANY:
return "At the beginning of each player's second main phase, ";
case ENCHANTED:
return "At the beginning of enchanted player's second main phase, ";
}
return "";
}
}
class MainPhaseWatcher extends Watcher {
private int mainPhaseCount = 0;
MainPhaseWatcher() {
super(WatcherScope.GAME);
}
@Override
public void watch(GameEvent event, Game game) {
switch (event.getType()) {
case PRECOMBAT_MAIN_PHASE_PRE:
case POSTCOMBAT_MAIN_PHASE_PRE:
mainPhaseCount++;
}
}
@Override
public void reset() {
super.reset();
this.mainPhaseCount = 0;
}
static boolean checkCount(Game game) {
return game
.getState()
.getWatcher(MainPhaseWatcher.class)
.mainPhaseCount == 2;
}
}