@Override
public void saveTileToSnapshot(Tile tile, Document doc, Element tileNode) {
if (tile.getBridge() != null) {
Location realLoc = tile.getBridge().getRawLocation();
tileNode.setAttribute("bridge", realLoc.toString());
}
}
/** merge this to another tile - method argument is tile placed before */
protected void merge(Tile tile, Location loc) {
if (logger.isDebugEnabled()) logger.debug("Merging " + id + " with " + tile.getId());
Location oppositeLoc = loc.rev();
MultiTileFeature oppositePiece = (MultiTileFeature) tile.getFeaturePartOf(oppositeLoc);
if (oppositePiece != null) {
if (isAbbeyTile()) {
oppositePiece.setAbbeyEdge(oppositeLoc);
} else {
MultiTileFeature thisPiece = (MultiTileFeature) getFeaturePartOf(loc);
oppositePiece.setEdge(oppositeLoc, thisPiece);
thisPiece.setEdge(loc, oppositePiece);
}
}
for (int i = 0; i < 2; i++) {
Location halfSide = i == 0 ? loc.getLeftFarm() : loc.getRightFarm();
Location oppositeHalfSide = halfSide.rev();
oppositePiece = (MultiTileFeature) tile.getFeaturePartOf(oppositeHalfSide);
if (oppositePiece != null) {
if (isAbbeyTile()) {
oppositePiece.setAbbeyEdge(oppositeHalfSide);
} else {
MultiTileFeature thisPiece = (MultiTileFeature) getFeaturePartOf(halfSide);
oppositePiece.setEdge(oppositeHalfSide, thisPiece);
thisPiece.setEdge(halfSide, oppositePiece);
}
}
}
}
public void tilePlaced(Tile tile, TileLayer tileLayer) {
Position p = tile.getPosition();
removeLayer(AbstractTilePlacementLayer.class);
removeLayer(PlacementHistory.class);
if (p.x == left) --left;
if (p.x == right) ++right;
if (p.y == top) --top;
if (p.y == bottom) ++bottom;
tileLayer.tilePlaced(tile);
if (client.getSettings().isShowHistory()) {
showRecentHistory();
}
boolean initialPlacement =
client.getActivePlayer() == null; // if active player is null we are placing initial tiles
if ((!initialPlacement && !client.isClientActive())
|| (initialPlacement && tile.equals(client.getGame().getCurrentTile()))) {
getAnimationService()
.registerAnimation(tile.getPosition(), new RecentPlacement(tile.getPosition()));
}
repaint();
}
private void createTileElements(Game game) {
tileElemens = new HashMap<Position, Element>();
Element parent = doc.createElement("tiles");
if (game.getCurrentTile() != null) {
parent.setAttribute("next", game.getCurrentTile().getId());
}
root.appendChild(parent);
//for()
for(String group : game.getTilePack().getGroups()) {
Element el = doc.createElement("group");
el.setAttribute("name", group);
el.setAttribute("active", "" + game.getTilePack().isGroupActive(group));
parent.appendChild(el);
}
for(Tile tile : game.getBoard().getAllTiles()) {
Element el = doc.createElement("tile");
el.setAttribute("name", tile.getId());
el.setAttribute("rotation", tile.getRotation().name());
XmlUtils.injectPosition(el, tile.getPosition());
parent.appendChild(el);
tileElemens.put(tile.getPosition(), el);
}
for(String tileId : game.getBoard().getDiscardedTiles()) {
Element el = doc.createElement("discard");
el.setAttribute("name", tileId);
parent.appendChild(el);
}
}
private boolean makeDebugDraw() {
if (debugTiles != null && debugTiles.size() > 0) { // for debug purposes only
String tileId = debugTiles.remove(0);
if (tileId.equals(DEBUG_END_OF_PACK)) {
next(GameOverPhase.class);
return true;
}
TilePack tilePack = getTilePack();
Tile tile = tilePack.drawTile(tileId);
if (tile == null) {
logger.warn("Invalid debug draw id: " + tileId);
} else {
boolean riverActive =
tilePack.getGroupState("river-start") == TileGroupState.ACTIVE
|| tilePack.getGroupState("river") == TileGroupState.ACTIVE;
if (game.hasCapability(RiverCapability.class) && tile.getRiver() == null && riverActive) {
game.getCapability(RiverCapability.class).activateNonRiverTiles();
tilePack.setGroupState("river-start", TileGroupState.RETIRED);
game.setCurrentTile(tile); // recovery from lake placement
}
nextTile(tile);
return true;
}
}
return false;
}
private BridgeAction prepareTileBridgeAction(Tile tile, BridgeAction action, Location bridgeLoc) {
if (isBridgePlacementAllowed(tile, tile.getPosition(), bridgeLoc)) {
if (action == null) action = new BridgeAction();
action.add(new FeaturePointer(tile.getPosition(), bridgeLoc));
}
return action;
}
public void deployBridge(Position pos, Location loc) {
Tile tile = getBoard().get(pos);
if (!tile.isBridgeAllowed(loc)) {
throw new IllegalArgumentException("Cannot deploy " + loc + " bridge on " + pos);
}
bridgeUsed = true;
tile.placeBridge(loc);
game.post(new BridgeDeployedEvent(game.getActivePlayer(), pos, loc));
}
private void scoreCompletedNearAbbey(Position pos) {
for (Entry<Location, Tile> e : getBoard().getAdjacentTilesMap(pos).entrySet()) {
Tile tile = e.getValue();
Feature feature = tile.getFeaturePartOf(e.getKey().rev());
if (feature instanceof Completable) {
scoreCompleted((Completable) feature, false);
}
}
}
public void update() {
history.clear();
int i = placedTilesView.size();
int limit = getGame().getAllPlayers().length;
for (Tile t : placedTilesView) {
if (i <= limit) {
history.put(t.getPosition(), "" + i);
}
i--;
}
}
private boolean isBridgePlacementAllowed(Tile tile, Position p, Location bridgeLoc) {
if (!tile.isBridgeAllowed(bridgeLoc)) return false;
for (Entry<Location, Tile> e : getBoard().getAdjacentTilesMap(p).entrySet()) {
Location rel = e.getKey();
if (rel.intersect(bridgeLoc) != null) {
Tile adjacent = e.getValue();
char adjacentSide = adjacent.getEdge(rel.rev());
if (adjacentSide != 'R') return false;
}
}
return true;
}
private BridgeAction prepareBridgeAction() {
BridgeAction action = null;
Tile tile = game.getCurrentTile();
action = prepareTileBridgeAction(tile, action, Location.NS);
action = prepareTileBridgeAction(tile, action, Location.WE);
for (Entry<Location, Tile> entry :
getBoard().getAdjacentTilesMap(tile.getPosition()).entrySet()) {
Tile adjacent = entry.getValue();
Location rel = entry.getKey();
action = prepareTileBridgeAction(adjacent, action, getBridgeLocationForAdjacent(rel));
}
return action;
}
@Override
public boolean visit(Feature feature) {
cloister = (Cloister) feature;
Position pos = cloister.getTile().getPosition();
List<Tile> neigbouringTiles = game.getBoard().getAdjacentAndDiagonalTiles(pos);
neigbouringTilesCount = neigbouringTiles.size();
if (lbCap != null) {
collectLittleBuildings(cloister.getTile().getPosition());
for (Tile tile : neigbouringTiles) {
collectLittleBuildings(tile.getPosition());
}
}
return true;
}
@Override
public boolean visit(Feature feature) {
City city = (City) feature;
if (city.isBesieged()) { // cloister must border Cathar tile
isBesieged = true;
Position p = city.getTile().getPosition();
for (Tile tile : getBoard().getAdjacentAndDiagonalTiles(p)) {
if (tile.hasCloister()) {
cloisterNearby = true;
return false; // do not continue, besieged cloister exists
}
}
}
return true;
}
@Override
public void loadTileFromSnapshot(Tile tile, Element tileNode) {
if (tileNode.hasAttribute("bridge")) {
Location loc = Location.valueOf(tileNode.getAttribute("bridge"));
tile.placeBridge(loc);
}
}
private void scoreCompletedOnTile(Tile tile) {
for (Feature feature : tile.getFeatures()) {
if (feature instanceof Completable) {
scoreCompleted((Completable) feature, true);
}
}
}
static TileSymmetry forTile(Tile tile) {
if (tile.getFlier() != null) {
return TileSymmetry.NONE;
}
if (tile.getWindRose() != null) {
return TileSymmetry.NONE;
}
TileSymmetry symmetry = countBaseSymmetry(tile);
Location river = tile.getRiver();
if (river != null) {
if (river == Location.WE || river == Location.NS) {
if (symmetry == TileSymmetry.S4) symmetry = TileSymmetry.S2;
} else {
symmetry = TileSymmetry.NONE;
}
}
return symmetry;
}
public BridgeAction prepareMandatoryBridgeAction() {
Tile tile = game.getCurrentTile();
for (Entry<Location, Tile> entry :
getBoard().getAdjacentTilesMap(tile.getPosition()).entrySet()) {
Tile adjacent = entry.getValue();
Location rel = entry.getKey();
char adjacentSide = adjacent.getEdge(rel.rev());
char tileSide = tile.getEdge(rel);
if (tileSide != adjacentSide) {
Location bridgeLoc = getBridgeLocationForAdjacent(rel);
BridgeAction action = prepareTileBridgeAction(tile, null, bridgeLoc);
if (action != null) return action;
return prepareTileBridgeAction(adjacent, null, bridgeLoc);
}
}
throw new IllegalStateException();
}
private Castle replaceCityWithCastle(Tile tile, Location loc) {
ListIterator<Feature> iter = tile.getFeatures().listIterator();
City city = null;
while (iter.hasNext()) {
Feature feature = iter.next();
if (feature.getLocation() == loc) {
city = (City) feature;
break;
}
}
List<Meeple> meeples =
new ArrayList<>(city.getMeeples()); // collection copy required!!! undeploy modify it
for (Meeple m : meeples) {
m.undeploy();
}
Castle castle = new Castle();
castle.setTile(tile);
castle.setId(game.idSequnceNextVal());
castle.setLocation(loc.rotateCCW(tile.getRotation()));
iter.set(castle);
for (Feature f : tile.getFeatures()) { // replace also city references
if (f instanceof Farm) {
Farm farm = (Farm) f;
Feature[] adjoining = farm.getAdjoiningCities();
if (adjoining != null) {
for (int i = 0; i < adjoining.length; i++) {
if (adjoining[i] == city) {
adjoining[i] = castle;
break;
}
}
}
}
}
FeaturePointer fp = new FeaturePointer(tile.getPosition(), loc);
for (Meeple m : meeples) {
if (m.getPlayer() == game.getActivePlayer() && m.isDeploymentAllowed(castle).result) {
m.deploy(fp);
}
}
return castle;
}
private static TileSymmetry countBaseSymmetry(Tile tile) {
for (Feature piece : tile.getFeatures()) {
if (piece instanceof Road || piece instanceof City) {
Feature opposite = tile.getFeature(piece.getLocation().rev());
if (opposite == null || !opposite.getClass().equals(piece.getClass())) {
return TileSymmetry.NONE;
}
}
}
for (Feature piece : tile.getFeatures()) {
if (piece instanceof Road || piece instanceof City) {
Feature opposite = tile.getFeature(piece.getLocation().rotateCW(Rotation.R90));
if (opposite == null || !opposite.getClass().equals(piece.getClass())) {
return TileSymmetry.S2;
}
}
}
return TileSymmetry.S4;
}
@Override
public void enter() {
Position pos = getTile().getPosition();
// TODO separate event here ??? and move this code to abbey and mayor game
if (barnCap != null) {
Map<City, CityScoreContext> cityCache = new HashMap<>();
for (Feature feature : getTile().getFeatures()) {
if (feature instanceof Farm) {
scoreFollowersOnBarnFarm((Farm) feature, cityCache);
}
}
}
scoreCompletedOnTile(getTile());
if (getTile().isAbbeyTile()) {
scoreCompletedNearAbbey(pos);
}
if (tunnelCap != null) {
Road r = tunnelCap.getPlacedTunnel();
if (r != null) {
scoreCompleted(r, true);
}
}
for (Tile neighbour : getBoard().getAdjacentAndDiagonalTiles(pos)) {
Cloister cloister = neighbour.getCloister();
if (cloister != null) {
scoreCompleted(cloister, false);
}
}
if (castleCap != null) {
for (Entry<Castle, Integer> entry : castleCap.getCastleScore().entrySet()) {
scoreCastle(entry.getKey(), entry.getValue());
}
}
alredyScored.clear();
next();
}
protected void deploy(Tile tile, Location loc, Feature feature) {
DeploymentCheckResult check = isDeploymentAllowed(feature);
if (!check.result) {
throw new IllegalArgumentException(check.error);
}
feature.addMeeple(this);
setPosition(tile.getPosition());
setLocation(loc);
setFeature(feature);
game.post(new MeepleEvent(MeepleEvent.DEPLOY, this));
}
public void tileEvent(TileEvent ev) {
Tile tile = ev.getTile();
if (ev.getType() == TileEvent.PLACEMENT) {
ResourceManager resourceManager = getClient().getResourceManager();
Set<Location> farmLocations = new HashSet<>();
for (Feature f : tile.getFeatures()) {
if (f instanceof Farm) {
farmLocations.add(f.getLocation());
}
}
if (farmLocations.isEmpty()) return;
Map<Location, Area> tAreas = resourceManager.getFeatureAreas(tile, FULL_SIZE, farmLocations);
areas.put(tile, tAreas);
refreshHints();
}
if (ev.getType() == TileEvent.REMOVE) {
areas.remove(tile);
refreshHints();
}
}
private boolean isTilePlacementWithOneAdjacentBridgeAllowed(Tile tile, Position p) {
boolean bridgeUsed = false;
for (Entry<Location, Tile> e : getBoard().getAdjacentTilesMap(p).entrySet()) {
Tile adjacent = e.getValue();
Location rel = e.getKey();
char tileSide = tile.getEdge(rel);
char adjacentSide = adjacent.getEdge(rel.rev());
if (tileSide != adjacentSide) {
if (bridgeUsed) return false;
if (tileSide != 'R') return false;
Location bridgeLoc = getBridgeLocationForAdjacent(rel);
if (!isBridgePlacementAllowed(adjacent, adjacent.getPosition(), bridgeLoc)) return false;
bridgeUsed = true;
}
}
return bridgeUsed; // ok if exactly one bridge is used
}
@Override
public void paint(Graphics2D g2) {
// TODO nice shadow
if (!getClient().getGridPanel().containsDecoration(AbstractTilePlacementLayer.class)) {
g2.setColor(Color.WHITE);
int squareSize = getSquareSize(), thickness = squareSize / 11;
for (Tile tile : placedTiles) {
Position p = tile.getPosition();
int x = getOffsetX(p), y = getOffsetY(p);
g2.fillRect(
x - thickness, y - thickness, squareSize + 2 * thickness, squareSize + 2 * thickness);
}
}
for (Tile tile : placedTiles) {
Image img = getClient().getResourceManager().getTileImage(tile);
g2.drawImage(
img,
getAffineTransform(img.getWidth(null), tile.getPosition(), tile.getRotation()),
null);
}
}
protected void unmerge(Tile tile, Location loc) {
Location oppositeLoc = loc.rev();
MultiTileFeature oppositePiece = (MultiTileFeature) tile.getFeaturePartOf(oppositeLoc);
if (oppositePiece != null) {
oppositePiece.setEdge(oppositeLoc, null);
if (!isAbbeyTile()) {
MultiTileFeature thisPiece = (MultiTileFeature) getFeaturePartOf(loc);
thisPiece.setEdge(loc, null);
}
}
for (int i = 0; i < 2; i++) {
Location halfSide = i == 0 ? loc.getLeftFarm() : loc.getRightFarm();
Location oppositeHalfSide = halfSide.rev();
oppositePiece = (MultiTileFeature) tile.getFeaturePartOf(oppositeHalfSide);
if (oppositePiece != null) {
oppositePiece.setEdge(oppositeHalfSide, null);
if (!isAbbeyTile()) {
MultiTileFeature thisPiece = (MultiTileFeature) getFeaturePartOf(halfSide);
thisPiece.setEdge(halfSide, null);
}
}
}
}
protected Game getGame() {
return tile.getGame();
}
public Feature getDeploymentFeature(Tile tile, Location loc) {
return tile.getFeature(loc);
}
protected boolean check(Tile tile, Location rel, Board board) {
return getEdge(rel) == tile.getEdge(rel.rev());
}
public Location getLocation() {
return location.rotateCW(tile.getRotation());
}
