@Override
public void showGame(
Game game, Set<Location<Integer>> blockedLocations, Map<Room, Weapon> weaponLocations) {
Board board = game.board;
char[][] buffer = new char[2 * (board.width + 1)][2 * (board.height + 1)];
for (char[] line : buffer) {
Arrays.fill(line, ' ');
}
for (int x = 0; x < board.width; x++) {
for (int y = 0; y < board.height; y++) {
// The actual tile is at buffer[2x + 1][2y + 1]
// Walls: above is [2x + 1][2y], left is [2x][2y + 1]
if (board.hasWallBetween(
new Location<>(x, y), new Location<>(x, y - 1))) { // if there's a wall above the tile.
buffer[2 * x + 1][2 * y] = '-';
}
if (board.hasWallBetween(
new Location<>(x, y),
new Location<>(x - 1, y))) { // if there's a wall to the left of the tile.
buffer[2 * x][2 * y + 1] = '|';
}
}
}
for (int x = 0; x < board.width; x++) {
buffer[2 * x + 1][2 * board.height] = '-';
}
for (int y = 0; y < board.height; y++) {
buffer[2 * board.width][2 * y + 1] = '|';
}
for (Room room : Room.values()) {
Location<Float> centre = board.centreLocationForRoom(room);
String name = room.shortName();
int startX = 2 * centre.x.intValue() + 1 - name.length() / 2;
int y = 2 * centre.y.intValue() + 1;
for (int i = 0; i < +name.length(); i++) {
buffer[startX + i][y] = name.charAt(i);
}
}
for (Player player : game.allPlayers) {
CluedoCharacter character = player.character;
Location<Integer> location = player.location();
buffer[2 * location.x + 1][2 * location.y + 1] = this.asciiIconForCharacter(character);
}
for (int y = 0; y < 2 * (board.height + 1); y++) {
for (int x = 0; x < 2 * (board.width + 1); x++) {
this.out.print(buffer[x][y]);
}
this.out.print('\n');
}
}
@Override
public Optional<Suggestion> requestPlayerAccusation(Player player) {
char userWantsToMakeAccusation = '\0';
while (userWantsToMakeAccusation != 'Y' && userWantsToMakeAccusation != 'N') {
this.out.println("Do you want to make an accusation (Y/N)?");
userWantsToMakeAccusation = this.scanner.next().charAt(0);
}
if (userWantsToMakeAccusation == 'Y') {
this.out.println("Choose your suspect:");
Stream<String> suspects =
Arrays.stream(CluedoCharacter.values())
.filter(e -> !player.cards.contains(e))
.map(CluedoCharacter::toString);
CluedoCharacter suspect = CluedoCharacter.values()[this.selectOptionFromList(suspects)];
this.out.println("Choose your weapon:");
Stream<String> weapons =
Arrays.stream(Weapon.values())
.filter(e -> !player.cards.contains(e))
.map(Weapon::toString);
Weapon weapon = Weapon.values()[this.selectOptionFromList(weapons)];
this.out.println("Choose your room:");
Stream<String> rooms =
Arrays.stream(Room.values()).filter(e -> !player.cards.contains(e)).map(Room::toString);
Room room = Room.values()[this.selectOptionFromList(rooms)];
return Optional.of(new Suggestion(suspect, weapon, room));
} else {
return Optional.empty();
}
}
@SuppressWarnings("SuspiciousNameCombination")
// so we don't get warned about using 'WallWidth' in conjunction with height
@Override
protected void paintComponent(Graphics g) {
double width = this.getWidth();
double height = this.getHeight();
Graphics2D graphics2D = (Graphics2D) g;
graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
graphics2D.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
Board board = _gameState.board;
double ratio = (double) board.width / board.height;
width = Math.min(width, (height * ratio));
height = Math.min(height, (width / ratio));
double startX = this.getWidth() / 2 - width / 2;
double startY = this.getHeight() / 2 - height / 2;
g.setColor(Color.yellow);
g.fillRect(round(startX), round(startY), round(width), round(height));
// Draw the grid.
g.setColor(Color.black);
double step = width / board.width;
for (double x = startX + step; x < startX + width; x += step) {
g.drawLine(round(x), round(startY), round(x), round(startY + height));
}
for (double y = startY + step; y < startY + height; y += step) {
g.drawLine(round(startX), round(y), round(startX + width), round(y));
}
// Draw the room tiles.
int x = 0;
for (Board.Tile[] column : board.tiles) {
int y = 0;
for (Board.Tile tile : column) {
boolean hasRoom = tile.room.isPresent();
boolean isUnaccessibleSpace = tile.connectedLocations.isEmpty();
if (hasRoom || isUnaccessibleSpace) {
g.setColor(hasRoom ? Color.lightGray : Color.cyan);
g.fillRect(
round(x * step + startX - 0.5),
round(y * step + startY - 0.5),
round(step + 1),
round(step + 1));
if (tile.isPassageway(board)) {
g.setColor(Color.darkGray);
for (int i = 0; i < step; i += 2) {
g.fillRect(
round(x * step + startX - 0.5),
round(y * step + startY - 0.5 + i),
round(step + 1),
1);
}
}
}
y++;
}
x++;
}
// Draw the walls.
// Loop again to draw over what we already have.
g.setColor(Color.black);
x = 0;
for (Board.Tile[] column : board.tiles) {
int y = 0;
for (Board.Tile tile : column) {
Location<Integer> location = new Location<>(x, y);
if (board.hasWallBetween(location, new Location<>(x + 1, y))) {
g.fillRect(
round(startX + step * (x + 1) - WallWidth / 2),
round(startY + step * y - 0.5),
WallWidth,
round(step + 1));
}
if (board.hasWallBetween(location, new Location<>(x, y + 1))) {
g.fillRect(
round(startX + step * x - 0.5),
round(startY + step * (y + 1) - WallWidth / 2),
round(step + 1),
WallWidth);
}
y++;
}
x++;
}
// Draw the outer walls.
g.fillRect(round(startX), round(startY), WallWidth, round(height));
g.fillRect(round(startX), round(startY), round(width), WallWidth);
g.fillRect(round(startX + width - WallWidth), round(startY), WallWidth, round(height));
g.fillRect(round(startX), round(startY + height - WallWidth), round(width), WallWidth);
// Draw the names for the rooms.
g.setFont(GameFont);
g.setColor(Color.black);
FontMetrics fontMetrics = g.getFontMetrics(GameFont);
for (Room room : Room.values()) {
Location<Float> centre = board.centreLocationForRoom(room);
double centreX = (centre.x + 0.5f) * step + startX;
double centreY = (centre.y + 0.5f) * step + startY;
String name = room.shortName().toUpperCase();
Rectangle2D bounds = fontMetrics.getStringBounds(name, g);
g.drawString(
name, (int) (centreX - bounds.getCenterX()), (int) (centreY - bounds.getCenterY()));
double stringBottom = bounds.getCenterY() + centreY;
this.drawWeaponTokenForRoom(g, board, room, centreX, stringBottom, step);
}
// Draw the players.
boolean shouldPlayMoveSequence = this.shouldPlayMoveSequence();
for (Player player : _gameState.allPlayers) {
boolean drawTransparent = false;
Location<Float> playerLocation;
if (shouldPlayMoveSequence
&& // We haven't finished animating the move
player.character == _lastPlayerMoveCharacter) { // and the move is for this character
// then we need to lerp between two values in the move sequence for the character's
// position.
int lowIndex = (int) Math.floor(_moveSequencePosition);
int highIndex = (int) Math.ceil(_moveSequencePosition);
double lerpValue = _moveSequencePosition - lowIndex;
Location<Float> startLocation =
this.centreForTileAtLocation(
_lastPlayerMove.locations[lowIndex], board, startX, startY, step);
Location<Float> endLocation =
this.centreForTileAtLocation(
_lastPlayerMove.locations[highIndex], board, startX, startY, step);
if (Location.distance(startLocation, endLocation)
> step * 1.5) { // if the tiles aren't adjacent, allowing for some error.
drawTransparent = true;
}
playerLocation = Location.lerp(startLocation, endLocation, (float) lerpValue);
} else {
playerLocation =
this.centreForTileAtLocation(player.location(), board, startX, startY, step);
}
this.drawPlayer(g, playerLocation, player.character, step, drawTransparent);
}
// If we're supposed to draw the overlay for the paths, do so. Don't draw the overlay while
// we're animating.
if (_accessibleTilePaths != null && !shouldPlayMoveSequence) {
this.drawAccessibleTilesOverlay(g, _accessibleTilePaths, startX, startY, step);
}
}