1 files changed, 178 insertions, 0 deletions

diff --git a/src/ch/epfl/xblast/client/XBlastComponent.java b/src/ch/epfl/xblast/client/XBlastComponent.java
new file mode 100644
index 0000000..388a208
--- /dev/null
+++ b/src/ch/epfl/xblast/client/XBlastComponent.java
@@ -0,0 +1,178 @@
+package ch.epfl.xblast.client;
+
+import ch.epfl.xblast.Cell;
+import ch.epfl.xblast.Lists;
+import ch.epfl.xblast.PlayerID;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.image.ImageObserver;
+import java.util.*;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+/**
+ * The game graphical component.
+ *
+ * @author Pacien TRAN-GIRARD (261948)
+ * @author Timothée FLOURE (257420)
+ */
+public final class XBlastComponent extends JComponent {
+
+    private static class Grid {
+
+        private static final Dimension CELL_DIMENSION = new Dimension(64, 48);
+        private static final Dimension SCORE_IMG_DIMENSION = new Dimension(48, 48);
+        private static final Dimension TIME_LED_DIMENSION = new Dimension(16, 16);
+        private static final Dimension FRAME_DIMENSION = totalDimension();
+
+        private static final List<Point> CELL_POSITIONS = buildCellGrid(CELL_DIMENSION);
+        private static final List<Point> SCORE_BG_POSITIONS = buildScoreGrid();
+        private static final List<Point> TIME_LINE_POSITIONS = buildTimeLineGrid();
+        private static final Map<PlayerID, Point> SCORE_TXT_POSITIONS = buildScoreMap(659);
+
+        private static Dimension totalDimension() {
+            return new Dimension(
+                    CELL_DIMENSION.width * Cell.COLUMNS,
+                    CELL_DIMENSION.height * Cell.ROWS + SCORE_IMG_DIMENSION.height + TIME_LED_DIMENSION.height);
+        }
+
+        private static List<Point> buildCellGrid(Dimension elementDim) {
+            return Collections.unmodifiableList(Cell.ROW_MAJOR_ORDER.stream()
+                    .map(c -> new Point(c.x() * elementDim.width, c.y() * elementDim.height))
+                    .collect(Collectors.toList()));
+        }
+
+        private static List<Point> buildLine(Dimension elementDim, int len, Point shift) {
+            return Collections.unmodifiableList(IntStream.range(0, len)
+                    .mapToObj(x -> new Point(x * elementDim.width + shift.x, shift.y))
+                    .collect(Collectors.toList()));
+        }
+
+        private static List<Point> buildScoreGrid() {
+            return buildLine(
+                    SCORE_IMG_DIMENSION,
+                    FRAME_DIMENSION.width / SCORE_IMG_DIMENSION.width,
+                    new Point(0, CELL_DIMENSION.height * Cell.ROWS));
+        }
+
+        private static List<Point> buildTimeLineGrid() {
+            return buildLine(
+                    TIME_LED_DIMENSION,
+                    FRAME_DIMENSION.width / TIME_LED_DIMENSION.width,
+                    new Point(0, CELL_DIMENSION.height * Cell.ROWS + SCORE_IMG_DIMENSION.height));
+        }
+
+        private static Map<PlayerID, Point> buildScoreMap(int vShift) {
+            Map<PlayerID, Point> m = new EnumMap<>(PlayerID.class);
+            m.put(PlayerID.PLAYER_1, new Point(96, vShift));
+            m.put(PlayerID.PLAYER_2, new Point(240, vShift));
+            m.put(PlayerID.PLAYER_3, new Point(768, vShift));
+            m.put(PlayerID.PLAYER_4, new Point(912, vShift));
+            return m;
+        }
+
+        private static Point positionForPlayer(GameState.Player p) {
+            return new Point(
+                    4 * p.position().x() - 24,
+                    3 * p.position().y() - 52);
+        }
+
+    }
+
+    private static class Painter {
+
+        private static final ImageObserver IMG_OBSERVER = null;
+        private static final Font TXT_FONT = new Font("Arial", Font.BOLD, 25);
+        private static final Color TXT_COLOR = Color.WHITE;
+
+        private static void drawString(Graphics2D g, Point pos, String str) {
+            g.setColor(TXT_COLOR);
+            g.setFont(TXT_FONT);
+            g.drawString(str, pos.x, pos.y);
+        }
+
+        private static void drawImage(Graphics2D g, Point pos, Image img) {
+            g.drawImage(img, pos.x, pos.y, IMG_OBSERVER);
+        }
+
+        private static void drawImageMap(Graphics2D g, Map<Point, Image> m) {
+            for (Map.Entry<Point, Image> e : m.entrySet())
+                drawImage(g, e.getKey(), e.getValue());
+        }
+
+        private static <T> void drawStringMap(Graphics2D g, Map<Point, T> m) {
+            for (Map.Entry<Point, T> e : m.entrySet())
+                drawString(g, e.getKey(), e.getValue().toString());
+        }
+
+    }
+
+    private static Comparator<GameState.Player> buildPlayerComparator(PlayerID blackSheep) {
+        Comparator<GameState.Player> coordinateComparator =
+                (p1, p2) -> p1.position().compareTo(p2.position());
+
+        Comparator<GameState.Player> idComparator =
+                (p1, p2) -> p1.id() == blackSheep ? -1 : 0;
+
+        return coordinateComparator.thenComparing(idComparator);
+    }
+
+    private GameState gameState;
+    private PlayerID playerID;
+
+    /**
+     * Display the given GameState from the point of view of the given playerID.
+     *
+     * @param gs  GameState to be displayed
+     * @param pid playerID related to the view
+     */
+    public void setGameState(GameState gs, PlayerID pid) {
+        this.gameState = gs;
+        this.playerID = pid;
+        this.repaint();
+    }
+
+    /**
+     * Returns the value of the preferredSize property.
+     *
+     * @return the value of the preferredSize property
+     */
+    @Override
+    public Dimension getPreferredSize() {
+        return Grid.FRAME_DIMENSION;
+    }
+
+    /**
+     * Draw the component.
+     *
+     * @param g0 the Graphics context
+     */
+    @Override
+    protected void paintComponent(Graphics g0) {
+        Graphics2D g = (Graphics2D) g0;
+
+        if (Objects.isNull(this.gameState))
+            return;
+
+        Painter.drawImageMap(g, Lists.linearMap(Grid.CELL_POSITIONS, this.gameState.board()));
+        Painter.drawImageMap(g, Lists.linearMap(Grid.CELL_POSITIONS, this.gameState.explosions()));
+        Painter.drawImageMap(g, Lists.linearMap(Grid.SCORE_BG_POSITIONS, this.gameState.scores()));
+        Painter.drawImageMap(g, Lists.linearMap(Grid.TIME_LINE_POSITIONS, this.gameState.ticks()));
+        Painter.drawStringMap(g, Lists.traverseMaps(Lists.invertMap(Grid.SCORE_TXT_POSITIONS), this.gameState.playerScores()));
+        drawPlayers(g, Lists.sorted(this.gameState.players(), buildPlayerComparator(this.playerID)));
+    }
+
+    /**
+     * Draw the players on the graphic context.
+     *
+     * @param g       the graphic context
+     * @param players the list of players to be displayed
+     */
+    private void drawPlayers(Graphics2D g, List<GameState.Player> players) {
+        for (GameState.Player p : players)
+            Painter.drawImage(g, Grid.positionForPlayer(p), p.image());
+    }
+
+}