Handle simulation start

Signed-off-by: pacien <pacien.trangirard@pacien.net>

3 files changed, 60 insertions, 16 deletions

diff --git a/src/main/java/fr/umlv/java/wallj/block/BombBlock.java b/src/main/java/fr/umlv/java/wallj/block/BombBlock.java
index 4f310eb..5570583 100644
--- a/src/main/java/fr/umlv/java/wallj/block/BombBlock.java
+++ b/src/main/java/fr/umlv/java/wallj/block/BombBlock.java
@@ -26,6 +26,7 @@ public class BombBlock extends JBoxBlock {
   private static final Duration MAX_TIME = Duration.ofSeconds(9);
 
   private Duration timer = MIN_TIME;
+  private boolean ignited = false;
 
   BombBlock(Vec2 pos) {
     super(BlockType.BOMB, BodyType.STATIC, SolidDef.squareShape(), pos);
@@ -44,6 +45,7 @@ public class BombBlock extends JBoxBlock {
   public Stream<Event> update(Context context) {
     return Updateables.updateAll(context,
     this::handleBombConfiguration,
+    this::handleSimulationStart,
     this::consume,
     this::paint);
   }
@@ -55,8 +57,14 @@ public class BombBlock extends JBoxBlock {
     return Stream.empty();
   }
 
+  private Stream<Event> handleSimulationStart(Context context) {
+    Events.findFirst(context.getEvents(), SimulationStartEvent.class)
+    .ifPresent(startEvent -> ignited = true);
+    return Stream.empty();
+  }
+
   private Stream<Event> consume(Context context) {
-    decrementTimer(context.getTimeDelta());
+    if (ignited) decrementTimer(context.getTimeDelta());
     return timer.isNegative() ?
            Stream.of(new BombExplosionEvent(TileVec2.of(getPos())), new BlockDestroyEvent(this)) :
            Stream.empty();
diff --git a/src/main/java/fr/umlv/java/wallj/block/RobotBlock.java b/src/main/java/fr/umlv/java/wallj/block/RobotBlock.java
index 11cf25f..6909555 100644
--- a/src/main/java/fr/umlv/java/wallj/block/RobotBlock.java
+++ b/src/main/java/fr/umlv/java/wallj/block/RobotBlock.java
@@ -23,13 +23,16 @@ import java.util.stream.Stream;
 public class RobotBlock extends Block {
   private static final float SPEED = 10f; // px/ms
 
+  private final TileVec2 initialPos;
   private Vec2 pos;
   private PathFinder pathFinder;
   private Deque<TileVec2> path = new LinkedList<>();
   private int droppedBombCount = 0;
+  private boolean isHiding = false;
 
   RobotBlock(Vec2 pos) {
     super(BlockType.ROBOT);
+    this.initialPos = TileVec2.of(pos);
     this.pos = pos;
   }
 
@@ -51,12 +54,29 @@ public class RobotBlock extends Block {
   @Override
   public Stream<Event> update(Context context) {
     return Updateables.updateAll(context,
+    this::handleSimulationStart,
     this::updatePath,
     this::move,
+    this::disappear,
     this::paint,
     this::setupBomb);
   }
 
+  private Stream<Event> handleSimulationStart(Context context) {
+    return Events.findFirst(context.getEvents(), SimulationStartEvent.class)
+           .map(startEvent -> {
+             isHiding = true;
+             return Stream.<Event>of(new MoveRobotOrder(initialPos));
+           })
+           .orElse(Stream.empty());
+  }
+
+  private Stream<Event> disappear(Context context) {
+    return isHiding && Objects.equals(TileVec2.of(pos), initialPos) ?
+           Stream.of(new BlockDestroyEvent(this)) :
+           Stream.empty();
+  }
+
   private Stream<Event> setupBomb(Context context) {
     return Events.findFirst(context.getEvents(), BombSetupOrder.class)
            .flatMap(event -> isOnBomb(context.getGame().getCurrentStage()) ?
@@ -78,6 +98,7 @@ public class RobotBlock extends Block {
       Board board = context.getGame().getCurrentStage().getBoard();
       TileVec2 target = event.getTarget();
       if (!board.inside(target) || !board.getBlockTypeAt(target).isTraversable()) return;
+      if (isHiding && !Objects.equals(target, initialPos)) return;
       if (pathFinder == null) pathFinder = new PathFinder(board);
       path = new LinkedList<>(pathFinder.findPath(TileVec2.of(pos), target));
     });
diff --git a/src/main/java/fr/umlv/java/wallj/context/Stage.java b/src/main/java/fr/umlv/java/wallj/context/Stage.java
index 44fad7b..9b66e03 100644
--- a/src/main/java/fr/umlv/java/wallj/context/Stage.java
+++ b/src/main/java/fr/umlv/java/wallj/context/Stage.java
@@ -6,10 +6,7 @@ import fr.umlv.java.wallj.block.BlockType;
 import fr.umlv.java.wallj.board.Board;
 import fr.umlv.java.wallj.board.BoardConverter;
 import fr.umlv.java.wallj.board.TileVec2;
-import fr.umlv.java.wallj.event.BlockCreateEvent;
-import fr.umlv.java.wallj.event.BlockDestroyEvent;
-import fr.umlv.java.wallj.event.Event;
-import fr.umlv.java.wallj.event.Events;
+import fr.umlv.java.wallj.event.*;
 import org.jbox2d.common.Vec2;
 import org.jbox2d.dynamics.World;
 
@@ -27,6 +24,7 @@ public class Stage implements Updateable {
   private final World world = new World(new Vec2());
   private final List<Block> blocks = new LinkedList<>();
   private final Board board;
+  private boolean running = false;
 
   /**
    * @param board the base board
@@ -69,30 +67,38 @@ public class Stage implements Updateable {
   }
 
   /**
-   * @return T(the physics simulation can start, i.e. the player has placed all their bombs)
-   */
-  public boolean isReady() {
-    return blocks.stream()
-           .filter(block -> block.getType() == BlockType.BOMB)
-           .count() == BOMB_PLACEMENTS;
-  }
-
-  /**
    * @param context the current context
    * @return the stream of newly generated events
    */
   @Override
   public Stream<Event> update(Context context) {
     return Updateables.updateAll(context,
+    this::handleSimulationStartOrder,
+    this::handleSimulationStartEvent,
     this::updatePhysicalWorld,
     this::handleBlockDestruction,
     this::handleBlockCreation,
     ctx -> Updateables.updateAll(ctx, blocks));
   }
 
+  private Stream<Event> handleSimulationStartOrder(Context context) {
+    return Events.findFirst(context.getEvents(), SimulationStartOrder.class)
+           .flatMap(order -> isReady() ? Optional.<Event>of(new SimulationStartEvent()) : Optional.empty())
+           .map(Stream::of) // Optional.stream() only available in Java 9
+           .orElseGet(Stream::empty);
+  }
+
+  private Stream<Event> handleSimulationStartEvent(Context context) {
+    Events.findFirst(context.getEvents(), SimulationStartEvent.class)
+    .ifPresent(startEvent -> running = true);
+    return Stream.empty();
+  }
+
   private Stream<Event> updatePhysicalWorld(Context context) {
-    int dt = (int) context.getTimeDelta().toMillis();
-    world.step(dt, dt * VELOCITY_TICK_PER_MS, dt * POSITION_TICK_PER_MS);
+    if (running) {
+      int dt = (int) context.getTimeDelta().toMillis();
+      world.step(dt, dt * VELOCITY_TICK_PER_MS, dt * POSITION_TICK_PER_MS);
+    }
     return Stream.empty();
   }
 
@@ -112,6 +118,15 @@ public class Stage implements Updateable {
     return Stream.empty();
   }
 
+  /**
+   * @implNote TODO: profile this and consider a bomb block counter
+   */
+  private boolean isReady() {
+    return blocks.stream()
+           .filter(block -> block.getType() == BlockType.BOMB)
+           .count() == BOMB_PLACEMENTS;
+  }
+