Merge pull request #35 from aoaaceai/master

make every skill a standalone class for accessibilty

_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-slate

src/main/java/eod/BoardPosition.java

@@ -0,0 +1,8 @@
+package eod;
+
+public enum BoardPosition {
+    SELF_BASE,
+    ENEMY_BASE,
+    SELF_CONFLICT,
+    ENEMY_CONFLICT
+}

src/main/java/eod/Game.java

@@ -5,10 +5,10 @@
 import eod.effect.Effect;
 import eod.effect.EffectExecutor;
 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.exceptions.NotSupportedException;
 import eod.param.AttackParam;
@@ -196,11 +196,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

src/main/java/eod/Gameboard.java

@@ -83,6 +83,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<Point> getPlayersConflict(Player player, PointParam param) {
         int iMin, iMax;
         if(player.isPlayerA()) {
@@ -244,7 +268,12 @@ public void summonObject(WarObject object, Point point) throws IllegalArgumentEx
         }
         board[x][y] = object;
         object.updatePosition(point);
-        game.sendEvent(this, new ObjectEnterEvent(object));
+    }
+
+    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

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() + "贏了");

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);

src/main/java/eod/Player.java

@@ -9,10 +9,12 @@
 import eod.effect.EffectExecutor;
 import eod.event.Event;
 import eod.event.*;
-import eod.event.listener.EventListener;
+import eod.event.relay.EventReceiver;
+import eod.event.relay.EventSender;
 import eod.exceptions.GameLosingException;
 import eod.exceptions.NotSupportedException;
 import eod.param.AttackParam;
+import eod.param.DamageParam;
 import eod.param.PointParam;
 import eod.snapshots.Snapshotted;
 import eod.warObject.CanAttack;
@@ -28,7 +30,7 @@
 import java.util.Objects;
 
 public class Player implements Snapshotted<Player.Snapshot>,
-                                GameObject, EventListener, EffectExecutor {
+                                GameObject, EventReceiver, EventSender, EffectExecutor {
 
     private Deck deck;
     private Game game;
@@ -39,6 +41,7 @@ public class Player implements Snapshotted<Player.Snapshot>,
     private String name;
     private boolean isPlayerA;
     private boolean isActingPlayer = false;
+    private ArrayList<EventReceiver> receivers;
 
     public Player(Deck deck, String name) {
         this(deck, new Hand(), name);
@@ -48,6 +51,7 @@ public Player(Deck deck, Hand hand, String name) {
         this.deck = deck;
         this.hand = hand;
         this.name = name;
+        receivers = new ArrayList<>();
     }
 
     public String getName() {
@@ -60,7 +64,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;
@@ -218,8 +222,8 @@ public ArrayList<Damageable> attack(CanAttack attacker,
         return attacker.attack(target, param);
     }
 
-    public void damage(Damageable target, int hp) {
-        target.damage(hp);
+    public void damage(Damageable target, DamageParam param) {
+        target.damage(param);
     }
 
     public void heal(Damageable damageable, int hp) {
@@ -288,6 +292,11 @@ public void summonObject(WarObject object, Point point) {
         output.sendWarObjectSummoned(object, point);
     }
 
+    public void transferObjectTo(WarObject from, WarObject to) {
+        getBoard().transfer(from, to);
+        output.sendWarObjectTransferred(from, to);
+    }
+
     @Override
     public void teardown() {
         hand.teardown();
@@ -296,6 +305,10 @@ public void teardown() {
         deck = null;
         leader.teardown();
         leader = null;
+        for(EventReceiver receiver:receivers) {
+            receiver.teardown();
+        }
+        receivers.clear();
     }
 
     @Override
@@ -343,10 +356,21 @@ 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)) {
+            sendUp(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) {
@@ -392,15 +416,30 @@ public ArrayList<Point> getFront(Point p, PointParam param) {
         return getBoard().getLine(p, dx, 0, param);
     }
 
-    public void registerListener(EventListener listener) {
-        game.registerListener(listener);
+    public BoardPosition getPosition(Point p) {
+        return getBoard().getPosition(this, p);
+    }
+
+    @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);
     }
 
@@ -420,30 +459,24 @@ public ArrayList<Class<? extends Event>> 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());
         }
+
+        send(sender, event);
     }
 
     public class Snapshot implements eod.snapshots.Snapshot {

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);
     }
 }

src/main/java/eod/card/concrete/attack/transparent/PreciseShot.java

@@ -1,12 +1,15 @@
 package eod.card.concrete.attack.transparent;
 
 import eod.Party;
+import eod.Player;
 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;
+import eod.warObject.WarObject;
 import eod.warObject.character.abstraction.Character;
 import eod.warObject.character.abstraction.assaulter.Shooter;
 
@@ -20,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

src/main/java/eod/card/concrete/attack/transparent/Snipe.java

@@ -1,9 +1,11 @@
 package eod.card.concrete.attack.transparent;
 
 import eod.Party;
+import eod.Player;
 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;
@@ -28,11 +30,21 @@ 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(8).from(player, ownedSnipers);
-        return attack.to(player, objects.which(OwnedBy(rival)).which(InRangeOf(attack.attacker())).which(Being(Damageable.class)).which(WithoutStatus(Status.SNEAK)).get());
+        RegionalAttack attack = RequestRegionalAttack(decideAttack(ownedSnipers)).from(player, ownedSnipers);
+        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) {
+        if(snipers.length >= 2) {
+            return 8;
+        } else {
+            return 6;
+        }
     }
 
     @Override