public MapPanel(ClientGameBoard gl) {
super();
_dismiss = false;
gameLogic = gl;
gameLogic._mapPanel = this;
_hexes = new ArrayList<Hex>();
vertexContents = new Hashtable<CoordPair, Pair>();
roadContents = new Hashtable<Pair, Integer>();
portContents = new Hashtable<Pair, BoardObject.type>();
diceImage = new BufferedImage(582, 98, BufferedImage.TYPE_INT_ARGB);
Graphics2D g = diceImage.createGraphics();
g.drawImage(BoardObject.images.get(BoardObject.type.DICE), null, null);
g.dispose();
rings = gameLogic.getNumRings();
hexleft =
100
- (int)
(radius
+ (Math.floor(rings / 2) * radius + Math.floor((rings - 1) / 2) * radius * 2));
if (rings % 2 == 0) {
hexleft -= radius / 2;
}
hextop = 300 - (int) (radius * 0.866 + (rings - 1) * 2 * (radius * 0.866));
double border = 0.4;
HashMap<Pair, Pair> hexData = gameLogic.getHexInfo(); // call the gamelogic
Pair currCoord = gameLogic.getStartPoint();
Pair topCoord = currCoord;
int ring = 0;
int currentDir = 5;
int current = 0;
int[][] directions = {{1, 1}, {0, 2}, {-1, 1}, {-1, -1}, {0, -2}, {1, -1}};
int[][] HexCoordDirections = {{2, 1}, {0, 2}, {-2, 1}, {-2, -1}, {0, -2}, {2, -1}};
Hex top =
new Hex(
100,
300,
radius,
(BoardObject.type) (hexData.get(currCoord).getA()),
(Integer) (hexData.get(currCoord).getB()));
Hex curr = top;
_hexes.add(top);
while (true) {
if (current == ring) {
currentDir++;
current = 0;
}
if (currentDir > 5) {
currentDir = 0;
current = 0;
ring++;
if (ring < rings) {
topCoord = new Pair(currCoord.getA(), (Double) (currCoord.getB()) - 2);
currCoord = topCoord;
top =
new Hex(
curr.getX(),
(curr.getY() - 2 * (Math.cos(Math.PI / 6) * (curr.getRadius() + border))),
curr.getRadius(),
(BoardObject.type) (hexData.get(currCoord).getA()),
(Integer) (hexData.get(currCoord).getB()));
curr = top;
} else {
break;
}
}
currCoord.setA((Object) ((Double) (currCoord.getA()) + HexCoordDirections[currentDir][0]));
currCoord.setB((Object) ((Double) (currCoord.getB()) + HexCoordDirections[currentDir][1]));
curr =
new Hex(
(curr.getX() + directions[currentDir][0] * (curr.getRadius() + border) * 3 / 2),
(curr.getY()
+ directions[currentDir][1]
* (Math.cos(Math.PI / 6) * (curr.getRadius() + border))),
curr.getRadius(),
(BoardObject.type) (hexData.get(currCoord).getA()),
(Integer) (hexData.get(currCoord).getB()));
_hexes.add(curr);
current++;
}
addMouseListener(this);
addMouseMotionListener(this);
}
/**
* This method finds the ordering of all the line segments that are removable from the current
* board state in the current turn for each player.
*
* @param pieceMap
* @param currentPlayerColor
* @return An example output could be: {set: ["white", "segment from a to b"] ["white", "segment
* from b to c"] ["black", "segment from x to y"] ["black", "segment from z to a"; after that
* "white", "segment from a to b"] ["black", "segment from d to f"] }
*/
private Set<List<Pair<PieceColor, Line.Segment>>> getRemovableLineOrderingsSetFromGipfBoard(
Map<Position, Piece> pieceMap, PieceColor currentPlayerColor) {
Set<List<Pair<PieceColor, Line.Segment>>> removableLineSetOrderingsFromGipfboard =
new HashSet<>();
PieceColor opponentColor = currentPlayerColor == WHITE ? BLACK : WHITE;
Set<Line.Segment> removableLineSegmentsCurrentPlayer =
getRemovableLineSegments(pieceMap, currentPlayerColor);
// This loop checks for all line segments that can be removed by the current player.
for (Line.Segment lineSegment : removableLineSegmentsCurrentPlayer) {
// Create a copy of the piecemap where the removed segment is removed
HashMap<Position, Piece> segmentRemovedPieceMap = new HashMap<>(pieceMap);
segmentRemovedPieceMap
.keySet()
.removeAll(lineSegment.getOccupiedPositions(segmentRemovedPieceMap));
List<Pair<PieceColor, Line.Segment>> removableLineSegmentOrdering =
Collections.singletonList(new Pair<>(currentPlayerColor, lineSegment));
// - I have to use removableLineSegmentList because the removableLineSegmentOrdering is
// already in use.
// - If the current player can remove at least 1 more segment, the board state that results
// will be checked
// after that for more subsequent segments that can be removed
Set<List<Pair<PieceColor, Line.Segment>>> removableLineSetOrderingsCurrentPlayer =
getRemovableLineOrderingsSetFromGipfBoard(segmentRemovedPieceMap, currentPlayerColor);
if (removableLineSetOrderingsCurrentPlayer.size() > 0) {
for (List<Pair<PieceColor, Line.Segment>> removableLineSegmentList :
removableLineSetOrderingsCurrentPlayer) {
List<Pair<PieceColor, Line.Segment>> ordering =
new ArrayList<>(removableLineSegmentOrdering);
ordering.addAll(removableLineSegmentList);
removableLineSetOrderingsFromGipfboard.add(ordering);
}
} else {
removableLineSetOrderingsFromGipfboard.add(removableLineSegmentOrdering);
}
// Now check for the line segments removable by the opponent
// Because if this code is ran, the current player can remove line segments. If this is the
// case, the current player
// must remove line segments before the opponent gets its turn.
for (Line.Segment lineSegmenRemovableByOpponent :
getRemovableLineSegments(segmentRemovedPieceMap, opponentColor)) {
// See for the comments in the similar lines above
HashMap<Position, Piece> opponentSegmentRemovedPieceMap =
new HashMap<>(segmentRemovedPieceMap);
opponentSegmentRemovedPieceMap
.keySet()
.removeAll(
lineSegmenRemovableByOpponent.getOccupiedPositions(opponentSegmentRemovedPieceMap));
List<Pair<PieceColor, Line.Segment>> opponentRemovableLineSegmentOrdering =
Collections.singletonList(new Pair<>(opponentColor, lineSegmenRemovableByOpponent));
Set<List<Pair<PieceColor, Line.Segment>>> removableLineSetOrderingsOpponent =
getRemovableLineOrderingsSetFromGipfBoard(
opponentSegmentRemovedPieceMap, opponentColor);
if (removableLineSetOrderingsOpponent.size() > 0) {
for (List<Pair<PieceColor, Line.Segment>> removableLineSegmentOpponentList :
removableLineSetOrderingsOpponent) {
List<Pair<PieceColor, Line.Segment>> ordering =
new ArrayList<>(opponentRemovableLineSegmentOrdering);
ordering.addAll(removableLineSegmentOpponentList);
removableLineSetOrderingsFromGipfboard.add(ordering);
}
} else {
removableLineSetOrderingsFromGipfboard.add(opponentRemovableLineSegmentOrdering);
}
}
}
if (removableLineSegmentsCurrentPlayer.size() == 0) {
// The current player can't remove any line segments, so the opponent can try to remove line
// segments
for (Line.Segment lineSegment : getRemovableLineSegments(pieceMap, opponentColor)) {
// See for the comments the similar lines above
HashMap<Position, Piece> segmentRemovedPieceMap = new HashMap<>(pieceMap);
segmentRemovedPieceMap
.keySet()
.removeAll(lineSegment.getOccupiedPositions(segmentRemovedPieceMap));
List<Pair<PieceColor, Line.Segment>> removableLineSegmentOrdering =
Collections.singletonList(new Pair<>(opponentColor, lineSegment));
Set<List<Pair<PieceColor, Line.Segment>>> removableLineSetOrderingsOpponent =
getRemovableLineOrderingsSetFromGipfBoard(segmentRemovedPieceMap, opponentColor);
if (removableLineSetOrderingsOpponent.size() > 0) {
for (List<Pair<PieceColor, Line.Segment>> removableLineSegmentList :
removableLineSetOrderingsOpponent) {
List<Pair<PieceColor, Line.Segment>> ordering =
new ArrayList<>(removableLineSegmentOrdering);
ordering.addAll(removableLineSegmentList);
removableLineSetOrderingsFromGipfboard.add(ordering);
}
} else {
removableLineSetOrderingsFromGipfboard.add(removableLineSegmentOrdering);
}
}
}
return removableLineSetOrderingsFromGipfboard;
}
