From 08f945f1d166df4e4aaae43960d8b7638beeb2d1 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Thu, 21 May 2020 23:28:40 +0800 Subject: [PATCH 01/22] added Scavenger --- .../card/concrete/summon/ScavengerSummon.java | 37 ++++++++++ .../character/concrete/red/Scavenger.java | 74 +++++++++++++++++++ 2 files changed, 111 insertions(+) create mode 100644 src/main/java/eod/card/concrete/summon/ScavengerSummon.java create mode 100644 src/main/java/eod/warObject/character/concrete/red/Scavenger.java diff --git a/src/main/java/eod/card/concrete/summon/ScavengerSummon.java b/src/main/java/eod/card/concrete/summon/ScavengerSummon.java new file mode 100644 index 0000000..6a8ed5f --- /dev/null +++ b/src/main/java/eod/card/concrete/summon/ScavengerSummon.java @@ -0,0 +1,37 @@ +package eod.card.concrete.summon; + +import eod.Party; +import eod.card.abstraction.Card; +import eod.card.abstraction.summon.SummonCard; +import eod.card.abstraction.summon.SummonCardType; +import eod.warObject.character.concrete.red.Scavenger; + +import static eod.effect.EffectFunctions.Summon; + +public class ScavengerSummon extends SummonCard { + public ScavengerSummon() { + super(1, SummonCardType.NORMAL); + } + + @Override + public void summon() { + Summon(player, new Scavenger(player)).from(player.getBaseEmpty()); + } + + @Override + public Card copy() { + Card c = new ScavengerSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "召喚 清道夫"; + } + + @Override + public Party getParty() { + return Party.RED; + } +} diff --git a/src/main/java/eod/warObject/character/concrete/red/Scavenger.java b/src/main/java/eod/warObject/character/concrete/red/Scavenger.java new file mode 100644 index 0000000..b2086fb --- /dev/null +++ b/src/main/java/eod/warObject/character/concrete/red/Scavenger.java @@ -0,0 +1,74 @@ +package eod.warObject.character.concrete.red; + +import eod.Gameboard; +import eod.Party; +import eod.Player; +import eod.card.abstraction.summon.SummonCard; +import eod.card.concrete.summon.ScavengerSummon; +import eod.exceptions.NotSupportedException; +import eod.param.AttackParam; +import eod.param.PointParam; +import eod.warObject.Damageable; +import eod.warObject.Status; +import eod.warObject.WarObject; +import eod.warObject.character.abstraction.Character; + +import java.awt.*; +import java.util.ArrayList; + +import static eod.effect.EffectFunctions.RequestRegionalAttack; + +public class Scavenger extends Character { + public Scavenger(Player player) { + super(player, 2, 1, Party.RED); + } + + @Override + public SummonCard getSummonCard() { + SummonCard c = new ScavengerSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "清道夫"; + } + + @Override + public ArrayList getAttackRange() { + PointParam param = new PointParam(); + param.range = 1; + return player.getBoard().get4Ways(position, param); + } + + @Override + public void attack() { + super.attack(); + RequestRegionalAttack(player, attack).from(this).to(getAttackRange(), 1); + } + + @Override + public ArrayList attack(ArrayList targets, AttackParam param) { + int hp = param.hp; + ArrayList affected = new ArrayList<>(); + Gameboard gameboard = player.getBoard(); + for(Point p:targets) { + try { + Damageable target = gameboard.getObjectOn(p.x, p.y); + if(target.getHp() <= 2) { + target.die(); + } else if(param.realDamage) { + target.realDamage(hp); + } else { + target.attacked(this, hp); + } + affected.add(target); + ((WarObject)target).addStatus(Status.ATTACKED); + } catch (IllegalArgumentException e) { + System.out.println(e.toString()); + } + } + return affected; + } +} From e542ac30edefc56108b9604795758f047bcc4b27 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Thu, 21 May 2020 23:36:45 +0800 Subject: [PATCH 02/22] added FrenzyCommander --- .../summon/FrenzyCommanderSummon.java | 37 +++++++++++++ src/main/java/eod/effect/Summon.java | 4 ++ .../concrete/red/FrenzyCommander.java | 52 +++++++++++++++++++ 3 files changed, 93 insertions(+) create mode 100644 src/main/java/eod/card/concrete/summon/FrenzyCommanderSummon.java create mode 100644 src/main/java/eod/warObject/character/concrete/red/FrenzyCommander.java diff --git a/src/main/java/eod/card/concrete/summon/FrenzyCommanderSummon.java b/src/main/java/eod/card/concrete/summon/FrenzyCommanderSummon.java new file mode 100644 index 0000000..361123c --- /dev/null +++ b/src/main/java/eod/card/concrete/summon/FrenzyCommanderSummon.java @@ -0,0 +1,37 @@ +package eod.card.concrete.summon; + +import eod.Party; +import eod.card.abstraction.Card; +import eod.card.abstraction.summon.SummonCard; +import eod.card.abstraction.summon.SummonCardType; +import eod.warObject.character.concrete.red.FrenzyCommander; + +import static eod.effect.EffectFunctions.Summon; + +public class FrenzyCommanderSummon extends SummonCard { + public FrenzyCommanderSummon() { + super(6, SummonCardType.NORMAL); + } + + @Override + public void summon() { + Summon(player, new FrenzyCommander(player)).from(player.getBaseEmpty()); + } + + @Override + public Card copy() { + Card c = new FrenzyCommanderSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "召喚 暴亂司令"; + } + + @Override + public Party getParty() { + return Party.RED; + } +} diff --git a/src/main/java/eod/effect/Summon.java b/src/main/java/eod/effect/Summon.java index 40ed748..57c5a86 100644 --- a/src/main/java/eod/effect/Summon.java +++ b/src/main/java/eod/effect/Summon.java @@ -32,6 +32,10 @@ public Player getPlayer() { return player; } + public WarObject getObject() { + return object; + } + @Override public void teardown() { player = null; diff --git a/src/main/java/eod/warObject/character/concrete/red/FrenzyCommander.java b/src/main/java/eod/warObject/character/concrete/red/FrenzyCommander.java new file mode 100644 index 0000000..15de99f --- /dev/null +++ b/src/main/java/eod/warObject/character/concrete/red/FrenzyCommander.java @@ -0,0 +1,52 @@ +package eod.warObject.character.concrete.red; + +import eod.Gameboard; +import eod.Party; +import eod.Player; +import eod.card.abstraction.summon.SummonCard; +import eod.card.concrete.summon.FrenzyCommanderSummon; +import eod.effect.Summon; +import eod.exceptions.NotSupportedException; +import eod.param.PointParam; +import eod.warObject.WarObject; +import eod.warObject.character.abstraction.Character; + +import java.awt.*; +import java.util.ArrayList; + +import static eod.effect.EffectFunctions.Summon; + +public class FrenzyCommander extends Character { + public FrenzyCommander(Player player) { + super(player, 3, 3, Party.RED); + } + + @Override + public SummonCard getSummonCard() { + SummonCard c = new FrenzyCommanderSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "暴亂司令"; + } + + @Override + public void attack() { + super.attack(); + Summon s = Summon(player, new Gangster(player)); + s.from(getAttackRange()); + Gangster g = (Gangster) s.getObject(); + g.addHealth(2); + g.addAttack(2); + } + + @Override + public ArrayList getAttackRange() { + PointParam param = new PointParam(); + param.emptySpace = true; + return player.getBoard().allSpaces(new Point(Gameboard.firstLine, 0), param); + } +} From 29ed5a89bdcb5e65e2d809489b01622a04a7d199 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Thu, 21 May 2020 23:53:03 +0800 Subject: [PATCH 03/22] added CrazyBomber --- .../concrete/summon/CrazyBomberSummon.java | 37 ++++++++ .../character/concrete/red/CrazyBomber.java | 86 +++++++++++++++++++ 2 files changed, 123 insertions(+) create mode 100644 src/main/java/eod/card/concrete/summon/CrazyBomberSummon.java create mode 100644 src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java diff --git a/src/main/java/eod/card/concrete/summon/CrazyBomberSummon.java b/src/main/java/eod/card/concrete/summon/CrazyBomberSummon.java new file mode 100644 index 0000000..c69bde9 --- /dev/null +++ b/src/main/java/eod/card/concrete/summon/CrazyBomberSummon.java @@ -0,0 +1,37 @@ +package eod.card.concrete.summon; + +import eod.Party; +import eod.card.abstraction.Card; +import eod.card.abstraction.summon.SummonCard; +import eod.card.abstraction.summon.SummonCardType; +import eod.warObject.character.concrete.red.CrazyBomber; + +import static eod.effect.EffectFunctions.Summon; + +public class CrazyBomberSummon extends SummonCard { + public CrazyBomberSummon() { + super(3, SummonCardType.NORMAL); + } + + @Override + public void summon() { + Summon(player, new CrazyBomber(player)).from(player.getBaseEmpty()); + } + + @Override + public Card copy() { + Card c = new CrazyBomberSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "召喚 瘋狂炸彈客"; + } + + @Override + public Party getParty() { + return Party.RED; + } +} diff --git a/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java b/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java new file mode 100644 index 0000000..5816d25 --- /dev/null +++ b/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java @@ -0,0 +1,86 @@ +package eod.warObject.character.concrete.red; + +import eod.Gameboard; +import eod.Party; +import eod.Player; +import eod.card.abstraction.summon.SummonCard; +import eod.card.concrete.summon.CrazyBomberSummon; +import eod.effect.RegionalAttack; +import eod.exceptions.NotSupportedException; +import eod.param.PointParam; +import eod.warObject.Damageable; +import eod.warObject.character.abstraction.Character; + +import java.awt.*; +import java.util.ArrayList; + +import static eod.effect.EffectFunctions.RequestRegionalAttack; + +public class CrazyBomber extends Character { + public CrazyBomber(Player player) { + super(player, 1, 2, Party.RED); + } + + @Override + public SummonCard getSummonCard() { + SummonCard c = new CrazyBomberSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "瘋狂炸彈客"; + } + + @Override + public ArrayList getAttackRange() { + return player.getBoard().allSpaces(new Point(Gameboard.firstLine, 0), new PointParam()); + } + + @Override + public void attack() { + super.attack(); + Point p = player.selectPosition(getAttackRange()); + + ArrayList singleTarget = new ArrayList<>(); + singleTarget.add(p); + RequestRegionalAttack(player, 1).from(this).to(singleTarget); + + PointParam param = new PointParam(); + param.range = 1; + SpecialRegionalAttack SRA = (SpecialRegionalAttack) RequestRegionalAttack(player, 1); + SRA.to(player.getBoard().getSurrounding(p, param)); + } + + @Override + public void die() { + PointParam param = new PointParam(); + param.range = 1; + SpecialRegionalAttack SRA = (SpecialRegionalAttack) RequestRegionalAttack(player, 3).from(this); + SRA.to(player.getBoard().getSurrounding(position, param)); + player.loseObject(this); + teardown(); + } + + public class SpecialRegionalAttack extends RegionalAttack { + + public SpecialRegionalAttack(Player player, int hp) { + super(player, hp); + } + + @Override + public RegionalAttack to(ArrayList targets) { + Gameboard board = player.getBoard(); + for(Point p:targets) { + try { + Damageable target = board.getObjectOn(p.x, p.y); + target.damage(param.hp); + } catch (IllegalArgumentException e) { + System.out.println("There's no object on the point, skipping."); + } + } + return this; + } + } +} From 55e010680417d50cf1e314e8dff20db69dfaffa5 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Fri, 22 May 2020 10:04:32 +0800 Subject: [PATCH 04/22] added ExperiencedWarrior and AssaultDirector --- src/main/java/eod/BoardPosition.java | 8 +++ src/main/java/eod/Gameboard.java | 30 +++++++++ src/main/java/eod/Player.java | 8 +++ .../summon/AssaultDirectorSummon.java | 37 +++++++++++ .../summon/ExperiencedWarriorSummon.java | 37 +++++++++++ src/main/java/eod/warObject/WarObject.java | 4 ++ .../concrete/red/AssaultDirector.java | 65 +++++++++++++++++++ .../concrete/red/ExperiencedWarrior.java | 25 +++++++ .../character/concrete/red/Gangster.java | 12 ++++ 9 files changed, 226 insertions(+) create mode 100644 src/main/java/eod/BoardPosition.java create mode 100644 src/main/java/eod/card/concrete/summon/AssaultDirectorSummon.java create mode 100644 src/main/java/eod/card/concrete/summon/ExperiencedWarriorSummon.java create mode 100644 src/main/java/eod/warObject/character/concrete/red/AssaultDirector.java create mode 100644 src/main/java/eod/warObject/character/concrete/red/ExperiencedWarrior.java diff --git a/src/main/java/eod/BoardPosition.java b/src/main/java/eod/BoardPosition.java new file mode 100644 index 0000000..7e78179 --- /dev/null +++ b/src/main/java/eod/BoardPosition.java @@ -0,0 +1,8 @@ +package eod; + +public enum BoardPosition { + SELF_BASE, + ENEMY_BASE, + SELF_CONFLICT, + ENEMY_CONFLICT +} diff --git a/src/main/java/eod/Gameboard.java b/src/main/java/eod/Gameboard.java index bca021d..f67ce81 100644 --- a/src/main/java/eod/Gameboard.java +++ b/src/main/java/eod/Gameboard.java @@ -82,6 +82,30 @@ public void removeObject(int x, int y) throws IllegalArgumentException { board[x][y] = null; } + public BoardPosition getPosition(Player player, Point p) { + if(player.isPlayerA()) { + if(p.x < firstLine) { + return BoardPosition.SELF_BASE; + } else if(p.x < middle) { + return BoardPosition.SELF_CONFLICT; + } else if(p.x < secondLine) { + return BoardPosition.ENEMY_CONFLICT; + } else { + return BoardPosition.ENEMY_BASE; + } + } else { + if(p.x >= secondLine) { + return BoardPosition.SELF_BASE; + } else if(p.x >= middle) { + return BoardPosition.SELF_CONFLICT; + } else if(p.x >= firstLine) { + return BoardPosition.ENEMY_CONFLICT; + } else { + return BoardPosition.ENEMY_BASE; + } + } + } + public ArrayList getPlayersConflict(Player player, PointParam param) { int iMin, iMax; if(player.isPlayerA()) { @@ -245,6 +269,12 @@ public void summonObject(WarObject object, Point point) throws IllegalArgumentEx object.updatePosition(point); } + public void transfer(WarObject from, WarObject to) { + Point p = new Point(from.position.x, from.position.y); + board[p.x][p.y] = to; + to.updatePosition(p); + } + @Override public void teardown() { game = null; diff --git a/src/main/java/eod/Player.java b/src/main/java/eod/Player.java index c5df0ae..c74cc28 100644 --- a/src/main/java/eod/Player.java +++ b/src/main/java/eod/Player.java @@ -209,6 +209,10 @@ public void summonObject(WarObject object, Point point) { getBoard().summonObject(object, point); } + public void transferObjectTo(WarObject from, WarObject to) { + getBoard().transfer(from, to); + } + @Override public void teardown() { hand.teardown(); @@ -313,6 +317,10 @@ public ArrayList getFront(Point p, PointParam param) { return getBoard().getLine(p, dx, 0, param); } + public BoardPosition getPosition(Point p) { + return getBoard().getPosition(this, p); + } + public void registerListener(EventListener listener) { game.registerListener(listener); } diff --git a/src/main/java/eod/card/concrete/summon/AssaultDirectorSummon.java b/src/main/java/eod/card/concrete/summon/AssaultDirectorSummon.java new file mode 100644 index 0000000..e8f1955 --- /dev/null +++ b/src/main/java/eod/card/concrete/summon/AssaultDirectorSummon.java @@ -0,0 +1,37 @@ +package eod.card.concrete.summon; + +import eod.Party; +import eod.card.abstraction.Card; +import eod.card.abstraction.summon.SummonCard; +import eod.card.abstraction.summon.SummonCardType; +import eod.warObject.character.concrete.red.AssaultDirector; + +import static eod.effect.EffectFunctions.Summon; + +public class AssaultDirectorSummon extends SummonCard { + public AssaultDirectorSummon() { + super(3, SummonCardType.NORMAL); + } + + @Override + public void summon() { + Summon(player, new AssaultDirector(player)).from(player.getBaseEmpty()); + } + + @Override + public Card copy() { + Card c = new AssaultTeamLeaderSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "召喚 突擊指揮"; + } + + @Override + public Party getParty() { + return Party.RED; + } +} diff --git a/src/main/java/eod/card/concrete/summon/ExperiencedWarriorSummon.java b/src/main/java/eod/card/concrete/summon/ExperiencedWarriorSummon.java new file mode 100644 index 0000000..03848c3 --- /dev/null +++ b/src/main/java/eod/card/concrete/summon/ExperiencedWarriorSummon.java @@ -0,0 +1,37 @@ +package eod.card.concrete.summon; + +import eod.Party; +import eod.card.abstraction.Card; +import eod.card.abstraction.summon.SummonCard; +import eod.card.abstraction.summon.SummonCardType; +import eod.warObject.character.concrete.red.ExperiencedWarrior; + +import static eod.effect.EffectFunctions.Summon; + +public class ExperiencedWarriorSummon extends SummonCard { + public ExperiencedWarriorSummon() { + super(3, SummonCardType.TOKEN); + } + + @Override + public void summon() { + Summon(player, new ExperiencedWarrior(player)).from(player.getBaseEmpty()); + } + + @Override + public Card copy() { + Card c = new ExperiencedWarriorSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "召喚 身經百戰的戰士"; + } + + @Override + public Party getParty() { + return Party.RED; + } +} diff --git a/src/main/java/eod/warObject/WarObject.java b/src/main/java/eod/warObject/WarObject.java index 9d00417..427084d 100644 --- a/src/main/java/eod/warObject/WarObject.java +++ b/src/main/java/eod/warObject/WarObject.java @@ -101,4 +101,8 @@ public void teardown() { player = null; canHandle.clear(); } + + public void transferTo(WarObject object) { + player.transferObjectTo(this, object); + } } diff --git a/src/main/java/eod/warObject/character/concrete/red/AssaultDirector.java b/src/main/java/eod/warObject/character/concrete/red/AssaultDirector.java new file mode 100644 index 0000000..6fc6d50 --- /dev/null +++ b/src/main/java/eod/warObject/character/concrete/red/AssaultDirector.java @@ -0,0 +1,65 @@ +package eod.warObject.character.concrete.red; + +import eod.BoardPosition; +import eod.Gameboard; +import eod.Party; +import eod.Player; +import eod.card.abstraction.summon.SummonCard; +import eod.card.concrete.summon.AssaultDirectorSummon; +import eod.param.PointParam; +import eod.warObject.character.abstraction.Character; + +import java.awt.*; +import java.util.ArrayList; + +import static eod.specifier.WarObjectSpecifier.WarObject; +import static eod.specifier.condition.Conditions.Being; +import static eod.specifier.condition.Conditions.OwnedBy; + +public class AssaultDirector extends Character { + public AssaultDirector(Player player) { + super(player, 2, 1, Party.RED); + } + + @Override + public SummonCard getSummonCard() { + SummonCard c = new AssaultDirectorSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "突擊指揮"; + } + + @Override + public void attack() { + super.attack(); + + Gameboard board = player.getBoard(); + PointParam param = new PointParam(); + param.range = 1; + + Gangster gangster = (Gangster) player.selectObject(WarObject(board).which(OwnedBy(player)).which(Being(Gangster.class)).get()); + do { + ArrayList front = player.getFront(gangster.position, param); + if(front.size() == 0) { + break; + } + Point p = front.get(0); + if(board.hasObjectOn(p.x, p.y)) { + gangster.addAttack(1); + gangster.addHealth(1); + if(player.getPosition(position) == BoardPosition.ENEMY_BASE) { + gangster.addAttack(2); + gangster.addHealth(2); + } + gangster.attack(); + break; + } else { + gangster.moveTo(p); + } + } while (true); + } +} diff --git a/src/main/java/eod/warObject/character/concrete/red/ExperiencedWarrior.java b/src/main/java/eod/warObject/character/concrete/red/ExperiencedWarrior.java new file mode 100644 index 0000000..c5714cf --- /dev/null +++ b/src/main/java/eod/warObject/character/concrete/red/ExperiencedWarrior.java @@ -0,0 +1,25 @@ +package eod.warObject.character.concrete.red; + +import eod.Party; +import eod.Player; +import eod.card.abstraction.summon.SummonCard; +import eod.card.concrete.summon.ExperiencedWarriorSummon; +import eod.warObject.character.abstraction.assaulter.Fighter; + +public class ExperiencedWarrior extends Fighter { + public ExperiencedWarrior(Player player) { + super(player, 5, 5, Party.RED); + } + + @Override + public SummonCard getSummonCard() { + SummonCard c = new ExperiencedWarriorSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "身經百戰的戰士"; + } +} diff --git a/src/main/java/eod/warObject/character/concrete/red/Gangster.java b/src/main/java/eod/warObject/character/concrete/red/Gangster.java index 0d1f323..0b66c62 100644 --- a/src/main/java/eod/warObject/character/concrete/red/Gangster.java +++ b/src/main/java/eod/warObject/character/concrete/red/Gangster.java @@ -1,5 +1,7 @@ package eod.warObject.character.concrete.red; +import eod.BoardPosition; +import eod.Gameboard; import eod.Party; import eod.Player; import eod.card.abstraction.summon.SummonCard; @@ -9,6 +11,8 @@ import eod.param.PointParam; import eod.warObject.character.abstraction.Character; +import java.awt.*; + import static eod.effect.EffectFunctions.RequestRegionalAttack; public class Gangster extends Character { @@ -35,4 +39,12 @@ public void attack() { param.range = 1; RequestRegionalAttack(player, attack).from(this).to(player.getFront(position, param)); } + + @Override + public void moveTo(Point point) { + super.moveTo(point); + if(player.getPosition(position) == BoardPosition.ENEMY_BASE && (position.x == 0 || position.x == Gameboard.boardSize - 1)) { + transferTo(new ExperiencedWarrior(player)); + } + } } From f9ff6cf9bd92ae904d74246ce524a9160ea100f9 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Fri, 22 May 2020 10:25:26 +0800 Subject: [PATCH 05/22] card updates --- .../eod/card/concrete/normal/GrandFeast.java | 34 ++++++------------- .../eod/specifier/condition/Conditions.java | 5 +++ .../specifier/condition/PartyCondition.java | 20 +++++++++++ src/main/java/eod/warObject/WarObject.java | 9 ++++- .../character/abstraction/Character.java | 16 +++++---- .../character/concrete/red/CrazyBomber.java | 2 +- 6 files changed, 53 insertions(+), 33 deletions(-) create mode 100644 src/main/java/eod/specifier/condition/PartyCondition.java diff --git a/src/main/java/eod/card/concrete/normal/GrandFeast.java b/src/main/java/eod/card/concrete/normal/GrandFeast.java index 3c60d38..4d7e579 100644 --- a/src/main/java/eod/card/concrete/normal/GrandFeast.java +++ b/src/main/java/eod/card/concrete/normal/GrandFeast.java @@ -1,18 +1,21 @@ package eod.card.concrete.normal; -import eod.GameObject; import eod.Party; -import eod.Player; import eod.card.abstraction.Card; import eod.card.abstraction.action.NormalCard; import eod.event.AttackEvent; import eod.event.Event; import eod.event.RoundEndEvent; -import eod.event.listener.EventListener; +import eod.warObject.Status; +import eod.warObject.WarObject; +import eod.warObject.character.abstraction.Character; import java.util.ArrayList; -public class GrandFeast extends NormalCard implements EventListener { +import static eod.specifier.WarObjectSpecifier.WarObject; +import static eod.specifier.condition.Conditions.*; + +public class GrandFeast extends NormalCard { ArrayList> canHandle; @@ -25,7 +28,9 @@ public GrandFeast() { @Override public void applyEffect() { - player.registerListener(this); + for(WarObject object:WarObject (player.getBoard()).which(OwnedBy(player)).which(Being(Character.class)).which(InParty(Party.RED)).get()) { + object.addStatus(Status.FURIOUS); + } } @Override @@ -45,25 +50,6 @@ public Party getParty() { return Party.RED; } - @Override - public ArrayList> supportedEventTypes() { - return canHandle; - } - - @Override - public void onEventOccurred(GameObject sender, Event event) { - if (event instanceof AttackEvent) { - AttackEvent e = (AttackEvent) event; - if(e.getSender().isPlayerA() == player.isPlayerA()) { - e.param.hp *= 2; - } - } - else if (event instanceof RoundEndEvent) { - player.unregisterListener(this); - teardown(); - } - } - @Override public void teardown() { super.teardown(); diff --git a/src/main/java/eod/specifier/condition/Conditions.java b/src/main/java/eod/specifier/condition/Conditions.java index ab853ca..44cacba 100644 --- a/src/main/java/eod/specifier/condition/Conditions.java +++ b/src/main/java/eod/specifier/condition/Conditions.java @@ -1,5 +1,6 @@ package eod.specifier.condition; +import eod.Party; import eod.Player; import eod.warObject.CanAttack; import eod.warObject.Status; @@ -31,4 +32,8 @@ public static InAttackRangeCondition InRangeOf(CanAttack center) { public static ExcludeStatusCondition WithoutStatus(Status status) { return new ExcludeStatusCondition(status); } + + public static PartyCondition InParty(Party party) { + return new PartyCondition(party); + } } diff --git a/src/main/java/eod/specifier/condition/PartyCondition.java b/src/main/java/eod/specifier/condition/PartyCondition.java new file mode 100644 index 0000000..437a45a --- /dev/null +++ b/src/main/java/eod/specifier/condition/PartyCondition.java @@ -0,0 +1,20 @@ +package eod.specifier.condition; + +import eod.Party; +import eod.warObject.WarObject; + +import java.util.Arrays; + +public class PartyCondition implements Condition { + private Party party; + public PartyCondition(Party party) { + this.party = party; + } + + @Override + public WarObject[] filter(WarObject[] objects) { + return Arrays.stream(objects) + .filter(object -> object.getParty() == party) + .toArray(WarObject[]::new); + } +} diff --git a/src/main/java/eod/warObject/WarObject.java b/src/main/java/eod/warObject/WarObject.java index 427084d..ccf74f5 100644 --- a/src/main/java/eod/warObject/WarObject.java +++ b/src/main/java/eod/warObject/WarObject.java @@ -3,6 +3,7 @@ import eod.GameObject; import eod.Gameboard; +import eod.Party; import eod.Player; import eod.event.Event; import eod.event.listener.EventListener; @@ -16,11 +17,13 @@ public abstract class WarObject implements GameObject, EventListener { public Point position; protected Player player; + protected final Party party; ArrayList status; protected ArrayList> canHandle; - public WarObject(Player player) { + public WarObject(Player player, Party party) { this.player = player; + this.party = party; canHandle = new ArrayList<>(); } @@ -32,6 +35,10 @@ public Point getPosition() { return position; } + public Party getParty() { + return party; + } + protected void move() { PointParam param = new PointParam(); param.range = 1; diff --git a/src/main/java/eod/warObject/character/abstraction/Character.java b/src/main/java/eod/warObject/character/abstraction/Character.java index 71e2ef5..4cb0b5c 100644 --- a/src/main/java/eod/warObject/character/abstraction/Character.java +++ b/src/main/java/eod/warObject/character/abstraction/Character.java @@ -20,16 +20,14 @@ public abstract class Character extends WarObject implements Damageable, CanAtta protected int max_hp; protected int hp; protected int attack; - protected final Party party; protected CanAttack attacker; public Character(Player player, int hp, int attack, Party party) { - super(player); + super(player, party); this.player = player; max_hp = hp; this.hp = max_hp; this.attack = attack; - this.party = party; } @Override @@ -81,6 +79,7 @@ public ArrayList attack(ArrayList targets, AttackParam param) System.out.println(e.toString()); } } + afterAttack(); return affected; } @@ -103,9 +102,16 @@ public ArrayList attack(Damageable[] targets, AttackParam param) { affected.add(target); ((WarObject)target).addStatus(Status.ATTACKED); }); + afterAttack(); return affected; } + protected void afterAttack() { + if(status.contains(Status.FURIOUS)) { + damage(1); + } + } + @Override public void realDamage(int val) { hp -= val; @@ -143,10 +149,6 @@ public void teardown() { status.clear(); } - public Party getParty() { - return party; - } - @Override public int getHp() { return hp; diff --git a/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java b/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java index 5816d25..85b386b 100644 --- a/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java +++ b/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java @@ -45,7 +45,7 @@ public void attack() { ArrayList singleTarget = new ArrayList<>(); singleTarget.add(p); - RequestRegionalAttack(player, 1).from(this).to(singleTarget); + RequestRegionalAttack(player, attack).from(this).to(singleTarget); PointParam param = new PointParam(); param.range = 1; From f3437c1c2aeebeb07eeff373c8ee3294b24e9774 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Fri, 22 May 2020 10:39:53 +0800 Subject: [PATCH 06/22] added BloodThirstFighter --- .../summon/BloodThirstFighterSummon.java | 46 +++++++++++++ .../concrete/red/BloodThirstFighter.java | 68 +++++++++++++++++++ 2 files changed, 114 insertions(+) create mode 100644 src/main/java/eod/card/concrete/summon/BloodThirstFighterSummon.java create mode 100644 src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java diff --git a/src/main/java/eod/card/concrete/summon/BloodThirstFighterSummon.java b/src/main/java/eod/card/concrete/summon/BloodThirstFighterSummon.java new file mode 100644 index 0000000..167c1f9 --- /dev/null +++ b/src/main/java/eod/card/concrete/summon/BloodThirstFighterSummon.java @@ -0,0 +1,46 @@ +package eod.card.concrete.summon; + +import eod.Party; +import eod.card.abstraction.Card; +import eod.card.abstraction.summon.SummonCard; +import eod.card.abstraction.summon.SummonCardType; +import eod.warObject.character.concrete.red.BloodThirstFighter; + +import java.awt.*; +import java.util.ArrayList; + +import static eod.effect.EffectFunctions.Summon; + +public class BloodThirstFighterSummon extends SummonCard { + public BloodThirstFighterSummon() { + super(5, SummonCardType.NORMAL); + } + + @Override + public void summon() { + Summon(player, new BloodThirstFighter(player)).from(baseAndConflict()); + } + + @Override + public Card copy() { + Card c = new BloodThirstFighterSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "召喚 嗜血的戰鬥狂"; + } + + @Override + public Party getParty() { + return Party.RED; + } + + private ArrayList baseAndConflict() { + ArrayList points = player.getBaseEmpty(); + points.addAll(player.getConflictEmpty()); + return points; + } +} diff --git a/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java b/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java new file mode 100644 index 0000000..81bc28d --- /dev/null +++ b/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java @@ -0,0 +1,68 @@ +package eod.warObject.character.concrete.red; + +import eod.GameObject; +import eod.Party; +import eod.Player; +import eod.card.abstraction.summon.SummonCard; +import eod.card.concrete.summon.BloodThirstFighterSummon; +import eod.effect.RegionalAttack; +import eod.event.Event; +import eod.event.ObjectEnterEvent; +import eod.param.PointParam; +import eod.warObject.Damageable; +import eod.warObject.character.abstraction.assaulter.Fighter; + +import java.awt.*; +import java.util.ArrayList; + +import static eod.effect.EffectFunctions.RequestRegionalAttack; + +public class BloodThirstFighter extends Fighter { + public BloodThirstFighter(Player player) { + super(player, 4, 3, Party.RED); + } + + @Override + public SummonCard getSummonCard() { + SummonCard c = new BloodThirstFighterSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "嗜血的戰鬥狂"; + } + + @Override + public void attack() { + super.attack(); + RegionalAttack a = RequestRegionalAttack(player, attack).from(this).to(getAttackRange(), 1); + for(Damageable victim:a.getAffected()) { + if(victim.getHp() <= 0) { + addAttack(1); + addHealth(1); + attack(); + break; + } + } + } + + @Override + public ArrayList getAttackRange() { + PointParam param = new PointParam(); + param.range = 1; + return player.getBoard().get4Ways(position, param); + } + + @Override + public void onEventOccurred(GameObject sender, Event event) { + super.onEventOccurred(sender, event); + if(event instanceof ObjectEnterEvent) { + ObjectEnterEvent e = (ObjectEnterEvent) event; + if(e.getObject() == this) { + attack(); + } + } + } +} From ec22e1ab723121db9e890446ce61bb768d6397f5 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Fri, 22 May 2020 10:42:44 +0800 Subject: [PATCH 07/22] fixed Repairman --- .../java/eod/warObject/character/concrete/blue/Repairman.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/main/java/eod/warObject/character/concrete/blue/Repairman.java b/src/main/java/eod/warObject/character/concrete/blue/Repairman.java index db383c1..2514584 100644 --- a/src/main/java/eod/warObject/character/concrete/blue/Repairman.java +++ b/src/main/java/eod/warObject/character/concrete/blue/Repairman.java @@ -46,8 +46,6 @@ public void attack() { machine.addHealth(1); machine.addAttack(1); }); - - RequestRegionalAttack(player, attack).from(this).to(getAttackRange()); } @Override From 2603b591c65ca60f31286daf3a83ebaac65287c7 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Fri, 22 May 2020 23:45:50 +0800 Subject: [PATCH 08/22] bug fix --- .../java/eod/warObject/character/concrete/red/CrazyBomber.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java b/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java index 85b386b..b14f734 100644 --- a/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java +++ b/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java @@ -49,7 +49,7 @@ public void attack() { PointParam param = new PointParam(); param.range = 1; - SpecialRegionalAttack SRA = (SpecialRegionalAttack) RequestRegionalAttack(player, 1); + SpecialRegionalAttack SRA = new SpecialRegionalAttack(player, 1); SRA.to(player.getBoard().getSurrounding(p, param)); } From 02fd73b2c717970ad55c5bad83fe3a701da8e86c Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Sat, 23 May 2020 14:59:10 +0800 Subject: [PATCH 09/22] fixed PreciseShot, Snipe and Sundar. --- .../card/concrete/attack/transparent/PreciseShot.java | 2 +- .../eod/card/concrete/attack/transparent/Snipe.java | 10 +++++++++- src/main/java/eod/warObject/leader/red/Sundar.java | 1 + 3 files changed, 11 insertions(+), 2 deletions(-) diff --git a/src/main/java/eod/card/concrete/attack/transparent/PreciseShot.java b/src/main/java/eod/card/concrete/attack/transparent/PreciseShot.java index 925b71d..2f90348 100644 --- a/src/main/java/eod/card/concrete/attack/transparent/PreciseShot.java +++ b/src/main/java/eod/card/concrete/attack/transparent/PreciseShot.java @@ -27,7 +27,7 @@ public void attack() { .from( characters.which(OwnedBy(player)).which(Being(Shooter.class)).get() ); - attack.to(characters.which(OwnedBy(rival)).which(InRangeOf(attack.attacker())).which(WithoutStatus(Status.SNEAK)).get()); + attack.realDamage().to(characters.which(OwnedBy(rival)).which(InRangeOf(attack.attacker())).which(WithoutStatus(Status.SNEAK)).get()); } @Override diff --git a/src/main/java/eod/card/concrete/attack/transparent/Snipe.java b/src/main/java/eod/card/concrete/attack/transparent/Snipe.java index 1345171..db9c2f0 100644 --- a/src/main/java/eod/card/concrete/attack/transparent/Snipe.java +++ b/src/main/java/eod/card/concrete/attack/transparent/Snipe.java @@ -31,10 +31,18 @@ public Card copy() { public void attack() { Accessing objects = WarObject(player.getBoard()); WarObject[] ownedSnipers = objects.which(OwnedBy(player)).which(Being(Sniper.class)).get(); - RegionalAttack attack = RequestRegionalAttack(player, 8).from(ownedSnipers); + RegionalAttack attack = RequestRegionalAttack(player, decideAttack(ownedSnipers)).from(ownedSnipers); attack.to(objects.which(OwnedBy(rival)).which(InRangeOf(attack.attacker())).which(Being(Damageable.class)).which(WithoutStatus(Status.SNEAK)).get()); } + private int decideAttack(WarObject[] snipers) { + if(snipers.length >= 2) { + return 8; + } else { + return 6; + } + } + @Override public String getName() { return "狙殺"; diff --git a/src/main/java/eod/warObject/leader/red/Sundar.java b/src/main/java/eod/warObject/leader/red/Sundar.java index f8b3ab7..caffaa6 100644 --- a/src/main/java/eod/warObject/leader/red/Sundar.java +++ b/src/main/java/eod/warObject/leader/red/Sundar.java @@ -51,6 +51,7 @@ public void deathPulse() { ArrayList targets = player.getBoard().get8ways(position, pointParam); AttackParam attackParam = new AttackParam(); attackParam.hp = 4; + attackParam.realDamage = true; attack(targets, attackParam); } From 07b9a87fcf1bee58cd5576f971ae912e2cb21cc5 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Sat, 23 May 2020 15:06:42 +0800 Subject: [PATCH 10/22] added OwnerlessAssassin --- .../summon/OwnerlessAssassinSummon.java | 37 ++++++++++++++ .../transparent/OwnerlessAssassin.java | 49 +++++++++++++++++++ 2 files changed, 86 insertions(+) create mode 100644 src/main/java/eod/card/concrete/summon/OwnerlessAssassinSummon.java create mode 100644 src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java diff --git a/src/main/java/eod/card/concrete/summon/OwnerlessAssassinSummon.java b/src/main/java/eod/card/concrete/summon/OwnerlessAssassinSummon.java new file mode 100644 index 0000000..b0e3f9f --- /dev/null +++ b/src/main/java/eod/card/concrete/summon/OwnerlessAssassinSummon.java @@ -0,0 +1,37 @@ +package eod.card.concrete.summon; + +import eod.Party; +import eod.card.abstraction.Card; +import eod.card.abstraction.summon.SummonCard; +import eod.card.abstraction.summon.SummonCardType; +import eod.warObject.character.concrete.transparent.OwnerlessAssassin; + +import static eod.effect.EffectFunctions.Summon; + +public class OwnerlessAssassinSummon extends SummonCard { + public OwnerlessAssassinSummon() { + super(2, SummonCardType.NORMAL); + } + + @Override + public void summon() { + Summon(player, new OwnerlessAssassin(player)).from(player.getBaseEmpty()); + } + + @Override + public Card copy() { + Card c = new OwnerlessAssassinSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "召喚 無主的殺手"; + } + + @Override + public Party getParty() { + return Party.TRANSPARENT; + } +} diff --git a/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java b/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java new file mode 100644 index 0000000..e0cec2e --- /dev/null +++ b/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java @@ -0,0 +1,49 @@ +package eod.warObject.character.concrete.transparent; + +import eod.GameObject; +import eod.Party; +import eod.Player; +import eod.card.abstraction.summon.SummonCard; +import eod.card.concrete.summon.OwnerlessAssassinSummon; +import eod.event.Event; +import eod.event.RoundStartEvent; +import eod.param.PointParam; +import eod.warObject.character.abstraction.assaulter.Assassin; + +import java.awt.*; +import java.util.ArrayList; + +public class OwnerlessAssassin extends Assassin { + public OwnerlessAssassin(Player player) { + super(player, 2, 4, Party.TRANSPARENT); + canHandle.add(RoundStartEvent.class); + } + + @Override + public SummonCard getSummonCard() { + SummonCard c = new OwnerlessAssassinSummon(); + c.setPlayer(player); + return c; + } + + @Override + public String getName() { + return "無主的殺手"; + } + + @Override + public ArrayList getAttackRange() { + PointParam param = new PointParam(); + param.range = 1; + return player.getBoard().getSurrounding(position, param); + } + + @Override + public void onEventOccurred(GameObject sender, Event event) { + super.onEventOccurred(sender, event); + if(event instanceof RoundStartEvent) { + RoundStartEvent e = (RoundStartEvent) event; + player = e.getStartedRound().getPlayer(); + } + } +} From 6b7b7759f7044855cb93c357449e255508a2eda4 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Sat, 23 May 2020 15:40:48 +0800 Subject: [PATCH 11/22] added NO_EFFECT in Status --- .../eod/card/concrete/attack/transparent/PreciseShot.java | 2 +- .../java/eod/card/concrete/attack/transparent/Snipe.java | 4 ++-- src/main/java/eod/warObject/Status.java | 2 ++ src/main/java/eod/warObject/WarObject.java | 4 +++- .../warObject/character/concrete/red/AssaultTeamLeader.java | 3 +++ .../warObject/character/concrete/red/BloodThirstFighter.java | 4 ++++ .../character/concrete/transparent/OwnerlessAssassin.java | 4 ++++ .../character/concrete/transparent/Spacezipper.java | 4 ++++ src/main/java/eod/warObject/leader/red/Sundar.java | 5 +++++ 9 files changed, 28 insertions(+), 4 deletions(-) diff --git a/src/main/java/eod/card/concrete/attack/transparent/PreciseShot.java b/src/main/java/eod/card/concrete/attack/transparent/PreciseShot.java index 2f90348..7a5a901 100644 --- a/src/main/java/eod/card/concrete/attack/transparent/PreciseShot.java +++ b/src/main/java/eod/card/concrete/attack/transparent/PreciseShot.java @@ -25,7 +25,7 @@ public void attack() { Accessing characters = WarObject(player.getBoard()).which(Being(Character.class)); RegionalAttack attack = RequestRegionalAttack(player, 3) .from( - characters.which(OwnedBy(player)).which(Being(Shooter.class)).get() + characters.which(OwnedBy(player)).which(Being(Shooter.class)).which(WithoutStatus(Status.CANT_ATTACK)).get() ); attack.realDamage().to(characters.which(OwnedBy(rival)).which(InRangeOf(attack.attacker())).which(WithoutStatus(Status.SNEAK)).get()); } diff --git a/src/main/java/eod/card/concrete/attack/transparent/Snipe.java b/src/main/java/eod/card/concrete/attack/transparent/Snipe.java index db9c2f0..b1ea180 100644 --- a/src/main/java/eod/card/concrete/attack/transparent/Snipe.java +++ b/src/main/java/eod/card/concrete/attack/transparent/Snipe.java @@ -30,8 +30,8 @@ public Card copy() { @Override public void attack() { Accessing objects = WarObject(player.getBoard()); - WarObject[] ownedSnipers = objects.which(OwnedBy(player)).which(Being(Sniper.class)).get(); - RegionalAttack attack = RequestRegionalAttack(player, decideAttack(ownedSnipers)).from(ownedSnipers); + Accessing ownedSnipers = objects.which(OwnedBy(player)).which(Being(Sniper.class)); + RegionalAttack attack = RequestRegionalAttack(player, decideAttack(ownedSnipers.get())).from(ownedSnipers.which(WithoutStatus(Status.CANT_ATTACK)).get()); attack.to(objects.which(OwnedBy(rival)).which(InRangeOf(attack.attacker())).which(Being(Damageable.class)).which(WithoutStatus(Status.SNEAK)).get()); } diff --git a/src/main/java/eod/warObject/Status.java b/src/main/java/eod/warObject/Status.java index 363b1ed..38f88d6 100644 --- a/src/main/java/eod/warObject/Status.java +++ b/src/main/java/eod/warObject/Status.java @@ -7,4 +7,6 @@ public enum Status { DEAD, STABLE, FURIOUS, + CANT_ATTACK, + NO_EFFECT } diff --git a/src/main/java/eod/warObject/WarObject.java b/src/main/java/eod/warObject/WarObject.java index ccf74f5..028118a 100644 --- a/src/main/java/eod/warObject/WarObject.java +++ b/src/main/java/eod/warObject/WarObject.java @@ -85,7 +85,9 @@ public ArrayList> supportedEventTypes() { @Override public void onEventOccurred(GameObject sender, Event event) { - //intended left blank + if(hasStatus(Status.NO_EFFECT)) { + return; + } } public abstract String getName(); diff --git a/src/main/java/eod/warObject/character/concrete/red/AssaultTeamLeader.java b/src/main/java/eod/warObject/character/concrete/red/AssaultTeamLeader.java index 0a250fe..9b60ca2 100644 --- a/src/main/java/eod/warObject/character/concrete/red/AssaultTeamLeader.java +++ b/src/main/java/eod/warObject/character/concrete/red/AssaultTeamLeader.java @@ -56,6 +56,9 @@ public String getName() { @Override public void onEventOccurred(GameObject sender, Event event) { super.onEventOccurred(sender, event); + if(hasStatus(Status.NO_EFFECT)) { + return; + } if(event instanceof ObjectEnterEvent) { if(((ObjectEnterEvent) event).getObject() == this) { addAttack(1); diff --git a/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java b/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java index 81bc28d..7c1c7dd 100644 --- a/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java +++ b/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java @@ -10,6 +10,7 @@ import eod.event.ObjectEnterEvent; import eod.param.PointParam; import eod.warObject.Damageable; +import eod.warObject.Status; import eod.warObject.character.abstraction.assaulter.Fighter; import java.awt.*; @@ -58,6 +59,9 @@ public ArrayList getAttackRange() { @Override public void onEventOccurred(GameObject sender, Event event) { super.onEventOccurred(sender, event); + if(hasStatus(Status.NO_EFFECT)) { + return; + } if(event instanceof ObjectEnterEvent) { ObjectEnterEvent e = (ObjectEnterEvent) event; if(e.getObject() == this) { diff --git a/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java b/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java index e0cec2e..4cce3af 100644 --- a/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java +++ b/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java @@ -8,6 +8,7 @@ import eod.event.Event; import eod.event.RoundStartEvent; import eod.param.PointParam; +import eod.warObject.Status; import eod.warObject.character.abstraction.assaulter.Assassin; import java.awt.*; @@ -41,6 +42,9 @@ public ArrayList getAttackRange() { @Override public void onEventOccurred(GameObject sender, Event event) { super.onEventOccurred(sender, event); + if(hasStatus(Status.NO_EFFECT)) { + return; + } if(event instanceof RoundStartEvent) { RoundStartEvent e = (RoundStartEvent) event; player = e.getStartedRound().getPlayer(); diff --git a/src/main/java/eod/warObject/character/concrete/transparent/Spacezipper.java b/src/main/java/eod/warObject/character/concrete/transparent/Spacezipper.java index 58f7697..bae4aa2 100644 --- a/src/main/java/eod/warObject/character/concrete/transparent/Spacezipper.java +++ b/src/main/java/eod/warObject/character/concrete/transparent/Spacezipper.java @@ -11,6 +11,7 @@ import eod.event.RoundStartEvent; import eod.param.PointParam; import eod.warObject.Marker; +import eod.warObject.Status; import eod.warObject.character.abstraction.Character; import java.awt.*; @@ -68,6 +69,9 @@ public String getName() { @Override public void onEventOccurred(GameObject sender, Event event) { super.onEventOccurred(sender, event); + if (hasStatus(Status.NO_EFFECT)) { + return; + } if(event instanceof RoundStartEvent) { mark(position); move(); diff --git a/src/main/java/eod/warObject/leader/red/Sundar.java b/src/main/java/eod/warObject/leader/red/Sundar.java index caffaa6..bf6dc5b 100644 --- a/src/main/java/eod/warObject/leader/red/Sundar.java +++ b/src/main/java/eod/warObject/leader/red/Sundar.java @@ -11,6 +11,7 @@ import eod.param.PointParam; import eod.warObject.CanAttack; import eod.warObject.Damageable; +import eod.warObject.Status; import eod.warObject.WarObject; import eod.warObject.character.abstraction.other.Ghost; import eod.warObject.character.concrete.red.GhostOfHatred; @@ -99,6 +100,10 @@ protected ArrayList generateCommand() { @Override public void onEventOccurred(GameObject sender, Event event) { + super.onEventOccurred(sender, event); + if(hasStatus(Status.NO_EFFECT)) { + return; + } if (event instanceof ObjectDeadEvent) { Damageable deadObject = ((ObjectDeadEvent) event).getDeadObject(); WarObject object = (WarObject) deadObject; From 8b309d334bd6b791e87f0ecd65ab6fa0c2823580 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Sat, 23 May 2020 19:01:51 +0800 Subject: [PATCH 12/22] added Transfer --- src/main/java/eod/IO/LocalOutput.java | 5 +++++ src/main/java/eod/IO/Output.java | 1 + src/main/java/eod/Player.java | 1 + 3 files changed, 7 insertions(+) diff --git a/src/main/java/eod/IO/LocalOutput.java b/src/main/java/eod/IO/LocalOutput.java index f3636bb..9df1fb7 100644 --- a/src/main/java/eod/IO/LocalOutput.java +++ b/src/main/java/eod/IO/LocalOutput.java @@ -95,6 +95,11 @@ public void sendWarObjectSummoned(WarObject object, Point position) { System.out.println(object.getName() + "被召喚到了" + position.toString() + "的位置"); } + @Override + public void sendWarObjectTransferred(WarObject from, WarObject to) { + System.out.println(from.getName() + "變身為" + to.getName()); + } + @Override public void sendWinning(Player player) { System.out.println(player.getName() + "贏了"); diff --git a/src/main/java/eod/IO/Output.java b/src/main/java/eod/IO/Output.java index 8a5daf0..e125df4 100644 --- a/src/main/java/eod/IO/Output.java +++ b/src/main/java/eod/IO/Output.java @@ -26,6 +26,7 @@ public interface Output { void sendWarObjectDied(WarObject object); void sendWarObjectActivatedEffect(WarObject object); void sendWarObjectSummoned(WarObject object, Point position); + void sendWarObjectTransferred(WarObject from, WarObject to); void sendWinning(Player player); void sendLosing(Player player); diff --git a/src/main/java/eod/Player.java b/src/main/java/eod/Player.java index 646a6c1..5762719 100644 --- a/src/main/java/eod/Player.java +++ b/src/main/java/eod/Player.java @@ -212,6 +212,7 @@ public void summonObject(WarObject object, Point point) { public void transferObjectTo(WarObject from, WarObject to) { getBoard().transfer(from, to); + output.sendWarObjectTransferred(from, to); } @Override From 067a6d2d0e5e16625e6dfb7bd1004d1e00364579 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Sat, 23 May 2020 18:30:35 +0800 Subject: [PATCH 13/22] added eventHandler --- src/main/java/eod/Game.java | 12 +-- src/main/java/eod/Gameboard.java | 2 + src/main/java/eod/Player.java | 45 ++++++++-- .../eod/card/concrete/normal/FightBack.java | 30 +++---- .../java/eod/card/concrete/normal/Sneak.java | 14 ++- .../card/concrete/normal/SupportAttack.java | 14 +-- src/main/java/eod/effect/Summon.java | 1 - .../eod/event/AfterObjectDamageEvent.java | 22 +++++ .../eod/event/BeforeObjectDamageEvent.java | 23 +++++ src/main/java/eod/event/EventManager.java | 31 ------- .../eod/event/ObjectEnterEnemyBaseEvent.java | 15 ++++ .../java/eod/event/ObjectMovingEvent.java | 4 + .../java/eod/event/relay/EventManager.java | 33 +++++++ .../EventReceiver.java} | 5 +- .../java/eod/event/relay/EventSender.java | 14 +++ src/main/java/eod/param/DamageParam.java | 10 +++ src/main/java/eod/warObject/Damageable.java | 7 +- src/main/java/eod/warObject/WarObject.java | 30 ++++++- .../character/abstraction/Character.java | 53 ++++++------ .../character/concrete/blue/HeavyPolice.java | 60 ++++++++++++- .../character/concrete/blue/Repairman.java | 2 + .../character/concrete/blue/SWAT.java | 1 + .../concrete/blue/SecureGuardBot.java | 23 +---- .../concrete/red/AssaultDirector.java | 2 + .../concrete/red/AssaultTeamLeader.java | 86 ++++++++++++------- .../concrete/red/BloodThirstFighter.java | 42 +++++++-- .../character/concrete/red/CrazyBomber.java | 54 +++++++++--- .../concrete/red/ExperiencedWarrior.java | 22 +++++ .../concrete/red/FrenzyCommander.java | 2 + .../character/concrete/red/GangBoss.java | 10 ++- .../character/concrete/red/Gangster.java | 2 + .../concrete/red/GuerrillaShooter.java | 2 + .../character/concrete/red/LeadersGuard.java | 44 +++++++++- .../character/concrete/red/MafiaAssassin.java | 8 +- .../character/concrete/red/Scavenger.java | 16 +++- .../character/concrete/red/ToughGuy.java | 47 ++++++++-- .../character/concrete/transparent/Drone.java | 20 +++-- .../transparent/OwnerlessAssassin.java | 49 +++++++++-- .../concrete/transparent/Spacezipper.java | 51 ++++++++--- .../java/eod/warObject/leader/red/Sundar.java | 81 +++++++++++------ 40 files changed, 736 insertions(+), 253 deletions(-) create mode 100644 src/main/java/eod/event/AfterObjectDamageEvent.java create mode 100644 src/main/java/eod/event/BeforeObjectDamageEvent.java delete mode 100644 src/main/java/eod/event/EventManager.java create mode 100644 src/main/java/eod/event/ObjectEnterEnemyBaseEvent.java create mode 100644 src/main/java/eod/event/relay/EventManager.java rename src/main/java/eod/event/{listener/EventListener.java => relay/EventReceiver.java} (72%) create mode 100644 src/main/java/eod/event/relay/EventSender.java create mode 100644 src/main/java/eod/param/DamageParam.java diff --git a/src/main/java/eod/Game.java b/src/main/java/eod/Game.java index fb7eb08..615dd89 100644 --- a/src/main/java/eod/Game.java +++ b/src/main/java/eod/Game.java @@ -3,10 +3,10 @@ import eod.card.abstraction.Card; import eod.card.abstraction.action.ActionCard; import eod.event.Event; -import eod.event.EventManager; +import eod.event.relay.EventManager; import eod.event.RoundEndEvent; import eod.event.RoundStartEvent; -import eod.event.listener.EventListener; +import eod.event.relay.EventReceiver; import eod.exceptions.GameLosingException; import eod.snapshots.Snapshotted; @@ -152,11 +152,11 @@ public void sendEvent(GameObject sender, Event event) { eventManager.send(sender, event); } - public void registerListener(EventListener listener) { - eventManager.registerListener(listener); + public void registerReceiver(EventReceiver receiver) { + eventManager.registerReceiver(receiver); } - public void unregisterListener(EventListener listener) { - eventManager.unregisterListener(listener); + public void unregisterReceiver(EventReceiver receiver) { + eventManager.unregisterReceiver(receiver); } @Override diff --git a/src/main/java/eod/Gameboard.java b/src/main/java/eod/Gameboard.java index f67ce81..a66e592 100644 --- a/src/main/java/eod/Gameboard.java +++ b/src/main/java/eod/Gameboard.java @@ -1,5 +1,6 @@ package eod; +import eod.event.ObjectEnterEvent; import eod.exceptions.MoveInvalidException; import eod.param.PointParam; import eod.snapshots.Snapshotted; @@ -267,6 +268,7 @@ public void summonObject(WarObject object, Point point) throws IllegalArgumentEx } board[x][y] = object; object.updatePosition(point); + game.sendEvent(object, new ObjectEnterEvent(object)); } public void transfer(WarObject from, WarObject to) { diff --git a/src/main/java/eod/Player.java b/src/main/java/eod/Player.java index c74cc28..3ecc016 100644 --- a/src/main/java/eod/Player.java +++ b/src/main/java/eod/Player.java @@ -7,7 +7,8 @@ import eod.card.collection.Hand; import eod.event.*; import eod.event.Event; -import eod.event.listener.EventListener; +import eod.event.relay.EventReceiver; +import eod.event.relay.EventSender; import eod.exceptions.GameLosingException; import eod.param.PointParam; import eod.snapshots.Snapshotted; @@ -20,7 +21,7 @@ import java.util.*; public class Player implements Snapshotted, - GameObject, EventListener { + GameObject, EventReceiver, EventSender { private Deck deck; private Game game; @@ -30,6 +31,7 @@ public class Player implements Snapshotted, private Output output; private String name; private boolean isPlayerA; + private ArrayList receivers; public Player(Deck deck, String name) { this(deck, new Hand(), name); @@ -39,6 +41,7 @@ public Player(Deck deck, Hand hand, String name) { this.deck = deck; this.hand = hand; this.name = name; + receivers = new ArrayList<>(); } public String getName() { @@ -51,7 +54,7 @@ public void setLeader(Leader leader) { public void attachToGame(Game game) { this.game = game; - game.registerListener(this); + game.registerReceiver(this); } public void attachIO(Input input, Output output) { this.input = input; @@ -221,6 +224,10 @@ public void teardown() { deck = null; leader.teardown(); leader = null; + for(EventReceiver receiver:receivers) { + receiver.teardown(); + } + receivers.clear(); } @Override @@ -269,14 +276,25 @@ public Card selectCard(Card[] cards) { public void moveObject(WarObject object, Point point) { game.getBoard().moveObject(object.position, point); game.sendEvent(this, new ObjectMovingEvent(object, point)); + if(inEnemyBase(object.position)) { + game.sendEvent(this, new ObjectEnterEnemyBaseEvent(object)); + } object.updatePosition(point); } + public boolean inEnemyBase(Point p) { + if(isPlayerA) { + return p.x < Gameboard.firstLine; + } else { + return p.x >= Gameboard.secondLine; + } + } + public void loseObject(WarObject object) { - getBoard().removeObject(object); if(object instanceof Damageable) { game.sendEvent(this, new ObjectDeadEvent((Damageable) object)); } + getBoard().removeObject(object); } public void loseLeader() throws GameLosingException { @@ -321,15 +339,24 @@ public BoardPosition getPosition(Point p) { return getBoard().getPosition(this, p); } - public void registerListener(EventListener listener) { - game.registerListener(listener); + @Override + public void registerReceiver(EventReceiver receiver) { + receivers.add(receiver); + } + + @Override + public void unregisterReceiver(EventReceiver receiver) { + receivers.remove(receiver); } - public void unregisterListener(EventListener listener) { - game.unregisterListener(listener); + @Override + public void send(GameObject sender, Event event) { + receivers.stream() + .filter(receiver -> receiver.supportedEventTypes().contains(event.getClass())) + .forEach(receiver -> receiver.onEventOccurred(sender, event)); } - public void sendEvent(GameObject sender, Event event) { + public void sendUp(GameObject sender, Event event) { game.sendEvent(sender, event); } diff --git a/src/main/java/eod/card/concrete/normal/FightBack.java b/src/main/java/eod/card/concrete/normal/FightBack.java index adca771..27a2af1 100644 --- a/src/main/java/eod/card/concrete/normal/FightBack.java +++ b/src/main/java/eod/card/concrete/normal/FightBack.java @@ -8,15 +8,14 @@ import eod.event.ObjectDeadEvent; import eod.event.RoundEndEvent; import eod.event.TargetedEvent; -import eod.event.listener.EventListener; -import eod.exceptions.NotSupportedException; -import eod.warObject.CanAttack; +import eod.event.relay.EventReceiver; +import eod.param.DamageParam; import eod.warObject.Damageable; import eod.warObject.WarObject; +import eod.warObject.character.abstraction.Character; import java.util.ArrayList; -import static eod.effect.EffectFunctions.RequestDirectAttack; import static eod.specifier.WarObjectSpecifier.WarObject; import static eod.specifier.condition.Conditions.Being; import static eod.specifier.condition.Conditions.OwnedBy; @@ -28,13 +27,11 @@ public FightBack() { @Override public void applyEffect() { - player.registerListener( - new AttackDetect((Damageable) player.selectObject( - WarObject(player.getBoard()) - .which(Being(Damageable.class)) - .which(OwnedBy(player)).get()) - ) - ); + new AttackDetect(player.selectObject( + WarObject(player.getBoard()) + .which(Being(Character.class)) + .which(OwnedBy(player)).get() + )); } @Override @@ -54,12 +51,13 @@ public Party getParty() { return Party.TRANSPARENT; } - public class AttackDetect implements EventListener, GameObject { - private Damageable watching; + public class AttackDetect implements EventReceiver, GameObject { + private WarObject watching; private ArrayList> canHandle; - public AttackDetect(Damageable watching) { + public AttackDetect(WarObject watching) { this.watching = watching; + watching.registerReceiver(this); canHandle = new ArrayList<>(); canHandle.add(ObjectDeadEvent.class); canHandle.add(TargetedEvent.class); @@ -86,7 +84,8 @@ public void onEventOccurred(GameObject sender, Event event) { TargetedEvent e = (TargetedEvent) event; if(e.getTarget() == watching) { Damageable attacker = (Damageable) e.getAttacker(); - attacker.damage(4); + DamageParam param = new DamageParam(4); + attacker.damage(param); } teardown(); } @@ -95,6 +94,7 @@ public void onEventOccurred(GameObject sender, Event event) { @Override public void teardown() { canHandle.clear(); + watching.unregisterReceiver(this); watching = null; } } diff --git a/src/main/java/eod/card/concrete/normal/Sneak.java b/src/main/java/eod/card/concrete/normal/Sneak.java index f4551d1..4a3f0d7 100644 --- a/src/main/java/eod/card/concrete/normal/Sneak.java +++ b/src/main/java/eod/card/concrete/normal/Sneak.java @@ -4,12 +4,10 @@ import eod.Party; import eod.card.abstraction.Card; import eod.card.abstraction.action.NormalCard; -import eod.effect.Attack; import eod.event.AttackEvent; import eod.event.Event; import eod.event.ObjectDeadEvent; -import eod.event.RoundEndEvent; -import eod.event.listener.EventListener; +import eod.event.relay.EventReceiver; import eod.specifier.Accessing; import eod.warObject.Status; import eod.warObject.WarObject; @@ -37,9 +35,7 @@ public void applyEffect() { if(afterEffect) { Arrays.stream(assassins) .map(object -> (Assassin) object) - .forEach(assassin -> - player.registerListener(new NextDamageDouble(assassin)) - ); + .forEach(NextDamageDouble::new); } } @@ -61,14 +57,16 @@ public Party getParty() { return Party.TRANSPARENT; } - public class NextDamageDouble implements EventListener, GameObject { + public class NextDamageDouble implements EventReceiver, GameObject { private Assassin assassin; private ArrayList> canHandle; + public NextDamageDouble(Assassin assassin) { this.assassin = assassin; canHandle = new ArrayList<>(); canHandle.add(ObjectDeadEvent.class); canHandle.add(AttackEvent.class); + assassin.registerReceiver(this); } @Override @@ -94,10 +92,10 @@ public void onEventOccurred(GameObject sender, Event event) { @Override public void teardown() { + assassin.unregisterReceiver(this); assassin = null; canHandle.clear(); canHandle = null; - player.unregisterListener(this); } } } diff --git a/src/main/java/eod/card/concrete/normal/SupportAttack.java b/src/main/java/eod/card/concrete/normal/SupportAttack.java index 1cc1663..f315918 100644 --- a/src/main/java/eod/card/concrete/normal/SupportAttack.java +++ b/src/main/java/eod/card/concrete/normal/SupportAttack.java @@ -7,7 +7,7 @@ import eod.event.Event; import eod.event.ObjectDeadEvent; import eod.event.TargetedEvent; -import eod.event.listener.EventListener; +import eod.event.relay.EventReceiver; import eod.warObject.Damageable; import eod.warObject.character.abstraction.Character; @@ -24,8 +24,11 @@ public SupportAttack() { @Override public void applyEffect() { - Character c = (Character) player.selectObject(WarObject(player.getBoard()).which(Being(Character.class)).which(OwnedBy(player)).get()); - player.registerListener(new EnemyAttack(c)); + new EnemyAttack((Character) player.selectObject( + WarObject(player.getBoard()) + .which(Being(Character.class)) + .which(OwnedBy(player)).get() + )); } @Override @@ -45,12 +48,13 @@ public Party getParty() { return Party.BLUE; } - public class EnemyAttack implements EventListener, GameObject { + public class EnemyAttack implements EventReceiver, GameObject { private Character holder; private ArrayList> canHandle; public EnemyAttack(Character holder) { this.holder = holder; + holder.registerReceiver(this); canHandle = new ArrayList<>(); canHandle.add(ObjectDeadEvent.class); canHandle.add(TargetedEvent.class); @@ -80,7 +84,7 @@ public void onEventOccurred(GameObject sender, Event event) { @Override public void teardown() { - player.unregisterListener(this); + holder.unregisterReceiver(this); canHandle.clear(); canHandle = null; holder = null; diff --git a/src/main/java/eod/effect/Summon.java b/src/main/java/eod/effect/Summon.java index 57c5a86..89fa1ea 100644 --- a/src/main/java/eod/effect/Summon.java +++ b/src/main/java/eod/effect/Summon.java @@ -19,7 +19,6 @@ public Summon(Player player, WarObject object) { public Point on(Point point) { player.summonObject(object, point); - player.sendEvent(player, new ObjectEnterEvent(object)); return point; } diff --git a/src/main/java/eod/event/AfterObjectDamageEvent.java b/src/main/java/eod/event/AfterObjectDamageEvent.java new file mode 100644 index 0000000..d361635 --- /dev/null +++ b/src/main/java/eod/event/AfterObjectDamageEvent.java @@ -0,0 +1,22 @@ +package eod.event; + +import eod.param.DamageParam; +import eod.warObject.Damageable; + +public class AfterObjectDamageEvent implements Event { + private Damageable victim; + private DamageParam param; + + public AfterObjectDamageEvent(Damageable victim, DamageParam param) { + this.victim = victim; + this.param = param; + } + + public Damageable getVictim() { + return victim; + } + + public DamageParam getParam() { + return param; + } +} diff --git a/src/main/java/eod/event/BeforeObjectDamageEvent.java b/src/main/java/eod/event/BeforeObjectDamageEvent.java new file mode 100644 index 0000000..3d324b6 --- /dev/null +++ b/src/main/java/eod/event/BeforeObjectDamageEvent.java @@ -0,0 +1,23 @@ +package eod.event; + +import eod.param.DamageParam; +import eod.warObject.Damageable; +import eod.warObject.WarObject; + +public class BeforeObjectDamageEvent implements Event { + private Damageable victim; + private DamageParam param; + + public BeforeObjectDamageEvent(Damageable victim, DamageParam param) { + this.victim = victim; + this.param = param; + } + + public Damageable getVictim() { + return victim; + } + + public DamageParam getParam() { + return param; + } +} diff --git a/src/main/java/eod/event/EventManager.java b/src/main/java/eod/event/EventManager.java deleted file mode 100644 index ddb80ed..0000000 --- a/src/main/java/eod/event/EventManager.java +++ /dev/null @@ -1,31 +0,0 @@ -package eod.event; - -import eod.GameObject; -import eod.Player; -import eod.event.listener.EventListener; - -import java.util.ArrayList; - -public class EventManager implements GameObject { - private ArrayList listeners = new ArrayList<>(); - - public void registerListener(EventListener listener) { - listeners.add(listener); - } - - public void unregisterListener(EventListener listener) { - listeners.remove(listener); - } - - public void send(GameObject sender, Event event) { - listeners.stream() - .filter(listener -> listener.supportedEventTypes().contains(event.getClass())) - .forEach(listener -> listener.onEventOccurred(sender, event)); - } - - @Override - public void teardown() { - listeners.clear(); - listeners = null; - } -} diff --git a/src/main/java/eod/event/ObjectEnterEnemyBaseEvent.java b/src/main/java/eod/event/ObjectEnterEnemyBaseEvent.java new file mode 100644 index 0000000..7ecf8fb --- /dev/null +++ b/src/main/java/eod/event/ObjectEnterEnemyBaseEvent.java @@ -0,0 +1,15 @@ +package eod.event; + +import eod.warObject.WarObject; + +public class ObjectEnterEnemyBaseEvent implements Event { + private WarObject object; + + public ObjectEnterEnemyBaseEvent(WarObject object) { + this.object = object; + } + + public WarObject getObject() { + return object; + } +} diff --git a/src/main/java/eod/event/ObjectMovingEvent.java b/src/main/java/eod/event/ObjectMovingEvent.java index 5a0d99b..cdbbf4b 100644 --- a/src/main/java/eod/event/ObjectMovingEvent.java +++ b/src/main/java/eod/event/ObjectMovingEvent.java @@ -25,4 +25,8 @@ public Point getOrigPos() { public Point getNewPos() { return newPos; } + + public void setNewPos(Point newPos) { + this.newPos = newPos; + } } diff --git a/src/main/java/eod/event/relay/EventManager.java b/src/main/java/eod/event/relay/EventManager.java new file mode 100644 index 0000000..14db3e3 --- /dev/null +++ b/src/main/java/eod/event/relay/EventManager.java @@ -0,0 +1,33 @@ +package eod.event.relay; + +import eod.GameObject; +import eod.event.Event; + +import java.util.ArrayList; + +public class EventManager implements EventSender, GameObject { + private ArrayList receivers = new ArrayList<>(); + + @Override + public void registerReceiver(EventReceiver receiver) { + receivers.add(receiver); + } + + @Override + public void unregisterReceiver(EventReceiver receiver) { + receivers.remove(receiver); + } + + @Override + public void send(GameObject sender, Event event) { + receivers.stream() + .filter(receiver -> receiver.supportedEventTypes().contains(event.getClass())) + .forEach(receiver -> receiver.onEventOccurred(sender, event)); + } + + @Override + public void teardown() { + receivers.clear(); + receivers = null; + } +} diff --git a/src/main/java/eod/event/listener/EventListener.java b/src/main/java/eod/event/relay/EventReceiver.java similarity index 72% rename from src/main/java/eod/event/listener/EventListener.java rename to src/main/java/eod/event/relay/EventReceiver.java index 95eb0e2..ca32cc0 100644 --- a/src/main/java/eod/event/listener/EventListener.java +++ b/src/main/java/eod/event/relay/EventReceiver.java @@ -1,12 +1,11 @@ -package eod.event.listener; +package eod.event.relay; import eod.GameObject; -import eod.Player; import eod.event.Event; import java.util.ArrayList; -public interface EventListener { +public interface EventReceiver extends GameObject { public ArrayList> supportedEventTypes(); void onEventOccurred(GameObject sender, Event event); } diff --git a/src/main/java/eod/event/relay/EventSender.java b/src/main/java/eod/event/relay/EventSender.java new file mode 100644 index 0000000..4386cec --- /dev/null +++ b/src/main/java/eod/event/relay/EventSender.java @@ -0,0 +1,14 @@ +package eod.event.relay; + +import eod.GameObject; +import eod.event.Event; + +import java.util.ArrayList; + +public interface EventSender { + void registerReceiver(EventReceiver receiver); + + void unregisterReceiver(EventReceiver receiver); + + void send(GameObject sender, Event event); +} diff --git a/src/main/java/eod/param/DamageParam.java b/src/main/java/eod/param/DamageParam.java new file mode 100644 index 0000000..f4f9b8a --- /dev/null +++ b/src/main/java/eod/param/DamageParam.java @@ -0,0 +1,10 @@ +package eod.param; + +public class DamageParam { + public int damage; + public boolean realDamage; + + public DamageParam(int damage) { + this.damage = damage; + } +} diff --git a/src/main/java/eod/warObject/Damageable.java b/src/main/java/eod/warObject/Damageable.java index eb4ee77..416e6b7 100644 --- a/src/main/java/eod/warObject/Damageable.java +++ b/src/main/java/eod/warObject/Damageable.java @@ -1,9 +1,10 @@ package eod.warObject; +import eod.param.DamageParam; + public interface Damageable { - void realDamage(int hp); - void damage(int hp); - void attacked(CanAttack attacker, int hp); + void damage(DamageParam param); + void attacked(CanAttack attacker, DamageParam param); void heal(int hp); void addHealth(int hp); void die(); diff --git a/src/main/java/eod/warObject/WarObject.java b/src/main/java/eod/warObject/WarObject.java index 028118a..3f1fbec 100644 --- a/src/main/java/eod/warObject/WarObject.java +++ b/src/main/java/eod/warObject/WarObject.java @@ -6,7 +6,9 @@ import eod.Party; import eod.Player; import eod.event.Event; -import eod.event.listener.EventListener; +import eod.event.StatusAcquiredEvent; +import eod.event.relay.EventReceiver; +import eod.event.relay.EventSender; import eod.param.PointParam; import java.awt.*; @@ -14,17 +16,19 @@ //WarObject represented anything on the gameboard // temporarily duplicated -public abstract class WarObject implements GameObject, EventListener { +public abstract class WarObject implements GameObject, EventReceiver, EventSender { public Point position; protected Player player; protected final Party party; ArrayList status; protected ArrayList> canHandle; + protected ArrayList receivers; public WarObject(Player player, Party party) { this.player = player; this.party = party; canHandle = new ArrayList<>(); + receivers = new ArrayList<>(); } public Player getPlayer() { @@ -78,6 +82,24 @@ public void addSupportedEventType(Class eventType) { canHandle.add(eventType); } + @Override + public void registerReceiver(EventReceiver receiver) { + receivers.add(receiver); + canHandle.addAll(receiver.supportedEventTypes()); + } + + @Override + public void unregisterReceiver(EventReceiver receiver) { + receivers.remove(receiver); + } + + @Override + public void send(GameObject sender, Event event) { + receivers.stream() + .filter(receiver -> receiver.supportedEventTypes().contains(event.getClass())) + .forEach(receiver -> receiver.onEventOccurred(sender, event)); + } + @Override public ArrayList> supportedEventTypes() { return canHandle; @@ -88,12 +110,14 @@ public void onEventOccurred(GameObject sender, Event event) { if(hasStatus(Status.NO_EFFECT)) { return; } + send(sender, event); } public abstract String getName(); public void addStatus(Status s) { if(!hasStatus(s)) { + player.sendUp(this, new StatusAcquiredEvent(this, s)); status.add(s); } } @@ -109,6 +133,8 @@ public void removeStatus(Status s) { public void teardown() { player = null; canHandle.clear(); + receivers.forEach(EventReceiver::teardown); + receivers.clear(); } public void transferTo(WarObject object) { diff --git a/src/main/java/eod/warObject/character/abstraction/Character.java b/src/main/java/eod/warObject/character/abstraction/Character.java index 4cb0b5c..8fe5b24 100644 --- a/src/main/java/eod/warObject/character/abstraction/Character.java +++ b/src/main/java/eod/warObject/character/abstraction/Character.java @@ -4,8 +4,10 @@ import eod.Party; import eod.Player; import eod.card.abstraction.summon.SummonCard; -import eod.exceptions.NotSupportedException; +import eod.event.AfterObjectDamageEvent; +import eod.event.BeforeObjectDamageEvent; import eod.param.AttackParam; +import eod.param.DamageParam; import eod.warObject.CanAttack; import eod.warObject.Damageable; import eod.warObject.Status; @@ -62,24 +64,26 @@ public void attack() { @Override public ArrayList attack(ArrayList targets, AttackParam param) { - int hp = param.hp; + int a; + if(hasStatus(Status.FURIOUS)) { + a = param.hp * 2; + } else { + a = param.hp; + } ArrayList affected = new ArrayList<>(); Gameboard gameboard = player.getBoard(); for(Point p:targets) { try { Damageable target = gameboard.getObjectOn(p.x, p.y); - if(param.realDamage) { - target.realDamage(hp); - } else { - target.attacked(this, hp); - } + DamageParam dp = new DamageParam(a); + dp.realDamage = param.realDamage; + target.attacked(this, dp); affected.add(target); ((WarObject)target).addStatus(Status.ATTACKED); } catch (IllegalArgumentException e) { System.out.println(e.toString()); } } - afterAttack(); return affected; } @@ -90,45 +94,44 @@ public ArrayList attack(Damageable target, AttackParam param) { @Override public ArrayList attack(Damageable[] targets, AttackParam param) { - int hp = param.hp; + int a; + if(hasStatus(Status.FURIOUS)) { + a = param.hp * 2; + } else { + a = param.hp; + } ArrayList affected = new ArrayList<>(); Arrays.stream(targets) .forEach(target -> { - if(param.realDamage) { - target.realDamage(hp); - } else { - target.attacked(this, hp); - } + DamageParam dp = new DamageParam(a); + dp.realDamage = param.realDamage; + target.attacked(this, dp); affected.add(target); ((WarObject)target).addStatus(Status.ATTACKED); }); - afterAttack(); return affected; } protected void afterAttack() { if(status.contains(Status.FURIOUS)) { - damage(1); + damage(new DamageParam(1)); } } @Override - public void realDamage(int val) { - hp -= val; + public void damage(DamageParam param) { + player.sendUp(this, new BeforeObjectDamageEvent(this, param)); + hp -= param.damage; if(hp <= 0) { die(); } + player.sendUp(this, new AfterObjectDamageEvent(this, param)); } @Override - public void damage(int val) { - realDamage(val); - } - - @Override - public void attacked(CanAttack attacker, int hp) { + public void attacked(CanAttack attacker, DamageParam param) { this.attacker = attacker; - damage(hp); + damage(param); this.attacker = null; } diff --git a/src/main/java/eod/warObject/character/concrete/blue/HeavyPolice.java b/src/main/java/eod/warObject/character/concrete/blue/HeavyPolice.java index d1f6c51..b4955a2 100644 --- a/src/main/java/eod/warObject/character/concrete/blue/HeavyPolice.java +++ b/src/main/java/eod/warObject/character/concrete/blue/HeavyPolice.java @@ -1,15 +1,26 @@ package eod.warObject.character.concrete.blue; +import eod.GameObject; import eod.Party; import eod.Player; import eod.card.abstraction.summon.SummonCard; import eod.card.concrete.summon.HeavyPoliceSummon; -import eod.exceptions.NotSupportedException; +import eod.event.Event; +import eod.event.BeforeObjectDamageEvent; +import eod.event.relay.EventReceiver; +import eod.param.DamageParam; +import eod.param.PointParam; import eod.warObject.character.abstraction.Character; +import java.awt.*; +import java.util.ArrayList; + +import static eod.effect.EffectFunctions.RequestRegionalAttack; + public class HeavyPolice extends Character { public HeavyPolice(Player player) { super(player, 5,5, Party.BLUE); + new DamageLessThan2(this); } @Override @@ -27,6 +38,51 @@ public String getName() { @Override public void attack() { super.attack(); - // TodO + RequestRegionalAttack(player, attack).from(this).to(getAttackRange()); + afterAttack(); + } + + @Override + public ArrayList getAttackRange() { + PointParam param = new PointParam(); + param.range = 1; + return player.getBoard().get4Ways(position, param); + } + + public class DamageLessThan2 implements EventReceiver { + private HeavyPolice holder; + private ArrayList> canHandle; + + public DamageLessThan2(HeavyPolice holder) { + this.holder = holder; + holder.registerReceiver(this); + this.canHandle = new ArrayList<>(); + canHandle.add(BeforeObjectDamageEvent.class); + } + + @Override + public ArrayList> supportedEventTypes() { + return canHandle; + } + + @Override + public void onEventOccurred(GameObject sender, Event event) { + if(event instanceof BeforeObjectDamageEvent) { + BeforeObjectDamageEvent e = (BeforeObjectDamageEvent) event; + DamageParam param = e.getParam(); + if(e.getVictim() == holder && !param.realDamage) { + if(param.damage > 2) { + param.damage = 2; + } + } + } + } + + @Override + public void teardown() { + canHandle.clear(); + holder.unregisterReceiver(this); + holder = null; + } } } diff --git a/src/main/java/eod/warObject/character/concrete/blue/Repairman.java b/src/main/java/eod/warObject/character/concrete/blue/Repairman.java index 2514584..3cc971a 100644 --- a/src/main/java/eod/warObject/character/concrete/blue/Repairman.java +++ b/src/main/java/eod/warObject/character/concrete/blue/Repairman.java @@ -46,6 +46,8 @@ public void attack() { machine.addHealth(1); machine.addAttack(1); }); + + afterAttack(); } @Override diff --git a/src/main/java/eod/warObject/character/concrete/blue/SWAT.java b/src/main/java/eod/warObject/character/concrete/blue/SWAT.java index c65bc14..d457fa3 100644 --- a/src/main/java/eod/warObject/character/concrete/blue/SWAT.java +++ b/src/main/java/eod/warObject/character/concrete/blue/SWAT.java @@ -38,6 +38,7 @@ public void attack() { super.attack(); decideAddHealthAndAttack(); RequestRegionalAttack(player, attack).from(this).to(getAttackRange(), 1); + afterAttack(); } private void decideAddHealthAndAttack() { diff --git a/src/main/java/eod/warObject/character/concrete/blue/SecureGuardBot.java b/src/main/java/eod/warObject/character/concrete/blue/SecureGuardBot.java index 1b29453..b6ee901 100644 --- a/src/main/java/eod/warObject/character/concrete/blue/SecureGuardBot.java +++ b/src/main/java/eod/warObject/character/concrete/blue/SecureGuardBot.java @@ -45,28 +45,7 @@ public CanAttack getAttacker() { public void attack(){ super.attack(); RequestRegionalAttack(player, attack).from(this).to(getAttackRange()); - } - - @Override - public ArrayList attack(ArrayList targets, AttackParam param) { - int hp = param.hp; - ArrayList affected = new ArrayList<>(); - Gameboard gameboard = player.getBoard(); - for(Point p:targets) { - try { - Damageable target = gameboard.getObjectOn(p.x, p.y); - if(param.realDamage) { - target.damage(hp); - } else { - target.attacked(this, hp); - } - affected.add(target); - ((WarObject) target).addStatus(Status.ATTACKED); - } catch (IllegalArgumentException e) { - System.out.println(e.toString()); - } - } - return affected; + afterAttack(); } @Override diff --git a/src/main/java/eod/warObject/character/concrete/red/AssaultDirector.java b/src/main/java/eod/warObject/character/concrete/red/AssaultDirector.java index 6fc6d50..f327383 100644 --- a/src/main/java/eod/warObject/character/concrete/red/AssaultDirector.java +++ b/src/main/java/eod/warObject/character/concrete/red/AssaultDirector.java @@ -61,5 +61,7 @@ public void attack() { gangster.moveTo(p); } } while (true); + + afterAttack(); } } diff --git a/src/main/java/eod/warObject/character/concrete/red/AssaultTeamLeader.java b/src/main/java/eod/warObject/character/concrete/red/AssaultTeamLeader.java index 9b60ca2..79369e0 100644 --- a/src/main/java/eod/warObject/character/concrete/red/AssaultTeamLeader.java +++ b/src/main/java/eod/warObject/character/concrete/red/AssaultTeamLeader.java @@ -5,12 +5,9 @@ import eod.Player; import eod.card.abstraction.summon.SummonCard; import eod.card.concrete.summon.AssaultTeamLeaderSummon; -import eod.effect.Summon; +import eod.event.*; import eod.event.Event; -import eod.event.ObjectEnterEvent; -import eod.event.RoundStartEvent; -import eod.event.StatusAcquiredEvent; -import eod.exceptions.NotSupportedException; +import eod.event.relay.EventReceiver; import eod.param.PointParam; import eod.warObject.Status; import eod.warObject.character.abstraction.Character; @@ -23,15 +20,14 @@ public class AssaultTeamLeader extends Character { public AssaultTeamLeader(Player player) { super(player, 1, 1, Party.RED); - canHandle.add(ObjectEnterEvent.class); - canHandle.add(StatusAcquiredEvent.class); - canHandle.add(RoundStartEvent.class); + new OwnedAbilities(this); } @Override public void attack() { super.attack(); RequestRegionalAttack(player, attack).from(this).to(getAttackRange()); + afterAttack(); } @Override @@ -53,37 +49,61 @@ public String getName() { return "特攻隊隊長"; } - @Override - public void onEventOccurred(GameObject sender, Event event) { - super.onEventOccurred(sender, event); - if(hasStatus(Status.NO_EFFECT)) { - return; - } - if(event instanceof ObjectEnterEvent) { - if(((ObjectEnterEvent) event).getObject() == this) { - addAttack(1); - addHealth(1); - } + private class OwnedAbilities implements EventReceiver { + private AssaultTeamLeader holder; + private ArrayList> canHandle; + + public OwnedAbilities(AssaultTeamLeader holder) { + this.holder = holder; + canHandle = new ArrayList<>(); + canHandle.add(RoundStartEvent.class); + canHandle.add(ObjectEnterEnemyBaseEvent.class); + canHandle.add(StatusAcquiredEvent.class); + holder.registerReceiver(this); } - if(event instanceof StatusAcquiredEvent) { - StatusAcquiredEvent e = (StatusAcquiredEvent) event; - if(e.getObject() == this && e.getStatus() == Status.SNEAK) { - addAttack(1); - addHealth(1); - } + + @Override + public ArrayList> supportedEventTypes() { + return canHandle; } - if(event instanceof RoundStartEvent) { - if(((RoundStartEvent) event).getStartedRound().getPlayer().isPlayerA() == player.isPlayerA()) { - PointParam param = new PointParam(); - param.emptySpace = true; - param.range = 1; - ArrayList front = player.getFront(position, param); - if(front.size() != 0) { - moveTo(front.get(0)); + @Override + public void onEventOccurred(GameObject sender, Event event) { + if(event instanceof RoundStartEvent) { + RoundStartEvent e = (RoundStartEvent) event; + if (e.getStartedRound().getPlayer().isPlayerA() == holder.getPlayer().isPlayerA()) { + PointParam param = new PointParam(); + param.emptySpace = true; + param.range = 1; + ArrayList front = player.getFront(position, param); + if(front.size() != 0) { + moveTo(front.get(0)); + } } } + if(event instanceof StatusAcquiredEvent) { + StatusAcquiredEvent e = (StatusAcquiredEvent) event; + if(e.getObject() == holder && e.getStatus() == Status.SNEAK) { + holder.addAttack(1); + holder.addHealth(1); + } + } + if(event instanceof ObjectEnterEnemyBaseEvent) { + ObjectEnterEnemyBaseEvent e = (ObjectEnterEnemyBaseEvent) event; + if(e.getObject() == holder) { + holder.addAttack(1); + holder.addHealth(1); + } + } + } + + @Override + public void teardown() { + holder.unregisterReceiver(this); + holder = null; + canHandle.clear(); + canHandle = null; } } } diff --git a/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java b/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java index 7c1c7dd..6e5cd42 100644 --- a/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java +++ b/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java @@ -8,6 +8,7 @@ import eod.effect.RegionalAttack; import eod.event.Event; import eod.event.ObjectEnterEvent; +import eod.event.relay.EventReceiver; import eod.param.PointParam; import eod.warObject.Damageable; import eod.warObject.Status; @@ -21,6 +22,7 @@ public class BloodThirstFighter extends Fighter { public BloodThirstFighter(Player player) { super(player, 4, 3, Party.RED); + new OwnedAbilities(this); } @Override @@ -56,17 +58,39 @@ public ArrayList getAttackRange() { return player.getBoard().get4Ways(position, param); } - @Override - public void onEventOccurred(GameObject sender, Event event) { - super.onEventOccurred(sender, event); - if(hasStatus(Status.NO_EFFECT)) { - return; + private class OwnedAbilities implements EventReceiver { + private BloodThirstFighter holder; + private ArrayList> canHandle; + + public OwnedAbilities(BloodThirstFighter holder) { + this.holder = holder; + canHandle = new ArrayList<>(); + canHandle.add(ObjectEnterEvent.class); + holder.registerReceiver(this); } - if(event instanceof ObjectEnterEvent) { - ObjectEnterEvent e = (ObjectEnterEvent) event; - if(e.getObject() == this) { - attack(); + + @Override + public ArrayList> supportedEventTypes() { + return canHandle; + } + + @Override + public void onEventOccurred(GameObject sender, Event event) { + if(event instanceof ObjectEnterEvent) { + ObjectEnterEvent e = (ObjectEnterEvent) event; + if(e.getObject() == holder) { + holder.attack(); + teardown(); + } } } + + @Override + public void teardown() { + holder.unregisterReceiver(this); + holder = null; + canHandle.clear(); + canHandle = null; + } } } diff --git a/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java b/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java index b14f734..95dfc3e 100644 --- a/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java +++ b/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java @@ -1,12 +1,17 @@ package eod.warObject.character.concrete.red; +import eod.GameObject; import eod.Gameboard; import eod.Party; import eod.Player; import eod.card.abstraction.summon.SummonCard; import eod.card.concrete.summon.CrazyBomberSummon; import eod.effect.RegionalAttack; +import eod.event.Event; +import eod.event.ObjectDeadEvent; +import eod.event.relay.EventReceiver; import eod.exceptions.NotSupportedException; +import eod.param.DamageParam; import eod.param.PointParam; import eod.warObject.Damageable; import eod.warObject.character.abstraction.Character; @@ -19,6 +24,7 @@ public class CrazyBomber extends Character { public CrazyBomber(Player player) { super(player, 1, 2, Party.RED); + new OwnedAbilities(this); } @Override @@ -53,17 +59,45 @@ public void attack() { SRA.to(player.getBoard().getSurrounding(p, param)); } - @Override - public void die() { - PointParam param = new PointParam(); - param.range = 1; - SpecialRegionalAttack SRA = (SpecialRegionalAttack) RequestRegionalAttack(player, 3).from(this); - SRA.to(player.getBoard().getSurrounding(position, param)); - player.loseObject(this); - teardown(); + private class OwnedAbilities implements EventReceiver { + private CrazyBomber holder; + private ArrayList> canHandle; + + public OwnedAbilities(CrazyBomber holder) { + holder.registerReceiver(this); + this.holder = holder; + canHandle = new ArrayList<>(); + canHandle.add(ObjectDeadEvent.class); + } + + @Override + public ArrayList> supportedEventTypes() { + return canHandle; + } + + @Override + public void onEventOccurred(GameObject sender, Event event) { + if(event instanceof ObjectDeadEvent) { + ObjectDeadEvent e = (ObjectDeadEvent) event; + if(e.getDeadObject() == holder) { + PointParam param = new PointParam(); + param.range = 1; + SpecialRegionalAttack SRA = new SpecialRegionalAttack(player, 3); + SRA.from(holder).to(player.getBoard().getSurrounding(position, param)); + } + } + } + + @Override + public void teardown() { + holder.unregisterReceiver(this); + holder = null; + canHandle.clear(); + canHandle = null; + } } - public class SpecialRegionalAttack extends RegionalAttack { + private class SpecialRegionalAttack extends RegionalAttack { public SpecialRegionalAttack(Player player, int hp) { super(player, hp); @@ -75,7 +109,7 @@ public RegionalAttack to(ArrayList targets) { for(Point p:targets) { try { Damageable target = board.getObjectOn(p.x, p.y); - target.damage(param.hp); + target.damage(new DamageParam(param.hp)); } catch (IllegalArgumentException e) { System.out.println("There's no object on the point, skipping."); } diff --git a/src/main/java/eod/warObject/character/concrete/red/ExperiencedWarrior.java b/src/main/java/eod/warObject/character/concrete/red/ExperiencedWarrior.java index c5714cf..6fadf38 100644 --- a/src/main/java/eod/warObject/character/concrete/red/ExperiencedWarrior.java +++ b/src/main/java/eod/warObject/character/concrete/red/ExperiencedWarrior.java @@ -4,13 +4,28 @@ import eod.Player; import eod.card.abstraction.summon.SummonCard; import eod.card.concrete.summon.ExperiencedWarriorSummon; +import eod.exceptions.NotSupportedException; +import eod.param.PointParam; import eod.warObject.character.abstraction.assaulter.Fighter; +import java.awt.*; +import java.util.ArrayList; + +import static eod.effect.EffectFunctions.RequestRegionalAttack; + public class ExperiencedWarrior extends Fighter { public ExperiencedWarrior(Player player) { super(player, 5, 5, Party.RED); } + @Override + public void attack() { + super.attack(); + RequestRegionalAttack(player, attack).from(this).to(getAttackRange(), 1); + + afterAttack(); + } + @Override public SummonCard getSummonCard() { SummonCard c = new ExperiencedWarriorSummon(); @@ -22,4 +37,11 @@ public SummonCard getSummonCard() { public String getName() { return "身經百戰的戰士"; } + + @Override + public ArrayList getAttackRange() { + PointParam param = new PointParam(); + param.range = 1; + return player.getBoard().getSurrounding(position, param); + } } diff --git a/src/main/java/eod/warObject/character/concrete/red/FrenzyCommander.java b/src/main/java/eod/warObject/character/concrete/red/FrenzyCommander.java index 15de99f..0718ff6 100644 --- a/src/main/java/eod/warObject/character/concrete/red/FrenzyCommander.java +++ b/src/main/java/eod/warObject/character/concrete/red/FrenzyCommander.java @@ -41,6 +41,8 @@ public void attack() { Gangster g = (Gangster) s.getObject(); g.addHealth(2); g.addAttack(2); + + afterAttack(); } @Override diff --git a/src/main/java/eod/warObject/character/concrete/red/GangBoss.java b/src/main/java/eod/warObject/character/concrete/red/GangBoss.java index d58912b..0d1e80d 100644 --- a/src/main/java/eod/warObject/character/concrete/red/GangBoss.java +++ b/src/main/java/eod/warObject/character/concrete/red/GangBoss.java @@ -4,6 +4,7 @@ import eod.Player; import eod.card.abstraction.summon.SummonCard; import eod.card.concrete.summon.GangBossSummon; +import eod.exceptions.NotSupportedException; import eod.param.PointParam; import eod.warObject.character.abstraction.assaulter.Fighter; @@ -68,12 +69,19 @@ public void attack() { gangster.attack(); }); + RequestRegionalAttack(player, attack).from(this).to(getAttackRange()); + + afterAttack(); + } + + @Override + public ArrayList getAttackRange() { ArrayList targets = new ArrayList<>(); PointParam param = new PointParam(); param.range = 1; targets.addAll(player.getFL(position, param)); targets.addAll(player.getFront(position, param)); targets.addAll(player.getFR(position, param)); - RequestRegionalAttack(player, attack).from(this).to(targets); + return targets; } } diff --git a/src/main/java/eod/warObject/character/concrete/red/Gangster.java b/src/main/java/eod/warObject/character/concrete/red/Gangster.java index 0b66c62..1ace633 100644 --- a/src/main/java/eod/warObject/character/concrete/red/Gangster.java +++ b/src/main/java/eod/warObject/character/concrete/red/Gangster.java @@ -38,6 +38,8 @@ public void attack() { PointParam param = new PointParam(); param.range = 1; RequestRegionalAttack(player, attack).from(this).to(player.getFront(position, param)); + + afterAttack(); } @Override diff --git a/src/main/java/eod/warObject/character/concrete/red/GuerrillaShooter.java b/src/main/java/eod/warObject/character/concrete/red/GuerrillaShooter.java index 7b674a9..df960a4 100644 --- a/src/main/java/eod/warObject/character/concrete/red/GuerrillaShooter.java +++ b/src/main/java/eod/warObject/character/concrete/red/GuerrillaShooter.java @@ -47,6 +47,8 @@ public void attack() { specialEffectTimes -= 2; attack(); } + + afterAttack(); } @Override diff --git a/src/main/java/eod/warObject/character/concrete/red/LeadersGuard.java b/src/main/java/eod/warObject/character/concrete/red/LeadersGuard.java index 97c55e8..3df7d56 100644 --- a/src/main/java/eod/warObject/character/concrete/red/LeadersGuard.java +++ b/src/main/java/eod/warObject/character/concrete/red/LeadersGuard.java @@ -1,10 +1,14 @@ package eod.warObject.character.concrete.red; +import eod.GameObject; import eod.Party; import eod.Player; import eod.card.abstraction.summon.SummonCard; import eod.card.concrete.summon.LeadersGuardSummon; import eod.effect.RegionalAttack; +import eod.event.Event; +import eod.event.ObjectMovingEvent; +import eod.event.relay.EventReceiver; import eod.exceptions.NotSupportedException; import eod.param.PointParam; import eod.warObject.character.abstraction.assaulter.Shooter; @@ -17,6 +21,7 @@ public class LeadersGuard extends Shooter { public LeadersGuard(Player player) { super(player, 5, 2, Party.RED); + new OwnedAbilities(this); } @Override @@ -34,8 +39,8 @@ public String getName() { @Override public void attack() { super.attack(); - SpecialRegionalAttack SRA = (SpecialRegionalAttack) RequestRegionalAttack(player, attack).from(this); - SRA.to(getAttackRange(), 1); + SpecialRegionalAttack SRA = new SpecialRegionalAttack(player, attack); + SRA.from(this).to(getAttackRange(), 1); } @Override @@ -43,6 +48,41 @@ public ArrayList getAttackRange() { return player.getBase(); } + private class OwnedAbilities implements EventReceiver { + private LeadersGuard holder; + private ArrayList> canHandle; + + public OwnedAbilities(LeadersGuard holder) { + this.holder = holder; + canHandle = new ArrayList<>(); + canHandle.add(ObjectMovingEvent.class); + holder.registerReceiver(this); + } + + @Override + public ArrayList> supportedEventTypes() { + return canHandle; + } + + @Override + public void onEventOccurred(GameObject sender, Event event) { + if(event instanceof ObjectMovingEvent) { + ObjectMovingEvent e = (ObjectMovingEvent) event; + if(e.getObject() == holder && !player.inBase(e.getNewPos())) { + e.setNewPos(e.getOrigPos()); + } + } + } + + @Override + public void teardown() { + holder.unregisterReceiver(this); + holder = null; + canHandle.clear(); + canHandle = null; + } + } + private class SpecialRegionalAttack extends RegionalAttack { public SpecialRegionalAttack(Player player, int hp) { super(player, hp); diff --git a/src/main/java/eod/warObject/character/concrete/red/MafiaAssassin.java b/src/main/java/eod/warObject/character/concrete/red/MafiaAssassin.java index 368ff1f..a222ec9 100644 --- a/src/main/java/eod/warObject/character/concrete/red/MafiaAssassin.java +++ b/src/main/java/eod/warObject/character/concrete/red/MafiaAssassin.java @@ -38,8 +38,10 @@ public String getName() { @Override public void attack() { super.attack(); - SpecialRegionalAttack a = (SpecialRegionalAttack) RequestRegionalAttack(player, attack).from(this); - a.to(getAttackRange()); + SpecialRegionalAttack SRA = new SpecialRegionalAttack(player, attack); + SRA.from(this).to(getAttackRange(), 1); + + afterAttack(); } @Override @@ -49,7 +51,7 @@ public ArrayList getAttackRange() { return player.getBoard().get4Ways(position, param); } - public class SpecialRegionalAttack extends RegionalAttack { + private class SpecialRegionalAttack extends RegionalAttack { public SpecialRegionalAttack(Player player, int hp) { super(player, hp); } diff --git a/src/main/java/eod/warObject/character/concrete/red/Scavenger.java b/src/main/java/eod/warObject/character/concrete/red/Scavenger.java index b2086fb..dae62c4 100644 --- a/src/main/java/eod/warObject/character/concrete/red/Scavenger.java +++ b/src/main/java/eod/warObject/character/concrete/red/Scavenger.java @@ -7,6 +7,7 @@ import eod.card.concrete.summon.ScavengerSummon; import eod.exceptions.NotSupportedException; import eod.param.AttackParam; +import eod.param.DamageParam; import eod.param.PointParam; import eod.warObject.Damageable; import eod.warObject.Status; @@ -46,22 +47,29 @@ public ArrayList getAttackRange() { public void attack() { super.attack(); RequestRegionalAttack(player, attack).from(this).to(getAttackRange(), 1); + + afterAttack(); } @Override public ArrayList attack(ArrayList targets, AttackParam param) { - int hp = param.hp; + int a; + if(hasStatus(Status.FURIOUS)) { + a = param.hp *2; + } else { + a = param.hp; + } ArrayList affected = new ArrayList<>(); Gameboard gameboard = player.getBoard(); for(Point p:targets) { try { Damageable target = gameboard.getObjectOn(p.x, p.y); + DamageParam dp = new DamageParam(a); + dp.realDamage = param.realDamage; if(target.getHp() <= 2) { target.die(); - } else if(param.realDamage) { - target.realDamage(hp); } else { - target.attacked(this, hp); + target.attacked(this, dp); } affected.add(target); ((WarObject)target).addStatus(Status.ATTACKED); diff --git a/src/main/java/eod/warObject/character/concrete/red/ToughGuy.java b/src/main/java/eod/warObject/character/concrete/red/ToughGuy.java index c292b41..c2269f4 100644 --- a/src/main/java/eod/warObject/character/concrete/red/ToughGuy.java +++ b/src/main/java/eod/warObject/character/concrete/red/ToughGuy.java @@ -1,10 +1,14 @@ package eod.warObject.character.concrete.red; +import eod.GameObject; import eod.Party; import eod.Player; import eod.card.abstraction.summon.SummonCard; import eod.card.concrete.summon.ToughGuySummon; -import eod.exceptions.NotSupportedException; +import eod.event.AfterObjectDamageEvent; +import eod.event.Event; +import eod.event.relay.EventReceiver; +import eod.param.DamageParam; import eod.param.PointParam; import eod.warObject.character.abstraction.assaulter.Fighter; @@ -34,6 +38,8 @@ public String getName() { public void attack() { super.attack(); RequestRegionalAttack(player, attack).from(this).to(getAttackRange()); + + afterAttack(); } @Override @@ -43,10 +49,39 @@ public ArrayList getAttackRange() { return player.getBoard().getSurrounding(position, param); } - @Override - public void realDamage(int val) { - super.realDamage(val); - addAttack(2); - addHealth(2); + private class OwnedAbilities implements EventReceiver { + private ToughGuy holder; + private ArrayList> canHandle; + + public OwnedAbilities(ToughGuy holder) { + this.holder = holder; + canHandle = new ArrayList<>(); + canHandle.add(AfterObjectDamageEvent.class); + holder.registerReceiver(this); + } + + @Override + public ArrayList> supportedEventTypes() { + return canHandle; + } + + @Override + public void onEventOccurred(GameObject sender, Event event) { + if(event instanceof AfterObjectDamageEvent) { + AfterObjectDamageEvent e = (AfterObjectDamageEvent) event; + if(e.getVictim() == holder) { + holder.addAttack(2); + holder.addHealth(2); + } + } + } + + @Override + public void teardown() { + holder.unregisterReceiver(this); + holder = null; + canHandle.clear(); + canHandle = null; + } } } diff --git a/src/main/java/eod/warObject/character/concrete/transparent/Drone.java b/src/main/java/eod/warObject/character/concrete/transparent/Drone.java index fc02ea9..a0382d0 100644 --- a/src/main/java/eod/warObject/character/concrete/transparent/Drone.java +++ b/src/main/java/eod/warObject/character/concrete/transparent/Drone.java @@ -4,10 +4,16 @@ import eod.Player; import eod.card.abstraction.summon.SummonCard; import eod.card.concrete.summon.DroneSummon; +import eod.exceptions.NotSupportedException; +import eod.param.PointParam; +import eod.specifier.Accessing; import eod.warObject.CanAttack; import eod.warObject.Damageable; import eod.warObject.character.abstraction.Machine; +import java.awt.*; +import java.util.ArrayList; + import static eod.effect.EffectFunctions.RequestRegionalAttack; import static eod.specifier.WarObjectSpecifier.*; import static eod.specifier.condition.Conditions.*; @@ -26,13 +32,13 @@ public String getName() { @Override public void attack() { super.attack(); - if(WarObject(player.getBoard()).which(OwnedBy(player)).which(Being(Drone.class)).which(InRangeOf(this)).get().length >= 1) { + Accessing objects = WarObject(player.getBoard()).which(InRangeOf(this)); + if(objects.which(OwnedBy(player)).which(Being(Drone.class)).get().length >= 1) { attack += 2; } - RequestRegionalAttack(player, attack).from(this).to(WarObject(player.getBoard()) + RequestRegionalAttack(player, attack).from(this).to(objects .which(OwnedBy(player.rival())) - .which(Being(Damageable.class)) - .which(InRangeOf(this)).get()); + .which(Being(Damageable.class)).get()); } @Override @@ -48,7 +54,9 @@ public SummonCard getSummonCard() { } @Override - public void teardown() { - super.teardown(); + public ArrayList getAttackRange() { + PointParam param = new PointParam(); + param.range = 1; + return player.getBoard().getSurrounding(position, param); } } diff --git a/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java b/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java index 4cce3af..dab7967 100644 --- a/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java +++ b/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java @@ -7,17 +7,21 @@ import eod.card.concrete.summon.OwnerlessAssassinSummon; import eod.event.Event; import eod.event.RoundStartEvent; +import eod.event.relay.EventReceiver; import eod.param.PointParam; import eod.warObject.Status; import eod.warObject.character.abstraction.assaulter.Assassin; import java.awt.*; +import java.lang.reflect.Array; import java.util.ArrayList; +import static eod.effect.EffectFunctions.RequestRegionalAttack; + public class OwnerlessAssassin extends Assassin { public OwnerlessAssassin(Player player) { super(player, 2, 4, Party.TRANSPARENT); - canHandle.add(RoundStartEvent.class); + new OwnedAbilities(this); } @Override @@ -32,6 +36,12 @@ public String getName() { return "無主的殺手"; } + @Override + public void attack() { + super.attack(); + RequestRegionalAttack(player, attack).from(this).to(getAttackRange(), 1); + } + @Override public ArrayList getAttackRange() { PointParam param = new PointParam(); @@ -39,15 +49,36 @@ public ArrayList getAttackRange() { return player.getBoard().getSurrounding(position, param); } - @Override - public void onEventOccurred(GameObject sender, Event event) { - super.onEventOccurred(sender, event); - if(hasStatus(Status.NO_EFFECT)) { - return; + private class OwnedAbilities implements EventReceiver { + private OwnerlessAssassin holder; + private ArrayList> canHandle; + + public OwnedAbilities(OwnerlessAssassin holder) { + this.holder = holder; + canHandle = new ArrayList<>(); + canHandle.add(RoundStartEvent.class); + holder.registerReceiver(this); } - if(event instanceof RoundStartEvent) { - RoundStartEvent e = (RoundStartEvent) event; - player = e.getStartedRound().getPlayer(); + + @Override + public ArrayList> supportedEventTypes() { + return canHandle; + } + + @Override + public void onEventOccurred(GameObject sender, Event event) { + if(event instanceof RoundStartEvent) { + RoundStartEvent e = (RoundStartEvent) event; + holder.player = e.getStartedRound().getPlayer(); + } + } + + @Override + public void teardown() { + holder.unregisterReceiver(this); + holder = null; + canHandle.clear(); + canHandle = null; } } } diff --git a/src/main/java/eod/warObject/character/concrete/transparent/Spacezipper.java b/src/main/java/eod/warObject/character/concrete/transparent/Spacezipper.java index bae4aa2..0213c87 100644 --- a/src/main/java/eod/warObject/character/concrete/transparent/Spacezipper.java +++ b/src/main/java/eod/warObject/character/concrete/transparent/Spacezipper.java @@ -9,6 +9,7 @@ import eod.event.Event; import eod.event.RoundEndEvent; import eod.event.RoundStartEvent; +import eod.event.relay.EventReceiver; import eod.param.PointParam; import eod.warObject.Marker; import eod.warObject.Status; @@ -23,8 +24,8 @@ public class Spacezipper extends Character implements Marker { private ArrayList marked; public Spacezipper(Player player) { super(player, 5, 3, Party.TRANSPARENT); - canHandle.add(RoundStartEvent.class); marked = new ArrayList<>(); + new OwnedAbilities(this); } @Override @@ -66,18 +67,6 @@ public String getName() { return "圭月"; } - @Override - public void onEventOccurred(GameObject sender, Event event) { - super.onEventOccurred(sender, event); - if (hasStatus(Status.NO_EFFECT)) { - return; - } - if(event instanceof RoundStartEvent) { - mark(position); - move(); - } - } - @Override public void teardown() { super.teardown(); @@ -112,4 +101,40 @@ public void clearMark() { public ArrayList getMarks() { return marked; } + + private class OwnedAbilities implements EventReceiver { + private Spacezipper holder; + private ArrayList> canHandle; + + public OwnedAbilities(Spacezipper holder) { + this.holder = holder; + canHandle = new ArrayList<>(); + canHandle.add(RoundStartEvent.class); + holder.registerReceiver(this); + } + + @Override + public ArrayList> supportedEventTypes() { + return canHandle; + } + + @Override + public void onEventOccurred(GameObject sender, Event event) { + if(event instanceof RoundStartEvent) { + RoundStartEvent e = (RoundStartEvent) event; + if(e.getStartedRound().getPlayer().isPlayerA() == holder.player.isPlayerA()) { + holder.mark(holder.position); + holder.move(); + } + } + } + + @Override + public void teardown() { + holder.unregisterReceiver(this); + holder = null; + canHandle.clear(); + canHandle = null; + } + } } diff --git a/src/main/java/eod/warObject/leader/red/Sundar.java b/src/main/java/eod/warObject/leader/red/Sundar.java index bf6dc5b..424f4c9 100644 --- a/src/main/java/eod/warObject/leader/red/Sundar.java +++ b/src/main/java/eod/warObject/leader/red/Sundar.java @@ -6,8 +6,9 @@ import eod.card.concrete.command.EquivalentExchange; import eod.event.Event; import eod.event.ObjectDeadEvent; -import eod.event.listener.EventListener; +import eod.event.relay.EventReceiver; import eod.param.AttackParam; +import eod.param.DamageParam; import eod.param.PointParam; import eod.warObject.CanAttack; import eod.warObject.Damageable; @@ -25,7 +26,7 @@ import static eod.effect.EffectFunctions.Summon; -public class Sundar extends Leader implements EventListener { +public class Sundar extends Leader { public Sundar(Player player) { super(player, 20, 0, Party.RED); canHandle.add(ObjectDeadEvent.class); @@ -54,13 +55,22 @@ public void deathPulse() { attackParam.hp = 4; attackParam.realDamage = true; attack(targets, attackParam); + + afterAttack(); } @Override public ArrayList attack(ArrayList targets, AttackParam param) { ArrayList affected = new ArrayList<>(); - int hp = param.hp; - this.damage(hp); + int a; + if(hasStatus(Status.FURIOUS)) { + a = param.hp * 2; + } else { + a = param.hp; + } + this.damage(param.hp); + DamageParam dp = new DamageParam(a); + dp.realDamage = param.realDamage; Gameboard gameboard = player.getBoard(); for(Point p:targets) { try { @@ -68,12 +78,12 @@ public ArrayList attack(ArrayList targets, AttackParam param) if(target instanceof Bunker || target instanceof Machine) { continue; } - if(target.getPlayer().equals(player)) { + if(target.getPlayer().isPlayerA() == player.isPlayerA()) { if(target instanceof Ghost) { ((Ghost) target).attack(); } } else { - ((Damageable) target).attacked(this, hp); + ((Damageable) target).attacked(this, dp); affected.add((Damageable) target); } } catch (Exception e) { @@ -98,29 +108,50 @@ protected ArrayList generateCommand() { return deck; } - @Override - public void onEventOccurred(GameObject sender, Event event) { - super.onEventOccurred(sender, event); - if(hasStatus(Status.NO_EFFECT)) { - return; + private class OwnedAbilities implements EventReceiver { + private Sundar holder; + private ArrayList> canHandle; + + + public OwnedAbilities(Sundar holder) { + this.holder = holder; + this.canHandle = new ArrayList<>(); + canHandle.add(ObjectDeadEvent.class); + holder.registerReceiver(this); + } + + @Override + public ArrayList> supportedEventTypes() { + return canHandle; } - if (event instanceof ObjectDeadEvent) { - Damageable deadObject = ((ObjectDeadEvent) event).getDeadObject(); - WarObject object = (WarObject) deadObject; - CanAttack attacker = deadObject.getAttacker(); - int x = object.position.x, y = object.position.y; - if(deadObject instanceof Ghost && object.getPlayer().equals(player)) { - heal(2); - } else if (object.getPlayer().equals(player)) { - Summon(player, new LittleGhost(player)).on(new Point(x, y)); - } else if(isDeadObjectOwnedByEnemy(object) && isGhostOrSundar(attacker) && ((WarObject) attacker).getPlayer().equals(player)){ - player.getBoard().summonObject(new GhostOfHatred(player), new Point(x, y)); + + @Override + public void onEventOccurred(GameObject sender, Event event) { + if(hasStatus(Status.NO_EFFECT)) { + return; + } + if (event instanceof ObjectDeadEvent) { + Damageable deadObject = ((ObjectDeadEvent) event).getDeadObject(); + WarObject object = (WarObject) deadObject; + CanAttack attacker = deadObject.getAttacker(); + int x = object.position.x, y = object.position.y; + if(deadObject instanceof Ghost && object.getPlayer().equals(player)) { + heal(2); + } else if (object.getPlayer().equals(player)) { + Summon(player, new LittleGhost(player)).on(new Point(x, y)); + } else if(object.getPlayer().isPlayerA() == holder.player.isPlayerA() && isGhostOrSundar(attacker) && ((WarObject) attacker).getPlayer().equals(player)){ + player.getBoard().summonObject(new GhostOfHatred(player), new Point(x, y)); + } } } - } - private boolean isDeadObjectOwnedByEnemy(WarObject deadObject) { - return deadObject.getPlayer().equals(player.rival()); + @Override + public void teardown() { + holder.unregisterReceiver(this); + holder = null; + canHandle.clear(); + canHandle = null; + } } private boolean isGhostOrSundar(CanAttack attacker) { From 3b7a2f841c58cfdc405358513506d635ad19a37f Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Mon, 25 May 2020 00:04:25 +0800 Subject: [PATCH 14/22] bug fix --- .../card/concrete/normal/SingleContract.java | 3 ++- .../eod/card/concrete/normal/SupportAttack.java | 3 ++- src/main/java/eod/warObject/leader/Leader.java | 17 ++--------------- 3 files changed, 6 insertions(+), 17 deletions(-) diff --git a/src/main/java/eod/card/concrete/normal/SingleContract.java b/src/main/java/eod/card/concrete/normal/SingleContract.java index bf2136c..e0857d2 100644 --- a/src/main/java/eod/card/concrete/normal/SingleContract.java +++ b/src/main/java/eod/card/concrete/normal/SingleContract.java @@ -3,6 +3,7 @@ import eod.Party; import eod.card.abstraction.Card; import eod.card.abstraction.action.NormalCard; +import eod.param.DamageParam; import eod.warObject.Status; import eod.warObject.WarObject; import eod.warObject.character.abstraction.Character; @@ -18,7 +19,7 @@ public SingleContract() { @Override public void applyEffect() { WarObject[] characters = WarObject(player.getBoard()).which(OwnedBy(player.rival())).which(Being(Character.class)).which(WithoutStatus(Status.SNEAK)).get(); - ((Character) player.selectObject(characters)).damage(4); + ((Character) player.selectObject(characters)).damage(new DamageParam(4)); player.getDeck().dropAll(this); player.getHand().dropAll(this); } diff --git a/src/main/java/eod/card/concrete/normal/SupportAttack.java b/src/main/java/eod/card/concrete/normal/SupportAttack.java index f315918..1ebc196 100644 --- a/src/main/java/eod/card/concrete/normal/SupportAttack.java +++ b/src/main/java/eod/card/concrete/normal/SupportAttack.java @@ -8,6 +8,7 @@ import eod.event.ObjectDeadEvent; import eod.event.TargetedEvent; import eod.event.relay.EventReceiver; +import eod.param.DamageParam; import eod.warObject.Damageable; import eod.warObject.character.abstraction.Character; @@ -76,7 +77,7 @@ public void onEventOccurred(GameObject sender, Event event) { if(event instanceof TargetedEvent) { TargetedEvent e = (TargetedEvent) event; if(e.getTarget() != holder) { - ((Damageable) e.getAttacker()).damage(2); + ((Damageable) e.getAttacker()).damage(new DamageParam(2)); teardown(); } } diff --git a/src/main/java/eod/warObject/leader/Leader.java b/src/main/java/eod/warObject/leader/Leader.java index c3c04c9..9ca7973 100644 --- a/src/main/java/eod/warObject/leader/Leader.java +++ b/src/main/java/eod/warObject/leader/Leader.java @@ -4,6 +4,8 @@ import eod.Player; import eod.card.abstraction.Card; import eod.card.abstraction.summon.SummonCard; +import eod.param.AttackParam; +import eod.param.DamageParam; import eod.warObject.CanAttack; import eod.warObject.Damageable; import eod.warObject.Status; @@ -53,26 +55,11 @@ public Leader enterArena() { protected abstract ArrayList generateCommand(); - @Override - public void attacked(CanAttack attacker, int hp) { - this.attacker = attacker; - damage(hp); - this.attacker = null; - } - @Override public CanAttack getAttacker() { return attacker; } - @Override - public void damage(int hp) { - this.hp -= hp; - if(this.hp <= 0) { - die(); - } - } - @Override public void die() { teardown(); From d9f009cc8c7045173fb7fff612f618a73880dccb Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Mon, 25 May 2020 00:06:14 +0800 Subject: [PATCH 15/22] (another) bug fix --- .../java/eod/card/concrete/command/EquivalentExchange.java | 3 ++- src/main/java/eod/warObject/leader/red/Sundar.java | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/main/java/eod/card/concrete/command/EquivalentExchange.java b/src/main/java/eod/card/concrete/command/EquivalentExchange.java index fc275d1..a15249d 100644 --- a/src/main/java/eod/card/concrete/command/EquivalentExchange.java +++ b/src/main/java/eod/card/concrete/command/EquivalentExchange.java @@ -5,6 +5,7 @@ import eod.card.abstraction.Card; import eod.card.abstraction.CommandCard; import eod.card.abstraction.action.NormalCard; +import eod.param.DamageParam; import eod.warObject.character.concrete.red.LittleGhost; import static eod.effect.EffectFunctions.Summon; @@ -16,7 +17,7 @@ public EquivalentExchange() { @Override public void applyEffect() { - player.getLeader().damage(2); + player.getLeader().damage(new DamageParam(2)); Summon(player, new LittleGhost(player)).from(player.getBaseEmpty()); } diff --git a/src/main/java/eod/warObject/leader/red/Sundar.java b/src/main/java/eod/warObject/leader/red/Sundar.java index 424f4c9..c6c7504 100644 --- a/src/main/java/eod/warObject/leader/red/Sundar.java +++ b/src/main/java/eod/warObject/leader/red/Sundar.java @@ -68,7 +68,7 @@ public ArrayList attack(ArrayList targets, AttackParam param) } else { a = param.hp; } - this.damage(param.hp); + this.damage(new DamageParam(param.hp)); DamageParam dp = new DamageParam(a); dp.realDamage = param.realDamage; Gameboard gameboard = player.getBoard(); From 0ca6a9be0182b567599bb0ddd1ff554b31b43a76 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Mon, 25 May 2020 19:18:12 +0800 Subject: [PATCH 16/22] minor fix. I can see another ton of conflicts coming around. --- src/main/java/eod/effect/RegionalAttack.java | 8 ++------ .../character/concrete/red/MafiaAssassin.java | 20 +++++++++++++++++++ 2 files changed, 22 insertions(+), 6 deletions(-) diff --git a/src/main/java/eod/effect/RegionalAttack.java b/src/main/java/eod/effect/RegionalAttack.java index 9547fc7..9740dd7 100644 --- a/src/main/java/eod/effect/RegionalAttack.java +++ b/src/main/java/eod/effect/RegionalAttack.java @@ -44,18 +44,14 @@ public RegionalAttack to(ArrayList candidates, int number) { if(number >= candidates.size()) { return to(candidates); } + ArrayList targets = new ArrayList<>(); for(int i = 0;i < number;i++) { Point target = askToSelectOneFrom(candidates); targets.add(target); candidates.remove(target); } - try { - affected.addAll(attacker.attack(targets, param)); - } catch (NotSupportedException e) { - System.out.println(e.toString()); - } - return this; + return to(targets); } public RegionalAttack to(WarObject[] candidates) { diff --git a/src/main/java/eod/warObject/character/concrete/red/MafiaAssassin.java b/src/main/java/eod/warObject/character/concrete/red/MafiaAssassin.java index a222ec9..3876c9c 100644 --- a/src/main/java/eod/warObject/character/concrete/red/MafiaAssassin.java +++ b/src/main/java/eod/warObject/character/concrete/red/MafiaAssassin.java @@ -9,6 +9,7 @@ import eod.exceptions.NotSupportedException; import eod.param.PointParam; import eod.warObject.Damageable; +import eod.warObject.Status; import eod.warObject.WarObject; import eod.warObject.character.abstraction.assaulter.Assassin; import eod.warObject.leader.Leader; @@ -56,6 +57,22 @@ public SpecialRegionalAttack(Player player, int hp) { super(player, hp); } + @Override + public RegionalAttack to(ArrayList candidates, int number) { + if(number >= candidates.size()) { + return to(candidates); + } + + ArrayList targets = new ArrayList<>(); + for(int i = 0;i < number;i++) { + Point selected = player.selectPosition(candidates); + candidates.remove(selected); + targets.add(selected); + } + + return to(targets); + } + @Override public RegionalAttack to(ArrayList targets) { Gameboard board = player.getBoard(); @@ -65,6 +82,9 @@ public RegionalAttack to(ArrayList targets) { if(target instanceof Leader) { param.hp *= 2; } + if(hasStatus(Status.FURIOUS)) { + param.hp *= 2; + } Damageable t = (Damageable) target; affected.addAll(attacker.attack(t, param)); } catch (IllegalArgumentException e) { From 3c795e189fa669db32d561f5f60d8f9f7c579cd2 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Tue, 26 May 2020 08:31:47 +0800 Subject: [PATCH 17/22] fix the event relay. --- src/main/java/eod/Player.java | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/src/main/java/eod/Player.java b/src/main/java/eod/Player.java index a3122c0..0eeaffc 100644 --- a/src/main/java/eod/Player.java +++ b/src/main/java/eod/Player.java @@ -460,30 +460,26 @@ public ArrayList> supportedEventTypes() { public void onEventOccurred(GameObject sender, Event event) { if(event instanceof RoundStartEvent) { output.sendRoundStarted(((RoundStartEvent) event).getStartedRound()); - return; - } - if(event instanceof RoundEndEvent) { + } else if(event instanceof RoundEndEvent) { output.sendRoundEnded(((RoundEndEvent) event).getEndedRound()); - return; - } - if(event instanceof DirectAttackEvent) { + } else if(event instanceof DirectAttackEvent) { DirectAttackEvent directAttack = (DirectAttackEvent) event; Character attacker = directAttack.getAttacker(); for(Damageable victim: directAttack.getTargets()) { output.sendCharacterAttacked(attacker, (Character) victim); } - return; - } - if(event instanceof ObjectDeadEvent) { + } else if(event instanceof ObjectDeadEvent) { ObjectDeadEvent objectDeadEvent = (ObjectDeadEvent) event; WarObject deadObject = (WarObject) objectDeadEvent.getDeadObject(); output.sendWarObjectDied(deadObject); - return; - } - if(event instanceof ObjectMovingEvent) { + } else if(event instanceof ObjectMovingEvent) { ObjectMovingEvent movingEvent = (ObjectMovingEvent) event; output.sendWarObjectMoved(movingEvent.getObject(), movingEvent.getNewPos()); } + + receivers.stream() + .filter(receiver -> receiver.supportedEventTypes().contains(event.getClass())) + .forEach(receiver -> receiver.onEventOccurred(sender, event)); } public class Snapshot implements eod.snapshots.Snapshot { From 814baca0a119d37af210757babaa99b4ddd23e2b Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Tue, 26 May 2020 16:34:15 +0800 Subject: [PATCH 18/22] Bug fix --- src/main/java/eod/Player.java | 4 +- .../eod/card/concrete/normal/FightBack.java | 7 +++- .../eod/card/concrete/normal/GrandFeast.java | 6 ++- .../card/concrete/normal/SingleContract.java | 1 - .../card/concrete/normal/SupportAttack.java | 5 ++- src/main/java/eod/warObject/WarObject.java | 3 -- .../character/concrete/blue/HeavyPolice.java | 13 +++---- .../concrete/red/AssaultTeamLeader.java | 37 +++++++++++-------- .../concrete/red/BloodThirstFighter.java | 15 +++----- .../character/concrete/red/CrazyBomber.java | 19 +++++----- .../concrete/red/ExperiencedWarrior.java | 4 +- .../concrete/red/FrenzyCommander.java | 12 ++++-- .../concrete/red/GuerrillaShooter.java | 6 ++- .../character/concrete/red/LeadersGuard.java | 16 ++++---- .../character/concrete/red/ToughGuy.java | 23 +++++++----- .../character/concrete/transparent/Drone.java | 2 + .../transparent/OwnerlessAssassin.java | 13 +++---- .../concrete/transparent/Spacezipper.java | 17 ++++----- 18 files changed, 110 insertions(+), 93 deletions(-) diff --git a/src/main/java/eod/Player.java b/src/main/java/eod/Player.java index 0eeaffc..8e18fcb 100644 --- a/src/main/java/eod/Player.java +++ b/src/main/java/eod/Player.java @@ -357,9 +357,9 @@ public Card selectCard(Card[] cards) { public void moveObject(WarObject object, Point point) { game.getBoard().moveObject(object.position, point); - game.sendEvent(this, new ObjectMovingEvent(object, point)); + sendUp(this, new ObjectMovingEvent(object, point)); if(inEnemyBase(object.position)) { - game.sendEvent(this, new ObjectEnterEnemyBaseEvent(object)); + sendUp(this, new ObjectEnterEnemyBaseEvent(object)); } object.updatePosition(point); } diff --git a/src/main/java/eod/card/concrete/normal/FightBack.java b/src/main/java/eod/card/concrete/normal/FightBack.java index 50ec999..ed5d987 100644 --- a/src/main/java/eod/card/concrete/normal/FightBack.java +++ b/src/main/java/eod/card/concrete/normal/FightBack.java @@ -13,6 +13,7 @@ import eod.event.TargetedEvent; import eod.event.relay.EventReceiver; import eod.param.DamageParam; +import eod.warObject.CanAttack; import eod.warObject.Damageable; import eod.warObject.WarObject; import eod.warObject.character.abstraction.Character; @@ -22,6 +23,7 @@ import static eod.specifier.WarObjectSpecifier.WarObject; import static eod.specifier.condition.Conditions.Being; import static eod.specifier.condition.Conditions.OwnedBy; +import static eod.effect.EffectFunctions.*; public class FightBack extends NormalCard { public FightBack() { @@ -80,7 +82,10 @@ public void onEventOccurred(GameObject sender, Event event) { if(event instanceof TargetedEvent) { TargetedEvent e = (TargetedEvent) event; if(e.getTarget() == watching) { - new Damage(new DamageParam(4), Effect.HandlerType.Rival).on((Damageable) e.getAttacker()); + CanAttack attacker = e.getAttacker(); + ((WarObject) attacker).getPlayer().tryToExecute( + Damage(new DamageParam(4), Effect.HandlerType.Rival).on((Damageable) attacker) + ); } teardown(); } diff --git a/src/main/java/eod/card/concrete/normal/GrandFeast.java b/src/main/java/eod/card/concrete/normal/GrandFeast.java index dbf61a7..1707d33 100644 --- a/src/main/java/eod/card/concrete/normal/GrandFeast.java +++ b/src/main/java/eod/card/concrete/normal/GrandFeast.java @@ -3,6 +3,7 @@ import eod.Party; import eod.card.abstraction.Card; import eod.card.abstraction.action.NormalCard; +import eod.effect.Effect; import eod.effect.EffectExecutor; import eod.event.AttackEvent; import eod.event.Event; @@ -13,6 +14,7 @@ import java.util.ArrayList; +import static eod.effect.EffectFunctions.GiveStatus; import static eod.specifier.WarObjectSpecifier.WarObject; import static eod.specifier.condition.Conditions.*; @@ -30,7 +32,9 @@ public GrandFeast() { @Override public void applyEffect(EffectExecutor executor) { for(WarObject object:WarObject (player.getBoard()).which(OwnedBy(player)).which(Being(Character.class)).which(InParty(Party.RED)).get()) { - object.addStatus(Status.FURIOUS); + player.tryToExecute( + GiveStatus(Status.FURIOUS, Effect.HandlerType.Owner).to(object) + ); } } diff --git a/src/main/java/eod/card/concrete/normal/SingleContract.java b/src/main/java/eod/card/concrete/normal/SingleContract.java index 820d954..c8520aa 100644 --- a/src/main/java/eod/card/concrete/normal/SingleContract.java +++ b/src/main/java/eod/card/concrete/normal/SingleContract.java @@ -22,7 +22,6 @@ public SingleContract() { @Override public void applyEffect(EffectExecutor executor) { WarObject[] characters = WarObject(player.getBoard()).which(OwnedBy(player.rival())).which(Being(Character.class)).which(WithoutStatus(Status.SNEAK)).get(); - ((Character) player.selectObject(characters)).damage(new DamageParam(4)); executor.tryToExecute( Damage(new DamageParam(4), Effect.HandlerType.Rival).onOneOf(player, characters) ); diff --git a/src/main/java/eod/card/concrete/normal/SupportAttack.java b/src/main/java/eod/card/concrete/normal/SupportAttack.java index 5413a45..b145de5 100644 --- a/src/main/java/eod/card/concrete/normal/SupportAttack.java +++ b/src/main/java/eod/card/concrete/normal/SupportAttack.java @@ -20,6 +20,7 @@ import static eod.specifier.WarObjectSpecifier.WarObject; import static eod.specifier.condition.Conditions.Being; import static eod.specifier.condition.Conditions.OwnedBy; +import static eod.effect.EffectFunctions.*; public class SupportAttack extends NormalCard { public SupportAttack() { @@ -80,7 +81,9 @@ public void onEventOccurred(GameObject sender, Event event) { if(event instanceof TargetedEvent) { TargetedEvent e = (TargetedEvent) event; if(e.getTarget() != holder) { - new Damage(new DamageParam(2), Effect.HandlerType.Rival).on((Damageable) e.getAttacker()); + player.tryToExecute( + Damage(new DamageParam(2), Effect.HandlerType.Rival).on((Damageable) e.getAttacker()) + ); teardown(); } } diff --git a/src/main/java/eod/warObject/WarObject.java b/src/main/java/eod/warObject/WarObject.java index 3f1fbec..c5ea22d 100644 --- a/src/main/java/eod/warObject/WarObject.java +++ b/src/main/java/eod/warObject/WarObject.java @@ -107,9 +107,6 @@ public ArrayList> supportedEventTypes() { @Override public void onEventOccurred(GameObject sender, Event event) { - if(hasStatus(Status.NO_EFFECT)) { - return; - } send(sender, event); } diff --git a/src/main/java/eod/warObject/character/concrete/blue/HeavyPolice.java b/src/main/java/eod/warObject/character/concrete/blue/HeavyPolice.java index 2005371..cd2a02c 100644 --- a/src/main/java/eod/warObject/character/concrete/blue/HeavyPolice.java +++ b/src/main/java/eod/warObject/character/concrete/blue/HeavyPolice.java @@ -21,7 +21,7 @@ public class HeavyPolice extends Character { public HeavyPolice(Player player) { super(player, 5,5, Party.BLUE); - new DamageLessThan2(this); + new DamageLessThan2(); } @Override @@ -54,14 +54,12 @@ public ArrayList getAttackRange() { } public class DamageLessThan2 implements EventReceiver { - private HeavyPolice holder; private ArrayList> canHandle; - public DamageLessThan2(HeavyPolice holder) { - this.holder = holder; - holder.registerReceiver(this); + public DamageLessThan2() { this.canHandle = new ArrayList<>(); canHandle.add(BeforeObjectDamageEvent.class); + HeavyPolice.this.registerReceiver(this); } @Override @@ -74,7 +72,7 @@ public void onEventOccurred(GameObject sender, Event event) { if(event instanceof BeforeObjectDamageEvent) { BeforeObjectDamageEvent e = (BeforeObjectDamageEvent) event; DamageParam param = e.getParam(); - if(e.getVictim() == holder && !param.realDamage) { + if(e.getVictim() == HeavyPolice.this && !param.realDamage) { if(param.damage > 2) { param.damage = 2; } @@ -85,8 +83,7 @@ public void onEventOccurred(GameObject sender, Event event) { @Override public void teardown() { canHandle.clear(); - holder.unregisterReceiver(this); - holder = null; + HeavyPolice.this.unregisterReceiver(this); } } } diff --git a/src/main/java/eod/warObject/character/concrete/red/AssaultTeamLeader.java b/src/main/java/eod/warObject/character/concrete/red/AssaultTeamLeader.java index 0e38337..6a809c3 100644 --- a/src/main/java/eod/warObject/character/concrete/red/AssaultTeamLeader.java +++ b/src/main/java/eod/warObject/character/concrete/red/AssaultTeamLeader.java @@ -19,12 +19,12 @@ import java.awt.*; import java.util.ArrayList; -import static eod.effect.EffectFunctions.RequestRegionalAttack; +import static eod.effect.EffectFunctions.*; public class AssaultTeamLeader extends Character { public AssaultTeamLeader(Player player) { super(player, 1, 1, Party.RED); - new OwnedAbilities(this); + new OwnedAbilities(); } @Override @@ -57,16 +57,14 @@ public String getName() { } private class OwnedAbilities implements EventReceiver { - private AssaultTeamLeader holder; private ArrayList> canHandle; - public OwnedAbilities(AssaultTeamLeader holder) { - this.holder = holder; + public OwnedAbilities() { canHandle = new ArrayList<>(); canHandle.add(RoundStartEvent.class); canHandle.add(ObjectEnterEnemyBaseEvent.class); canHandle.add(StatusAcquiredEvent.class); - holder.registerReceiver(this); + AssaultTeamLeader.this.registerReceiver(this); } @@ -79,7 +77,7 @@ public ArrayList> supportedEventTypes() { public void onEventOccurred(GameObject sender, Event event) { if(event instanceof RoundStartEvent) { RoundStartEvent e = (RoundStartEvent) event; - if (e.getStartedRound().getPlayer().isPlayerA() == holder.getPlayer().isPlayerA()) { + if (e.getStartedRound().getPlayer().isPlayerA() == AssaultTeamLeader.this.getPlayer().isPlayerA()) { PointParam param = new PointParam(); param.emptySpace = true; param.range = 1; @@ -91,24 +89,33 @@ public void onEventOccurred(GameObject sender, Event event) { } if(event instanceof StatusAcquiredEvent) { StatusAcquiredEvent e = (StatusAcquiredEvent) event; - if(e.getObject() == holder && e.getStatus() == Status.SNEAK) { - holder.addAttack(1); - holder.addHealth(1); + if(e.getObject() == AssaultTeamLeader.this && e.getStatus() == Status.SNEAK) { + Player owner = AssaultTeamLeader.this.getPlayer(); + owner.tryToExecute( + IncreaseAttack(1).to(AssaultTeamLeader.this) + ); + owner.tryToExecute( + IncreaseHealth(1).to(AssaultTeamLeader.this) + ); } } if(event instanceof ObjectEnterEnemyBaseEvent) { ObjectEnterEnemyBaseEvent e = (ObjectEnterEnemyBaseEvent) event; - if(e.getObject() == holder) { - holder.addAttack(1); - holder.addHealth(1); + if(e.getObject() == AssaultTeamLeader.this) { + Player owner = AssaultTeamLeader.this.getPlayer(); + owner.tryToExecute( + IncreaseAttack(1).to(AssaultTeamLeader.this) + ); + owner.tryToExecute( + IncreaseHealth(1).to(AssaultTeamLeader.this) + ); } } } @Override public void teardown() { - holder.unregisterReceiver(this); - holder = null; + AssaultTeamLeader.this.unregisterReceiver(this); canHandle.clear(); canHandle = null; } diff --git a/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java b/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java index 5a84385..28d2d82 100644 --- a/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java +++ b/src/main/java/eod/warObject/character/concrete/red/BloodThirstFighter.java @@ -23,7 +23,7 @@ public class BloodThirstFighter extends Fighter { public BloodThirstFighter(Player player) { super(player, 4, 3, Party.RED); - new OwnedAbilities(this); + new OwnedAbilities(); } @Override @@ -62,14 +62,12 @@ public ArrayList getAttackRange() { } private class OwnedAbilities implements EventReceiver { - private BloodThirstFighter holder; private ArrayList> canHandle; - public OwnedAbilities(BloodThirstFighter holder) { - this.holder = holder; + public OwnedAbilities() { canHandle = new ArrayList<>(); canHandle.add(ObjectEnterEvent.class); - holder.registerReceiver(this); + BloodThirstFighter.this.registerReceiver(this); } @Override @@ -81,8 +79,8 @@ public ArrayList> supportedEventTypes() { public void onEventOccurred(GameObject sender, Event event) { if(event instanceof ObjectEnterEvent) { ObjectEnterEvent e = (ObjectEnterEvent) event; - if(e.getObject() == holder) { - holder.attack(player); + if(e.getObject() == BloodThirstFighter.this) { + BloodThirstFighter.this.attack(player); teardown(); } } @@ -90,8 +88,7 @@ public void onEventOccurred(GameObject sender, Event event) { @Override public void teardown() { - holder.unregisterReceiver(this); - holder = null; + BloodThirstFighter.this.unregisterReceiver(this); canHandle.clear(); canHandle = null; } diff --git a/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java b/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java index 08d3956..80dadb2 100644 --- a/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java +++ b/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java @@ -25,7 +25,7 @@ public class CrazyBomber extends Character { public CrazyBomber(Player player) { super(player, 1, 2, Party.RED); - new OwnedAbilities(this); + new OwnedAbilities(); } @Override @@ -52,7 +52,9 @@ public void attack(EffectExecutor executor) { ArrayList singleTarget = new ArrayList<>(); singleTarget.add(p); - RequestRegionalAttack(attack).from(this).to(singleTarget); + executor.tryToExecute( + RequestRegionalAttack(attack).from(this).to(singleTarget) + ); PointParam param = new PointParam(); param.range = 1; @@ -63,14 +65,12 @@ public void attack(EffectExecutor executor) { } private class OwnedAbilities implements EventReceiver { - private CrazyBomber holder; private ArrayList> canHandle; - public OwnedAbilities(CrazyBomber holder) { - holder.registerReceiver(this); - this.holder = holder; + public OwnedAbilities() { canHandle = new ArrayList<>(); canHandle.add(ObjectDeadEvent.class); + CrazyBomber.this.registerReceiver(this); } @Override @@ -82,19 +82,18 @@ public ArrayList> supportedEventTypes() { public void onEventOccurred(GameObject sender, Event event) { if(event instanceof ObjectDeadEvent) { ObjectDeadEvent e = (ObjectDeadEvent) event; - if(e.getDeadObject() == holder) { + if(e.getDeadObject() == CrazyBomber.this) { PointParam param = new PointParam(); param.range = 1; SpecialRegionalAttack SRA = new SpecialRegionalAttack(3); - SRA.from(holder).to(player.getBoard().getSurrounding(position, param)); + SRA.from(CrazyBomber.this).to(player.getBoard().getSurrounding(position, param)); } } } @Override public void teardown() { - holder.unregisterReceiver(this); - holder = null; + CrazyBomber.this.unregisterReceiver(this); canHandle.clear(); canHandle = null; } diff --git a/src/main/java/eod/warObject/character/concrete/red/ExperiencedWarrior.java b/src/main/java/eod/warObject/character/concrete/red/ExperiencedWarrior.java index 70c3de3..08a01b2 100644 --- a/src/main/java/eod/warObject/character/concrete/red/ExperiencedWarrior.java +++ b/src/main/java/eod/warObject/character/concrete/red/ExperiencedWarrior.java @@ -22,7 +22,9 @@ public ExperiencedWarrior(Player player) { @Override public void attack(EffectExecutor executor) { super.attack(executor); - RequestRegionalAttack(attack).from(this).to(player, getAttackRange(), 1); + executor.tryToExecute( + RequestRegionalAttack(attack).from(this).to(player, getAttackRange(), 1) + ); afterAttack(); } diff --git a/src/main/java/eod/warObject/character/concrete/red/FrenzyCommander.java b/src/main/java/eod/warObject/character/concrete/red/FrenzyCommander.java index f9637ce..1a979f4 100644 --- a/src/main/java/eod/warObject/character/concrete/red/FrenzyCommander.java +++ b/src/main/java/eod/warObject/character/concrete/red/FrenzyCommander.java @@ -38,10 +38,16 @@ public String getName() { public void attack(EffectExecutor executor) { super.attack(executor); Summon s = Summon(new Gangster(player)); - s.onOnePointOf(player, getAttackRange()); + executor.tryToExecute( + s.onOnePointOf(player, getAttackRange()) + ); Gangster g = (Gangster) s.getObject(); - IncreaseAttack(2).to(g); - IncreaseHealth(2).to(g); + executor.tryToExecute( + IncreaseAttack(2).to(g) + ); + executor.tryToExecute( + IncreaseHealth(2).to(g) + ); afterAttack(); } diff --git a/src/main/java/eod/warObject/character/concrete/red/GuerrillaShooter.java b/src/main/java/eod/warObject/character/concrete/red/GuerrillaShooter.java index 43c2bc1..fae5c55 100644 --- a/src/main/java/eod/warObject/character/concrete/red/GuerrillaShooter.java +++ b/src/main/java/eod/warObject/character/concrete/red/GuerrillaShooter.java @@ -38,17 +38,19 @@ public void attack(EffectExecutor executor) { super.attack(executor); RegionalAttack effect = RequestRegionalAttack(attack).from(this).to(player, getAttackRange(), 1); executor.tryToExecute(effect); + + afterAttack(); + ArrayList affected = effect.getAffected(); if(affected.size() > 0 && affected.get(0).getHp() <= 0) { specialEffectTimes++; move(); } + if(specialEffectTimes >= 2) { specialEffectTimes -= 2; attack(executor); } - - afterAttack(); } @Override diff --git a/src/main/java/eod/warObject/character/concrete/red/LeadersGuard.java b/src/main/java/eod/warObject/character/concrete/red/LeadersGuard.java index 1ace920..0b10408 100644 --- a/src/main/java/eod/warObject/character/concrete/red/LeadersGuard.java +++ b/src/main/java/eod/warObject/character/concrete/red/LeadersGuard.java @@ -23,6 +23,7 @@ public class LeadersGuard extends Shooter { public LeadersGuard(Player player) { super(player, 5, 2, Party.RED); + new OwnedAbilities(); } @Override @@ -41,7 +42,9 @@ public String getName() { public void attack(EffectExecutor executor) { super.attack(executor); SpecialRegionalAttack SRA = new SpecialRegionalAttack(attack); - SRA.from(this).to(player, getAttackRange(), 1); + executor.tryToExecute( + SRA.from(this).to(player, getAttackRange(), 1) + ); } @Override @@ -50,14 +53,12 @@ public ArrayList getAttackRange() { } private class OwnedAbilities implements EventReceiver { - private LeadersGuard holder; private ArrayList> canHandle; - public OwnedAbilities(LeadersGuard holder) { - this.holder = holder; + public OwnedAbilities() { canHandle = new ArrayList<>(); canHandle.add(ObjectMovingEvent.class); - holder.registerReceiver(this); + LeadersGuard.this.registerReceiver(this); } @Override @@ -69,7 +70,7 @@ public ArrayList> supportedEventTypes() { public void onEventOccurred(GameObject sender, Event event) { if(event instanceof ObjectMovingEvent) { ObjectMovingEvent e = (ObjectMovingEvent) event; - if(e.getObject() == holder && !player.inBase(e.getNewPos())) { + if(e.getObject() == LeadersGuard.this && !player.inBase(e.getNewPos())) { e.setNewPos(e.getOrigPos()); } } @@ -77,8 +78,7 @@ public void onEventOccurred(GameObject sender, Event event) { @Override public void teardown() { - holder.unregisterReceiver(this); - holder = null; + LeadersGuard.this.unregisterReceiver(this); canHandle.clear(); canHandle = null; } diff --git a/src/main/java/eod/warObject/character/concrete/red/ToughGuy.java b/src/main/java/eod/warObject/character/concrete/red/ToughGuy.java index 59f525c..7d18fe1 100644 --- a/src/main/java/eod/warObject/character/concrete/red/ToughGuy.java +++ b/src/main/java/eod/warObject/character/concrete/red/ToughGuy.java @@ -16,11 +16,12 @@ import java.awt.*; import java.util.ArrayList; -import static eod.effect.EffectFunctions.RequestRegionalAttack; +import static eod.effect.EffectFunctions.*; public class ToughGuy extends Fighter { public ToughGuy(Player player) { super(player, 6, 3, Party.RED); + new OwnedAbilities(); } @Override @@ -51,14 +52,12 @@ public ArrayList getAttackRange() { } private class OwnedAbilities implements EventReceiver { - private ToughGuy holder; private ArrayList> canHandle; - public OwnedAbilities(ToughGuy holder) { - this.holder = holder; + public OwnedAbilities() { canHandle = new ArrayList<>(); canHandle.add(AfterObjectDamageEvent.class); - holder.registerReceiver(this); + ToughGuy.this.registerReceiver(this); } @Override @@ -70,17 +69,21 @@ public ArrayList> supportedEventTypes() { public void onEventOccurred(GameObject sender, Event event) { if(event instanceof AfterObjectDamageEvent) { AfterObjectDamageEvent e = (AfterObjectDamageEvent) event; - if(e.getVictim() == holder) { - holder.addAttack(2); - holder.addHealth(2); + if(e.getVictim() == ToughGuy.this) { + Player owner = ToughGuy.this.getPlayer(); + owner.tryToExecute( + IncreaseAttack(2).to(ToughGuy.this) + ); + owner.tryToExecute( + IncreaseHealth(2).to(ToughGuy.this) + ); } } } @Override public void teardown() { - holder.unregisterReceiver(this); - holder = null; + ToughGuy.this.unregisterReceiver(this); canHandle.clear(); canHandle = null; } diff --git a/src/main/java/eod/warObject/character/concrete/transparent/Drone.java b/src/main/java/eod/warObject/character/concrete/transparent/Drone.java index 80ef02c..8f0a6db 100644 --- a/src/main/java/eod/warObject/character/concrete/transparent/Drone.java +++ b/src/main/java/eod/warObject/character/concrete/transparent/Drone.java @@ -44,6 +44,8 @@ public void attack(EffectExecutor executor) { .which(Being(Damageable.class)) .which(InRangeOf(this)).get()) ); + + afterAttack(); } @Override diff --git a/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java b/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java index 387fc60..4f4c335 100644 --- a/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java +++ b/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java @@ -22,7 +22,7 @@ public class OwnerlessAssassin extends Assassin { public OwnerlessAssassin(Player player) { super(player, 2, 4, Party.TRANSPARENT); - new OwnedAbilities(this); + new OwnedAbilities(); } @Override @@ -53,14 +53,12 @@ public ArrayList getAttackRange() { } private class OwnedAbilities implements EventReceiver { - private OwnerlessAssassin holder; private ArrayList> canHandle; - public OwnedAbilities(OwnerlessAssassin holder) { - this.holder = holder; + public OwnedAbilities() { canHandle = new ArrayList<>(); canHandle.add(RoundStartEvent.class); - holder.registerReceiver(this); + OwnerlessAssassin.this.registerReceiver(this); } @Override @@ -72,14 +70,13 @@ public ArrayList> supportedEventTypes() { public void onEventOccurred(GameObject sender, Event event) { if(event instanceof RoundStartEvent) { RoundStartEvent e = (RoundStartEvent) event; - holder.player = e.getStartedRound().getPlayer(); + OwnerlessAssassin.this.player = e.getStartedRound().getPlayer(); } } @Override public void teardown() { - holder.unregisterReceiver(this); - holder = null; + OwnerlessAssassin.this.unregisterReceiver(this); canHandle.clear(); canHandle = null; } diff --git a/src/main/java/eod/warObject/character/concrete/transparent/Spacezipper.java b/src/main/java/eod/warObject/character/concrete/transparent/Spacezipper.java index 8496969..d6028c9 100644 --- a/src/main/java/eod/warObject/character/concrete/transparent/Spacezipper.java +++ b/src/main/java/eod/warObject/character/concrete/transparent/Spacezipper.java @@ -25,7 +25,7 @@ public class Spacezipper extends Character implements Marker { public Spacezipper(Player player) { super(player, 5, 3, Party.TRANSPARENT); marked = new ArrayList<>(); - new OwnedAbilities(this); + new OwnedAbilities(); } @Override @@ -105,14 +105,12 @@ public ArrayList getMarks() { } private class OwnedAbilities implements EventReceiver { - private Spacezipper holder; private ArrayList> canHandle; - public OwnedAbilities(Spacezipper holder) { - this.holder = holder; + public OwnedAbilities() { canHandle = new ArrayList<>(); canHandle.add(RoundStartEvent.class); - holder.registerReceiver(this); + Spacezipper.this.registerReceiver(this); } @Override @@ -124,17 +122,16 @@ public ArrayList> supportedEventTypes() { public void onEventOccurred(GameObject sender, Event event) { if(event instanceof RoundStartEvent) { RoundStartEvent e = (RoundStartEvent) event; - if(e.getStartedRound().getPlayer().isPlayerA() == holder.player.isPlayerA()) { - holder.mark(holder.position); - holder.move(); + if(e.getStartedRound().getPlayer().isPlayerA() == Spacezipper.this.player.isPlayerA()) { + Spacezipper.this.mark(Spacezipper.this.position); + Spacezipper.this.move(); } } } @Override public void teardown() { - holder.unregisterReceiver(this); - holder = null; + Spacezipper.this.unregisterReceiver(this); canHandle.clear(); canHandle = null; } From 3ac3b14c84d7afb54d1f0d271cc17b87d8c44316 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Tue, 26 May 2020 18:41:07 +0800 Subject: [PATCH 19/22] bug fix --- src/main/java/eod/Player.java | 4 +--- src/main/java/eod/card/concrete/normal/GrandFeast.java | 7 ++++++- .../eod/warObject/character/abstraction/Character.java | 2 -- 3 files changed, 7 insertions(+), 6 deletions(-) diff --git a/src/main/java/eod/Player.java b/src/main/java/eod/Player.java index 8e18fcb..3c063f3 100644 --- a/src/main/java/eod/Player.java +++ b/src/main/java/eod/Player.java @@ -477,9 +477,7 @@ public void onEventOccurred(GameObject sender, Event event) { output.sendWarObjectMoved(movingEvent.getObject(), movingEvent.getNewPos()); } - receivers.stream() - .filter(receiver -> receiver.supportedEventTypes().contains(event.getClass())) - .forEach(receiver -> receiver.onEventOccurred(sender, event)); + send(sender, event); } public class Snapshot implements eod.snapshots.Snapshot { diff --git a/src/main/java/eod/card/concrete/normal/GrandFeast.java b/src/main/java/eod/card/concrete/normal/GrandFeast.java index 1707d33..7688aeb 100644 --- a/src/main/java/eod/card/concrete/normal/GrandFeast.java +++ b/src/main/java/eod/card/concrete/normal/GrandFeast.java @@ -31,7 +31,12 @@ public GrandFeast() { @Override public void applyEffect(EffectExecutor executor) { - for(WarObject object:WarObject (player.getBoard()).which(OwnedBy(player)).which(Being(Character.class)).which(InParty(Party.RED)).get()) { + for(WarObject object:WarObject( + player.getBoard()) + .which(OwnedBy(player)) + .which(Being(Character.class)) + .which(InParty(Party.RED)).get() + ) { player.tryToExecute( GiveStatus(Status.FURIOUS, Effect.HandlerType.Owner).to(object) ); diff --git a/src/main/java/eod/warObject/character/abstraction/Character.java b/src/main/java/eod/warObject/character/abstraction/Character.java index a9d8a7a..231396c 100644 --- a/src/main/java/eod/warObject/character/abstraction/Character.java +++ b/src/main/java/eod/warObject/character/abstraction/Character.java @@ -61,8 +61,6 @@ public void addAttack(int a) { @Override public void attack(EffectExecutor executor) { removeStatus(Status.SNEAK); - - afterAttack(); } @Override From f924cb1e4ff9ea86a3e4c76567ca753ab433119e Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Tue, 26 May 2020 18:54:04 +0800 Subject: [PATCH 20/22] Set theme jekyll-theme-slate --- _config.yml | 1 + 1 file changed, 1 insertion(+) create mode 100644 _config.yml diff --git a/_config.yml b/_config.yml new file mode 100644 index 0000000..c741881 --- /dev/null +++ b/_config.yml @@ -0,0 +1 @@ +theme: jekyll-theme-slate \ No newline at end of file From a99f9dcbd1aeefb13a6bf123c531d07d84d31929 Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Wed, 27 May 2020 10:35:49 +0800 Subject: [PATCH 21/22] another bug fix --- src/main/java/eod/card/concrete/normal/GrandFeast.java | 2 +- .../eod/warObject/character/concrete/red/CrazyBomber.java | 7 +++++-- .../eod/warObject/character/concrete/red/ToughGuy.java | 4 +++- .../character/concrete/transparent/OwnerlessAssassin.java | 2 +- 4 files changed, 10 insertions(+), 5 deletions(-) diff --git a/src/main/java/eod/card/concrete/normal/GrandFeast.java b/src/main/java/eod/card/concrete/normal/GrandFeast.java index 7688aeb..35cf64d 100644 --- a/src/main/java/eod/card/concrete/normal/GrandFeast.java +++ b/src/main/java/eod/card/concrete/normal/GrandFeast.java @@ -37,7 +37,7 @@ public void applyEffect(EffectExecutor executor) { .which(Being(Character.class)) .which(InParty(Party.RED)).get() ) { - player.tryToExecute( + executor.tryToExecute( GiveStatus(Status.FURIOUS, Effect.HandlerType.Owner).to(object) ); } diff --git a/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java b/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java index 80dadb2..558da54 100644 --- a/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java +++ b/src/main/java/eod/warObject/character/concrete/red/CrazyBomber.java @@ -20,6 +20,7 @@ import java.awt.*; import java.util.ArrayList; +import static eod.effect.EffectFunctions.Damage; import static eod.effect.EffectFunctions.RequestRegionalAttack; public class CrazyBomber extends Character { @@ -59,7 +60,9 @@ public void attack(EffectExecutor executor) { PointParam param = new PointParam(); param.range = 1; SpecialRegionalAttack SRA = new SpecialRegionalAttack(1); - SRA.to(player.getBoard().getSurrounding(p, param)); + executor.tryToExecute( + SRA.to(player.getBoard().getSurrounding(p, param)) + ); afterAttack(); } @@ -111,7 +114,7 @@ public RegionalAttack to(ArrayList targets) { for(Point p:targets) { try { Damageable target = board.getObjectOn(p.x, p.y); - target.damage(new DamageParam(param.hp)); + Damage(new DamageParam(param.hp), HandlerType.Rival).on(target); } catch (IllegalArgumentException e) { System.out.println("There's no object on the point, skipping."); } diff --git a/src/main/java/eod/warObject/character/concrete/red/ToughGuy.java b/src/main/java/eod/warObject/character/concrete/red/ToughGuy.java index 7d18fe1..b4296ba 100644 --- a/src/main/java/eod/warObject/character/concrete/red/ToughGuy.java +++ b/src/main/java/eod/warObject/character/concrete/red/ToughGuy.java @@ -39,7 +39,9 @@ public String getName() { @Override public void attack(EffectExecutor executor) { super.attack(executor); - RequestRegionalAttack(attack).from(this).to(getAttackRange()); + executor.tryToExecute( + RequestRegionalAttack(attack).from(this).to(getAttackRange()) + ); afterAttack(); } diff --git a/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java b/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java index 4f4c335..a808a8c 100644 --- a/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java +++ b/src/main/java/eod/warObject/character/concrete/transparent/OwnerlessAssassin.java @@ -34,7 +34,7 @@ public SummonCard getSummonCard() { @Override public String getName() { - return "無主的殺手"; + return "無主的刺客"; } @Override From c8ec65dd24cdf9de628191744a5a4c5084c3c3ab Mon Sep 17 00:00:00 2001 From: aoaaceai <54458354+aoaaceai@users.noreply.github.com> Date: Wed, 27 May 2020 11:22:03 +0800 Subject: [PATCH 22/22] Sundar and AttackCard fix --- .../card/abstraction/action/AttackCard.java | 4 +- .../attack/transparent/PreciseShot.java | 8 +- .../concrete/attack/transparent/Snipe.java | 7 +- .../eod/card/concrete/command/DeathPulse.java | 75 ++++++++++++++++++- .../java/eod/warObject/leader/red/Sundar.java | 45 +---------- 5 files changed, 87 insertions(+), 52 deletions(-) diff --git a/src/main/java/eod/card/abstraction/action/AttackCard.java b/src/main/java/eod/card/abstraction/action/AttackCard.java index 2a02f86..63ce689 100644 --- a/src/main/java/eod/card/abstraction/action/AttackCard.java +++ b/src/main/java/eod/card/abstraction/action/AttackCard.java @@ -10,7 +10,7 @@ public AttackCard(int cost) { } public Player rival; - public abstract Attack attack(); + public abstract void attack(EffectExecutor executor); @Override public void setPlayer(Player p) { @@ -20,6 +20,6 @@ public void setPlayer(Player p) { @Override public void applyEffect(EffectExecutor executor) { - executor.tryToExecute(attack()); + attack(executor); } } diff --git a/src/main/java/eod/card/concrete/attack/transparent/PreciseShot.java b/src/main/java/eod/card/concrete/attack/transparent/PreciseShot.java index 127a29d..9bd49a1 100644 --- a/src/main/java/eod/card/concrete/attack/transparent/PreciseShot.java +++ b/src/main/java/eod/card/concrete/attack/transparent/PreciseShot.java @@ -5,6 +5,7 @@ import eod.card.abstraction.Card; import eod.card.abstraction.action.AttackCard; import eod.effect.Attack; +import eod.effect.EffectExecutor; import eod.effect.RegionalAttack; import eod.specifier.Accessing; import eod.warObject.Status; @@ -22,14 +23,15 @@ public PreciseShot() { } @Override - public Attack attack() { + public void attack(EffectExecutor executor) { Accessing characters = WarObject(player.getBoard()).which(Being(Character.class)); RegionalAttack attack = RequestRegionalAttack(3) .from(player, characters.which(OwnedBy(player)).which(Being(Shooter.class)).get() ); - return attack.to(player, - characters.which(OwnedBy(rival)).which(InRangeOf(attack.attacker())).which(WithoutStatus(Status.SNEAK)).get()); + executor.tryToExecute(attack.to(player, + characters.which(OwnedBy(rival)).which(InRangeOf(attack.attacker())).which(WithoutStatus(Status.SNEAK)).get()) + ); } @Override diff --git a/src/main/java/eod/card/concrete/attack/transparent/Snipe.java b/src/main/java/eod/card/concrete/attack/transparent/Snipe.java index 46661ba..f11bd2e 100644 --- a/src/main/java/eod/card/concrete/attack/transparent/Snipe.java +++ b/src/main/java/eod/card/concrete/attack/transparent/Snipe.java @@ -5,6 +5,7 @@ import eod.card.abstraction.Card; import eod.card.abstraction.action.AttackCard; import eod.effect.Attack; +import eod.effect.EffectExecutor; import eod.effect.RegionalAttack; import eod.specifier.Accessing; import eod.warObject.Damageable; @@ -29,11 +30,13 @@ public Card copy() { } @Override - public Attack attack() { + public void attack(EffectExecutor executor) { Accessing objects = WarObject(player.getBoard()); WarObject[] ownedSnipers = objects.which(OwnedBy(player)).which(Being(Sniper.class)).get(); RegionalAttack attack = RequestRegionalAttack(decideAttack(ownedSnipers)).from(player, ownedSnipers); - return attack.to(player, objects.which(OwnedBy(rival)).which(InRangeOf(attack.attacker())).which(Being(Damageable.class)).which(WithoutStatus(Status.SNEAK)).get()); + executor.tryToExecute( + attack.to(player, objects.which(OwnedBy(rival)).which(InRangeOf(attack.attacker())).which(Being(Damageable.class)).which(WithoutStatus(Status.SNEAK)).get()) + ); } private int decideAttack(WarObject[] snipers) { diff --git a/src/main/java/eod/card/concrete/command/DeathPulse.java b/src/main/java/eod/card/concrete/command/DeathPulse.java index 8a45ffc..8d1a0ea 100644 --- a/src/main/java/eod/card/concrete/command/DeathPulse.java +++ b/src/main/java/eod/card/concrete/command/DeathPulse.java @@ -1,11 +1,28 @@ package eod.card.concrete.command; +import eod.Gameboard; import eod.Party; import eod.card.abstraction.Card; import eod.card.abstraction.action.AttackCard; import eod.effect.Attack; +import eod.effect.Effect; +import eod.effect.EffectExecutor; +import eod.effect.RegionalAttack; +import eod.param.DamageParam; +import eod.param.PointParam; +import eod.warObject.CanAttack; +import eod.warObject.Damageable; +import eod.warObject.WarObject; +import eod.warObject.character.abstraction.Bunker; +import eod.warObject.character.abstraction.Machine; +import eod.warObject.character.abstraction.other.Ghost; import eod.warObject.leader.red.Sundar; +import java.awt.*; +import java.util.ArrayList; + +import static eod.effect.EffectFunctions.Damage; +import static eod.effect.EffectFunctions.RequestRegionalAttack; import static eod.specifier.WarObjectSpecifier.WarObject; import static eod.specifier.condition.Conditions.Being; import static eod.specifier.condition.Conditions.OwnedBy; @@ -16,9 +33,21 @@ public DeathPulse() { } @Override - public Attack attack() { + public void attack(EffectExecutor executor) { Sundar sundar = (Sundar) WarObject(player.getBoard()).which(Being(Sundar.class)).which(OwnedBy(player)).get()[0]; - return sundar.deathPulse(); + executor.tryToExecute( + Damage(new DamageParam(4), Effect.HandlerType.Owner).on(sundar) + ); + + PointParam pointParam = new PointParam(); + pointParam.range = Gameboard.boardSize; + ArrayList attackRange = player.getBoard().get8ways(sundar.position, pointParam); + + SpecialRegionalAttack SRA = new SpecialRegionalAttack(4); + + executor.tryToExecute( + SRA.from(sundar).realDamage().to(attackRange, player.getBoard(), executor) + ); } @Override @@ -37,4 +66,46 @@ public String getName() { public Party getParty() { return Party.RED; } + + private class SpecialRegionalAttack extends RegionalAttack { + + protected SpecialRegionalAttack(int hp) { + super(hp); + } + + @Override + public SpecialRegionalAttack from(WarObject attacker) { + this.attacker = (CanAttack) attacker; + return this; + } + + @Override + public SpecialRegionalAttack realDamage() { + param.realDamage = true; + return this; + } + + public RegionalAttack to(ArrayList candidates, Gameboard gameboard, EffectExecutor executor) { + ArrayList targets = new ArrayList<>(); + for(Point p:candidates) { + try { + WarObject object = gameboard.getObjectOn(p.x, p.y); + if(object instanceof Bunker || object instanceof Machine) { + continue; + } + + if(object.getPlayer().isPlayerA() == player.isPlayerA() && object instanceof Ghost) { + Ghost ghost = (Ghost) object; + ghost.attack(executor); + } else { + targets.add(p); + } + + } catch (IllegalArgumentException e) { + System.out.println("There's no objects on the position. Skipping."); + } + } + return to(targets); + } + } } diff --git a/src/main/java/eod/warObject/leader/red/Sundar.java b/src/main/java/eod/warObject/leader/red/Sundar.java index df0f17b..b22856d 100644 --- a/src/main/java/eod/warObject/leader/red/Sundar.java +++ b/src/main/java/eod/warObject/leader/red/Sundar.java @@ -5,6 +5,7 @@ import eod.card.concrete.command.DeathPulse; import eod.card.concrete.command.EquivalentExchange; import eod.effect.Attack; +import eod.effect.Effect; import eod.effect.EffectExecutor; import eod.event.Event; import eod.event.ObjectDeadEvent; @@ -26,8 +27,7 @@ import java.awt.*; import java.util.ArrayList; -import static eod.effect.EffectFunctions.Summon; -import static eod.effect.EffectFunctions.RequestRegionalAttack; +import static eod.effect.EffectFunctions.*; public class Sundar extends Leader { public Sundar(Player player) { @@ -50,47 +50,6 @@ public void attack(EffectExecutor executor) { executor.tryToExecute(Summon(new LittleGhost(player)).on(p)); } - public Attack deathPulse() { - PointParam pointParam = new PointParam(); - pointParam.range = Gameboard.boardSize; - ArrayList targets = player.getBoard().get8ways(position, pointParam); - return RequestRegionalAttack(4).from(this).to(targets); - } - - @Override - public ArrayList attack(Gameboard gameboard, ArrayList targets, AttackParam param) { - ArrayList affected = new ArrayList<>(); - this.damage(new DamageParam(param.hp)); - int a; - if(hasStatus(Status.FURIOUS)) { - a = param.hp * 2; - } else { - a = param.hp; - } - this.damage(new DamageParam(param.hp)); - DamageParam dp = new DamageParam(a); - dp.realDamage = param.realDamage; - for(Point p:targets) { - try { - WarObject target = gameboard.getObjectOn(p.x, p.y); - if(target instanceof Bunker || target instanceof Machine) { - continue; - } - if(target.getPlayer().isPlayerA() == player.isPlayerA()) { - if(target instanceof Ghost) { - ((Ghost) target).attack(player); //TODO: This need to be fixed - } - } else { - ((Damageable) target).attacked(this, dp); - affected.add((Damageable) target); - } - } catch (Exception e) { - System.out.println(e.toString()); - } - } - return affected; - } - @Override protected ArrayList generateCommand() { ArrayList deck = new ArrayList<>();