@Override
public void saveTileToSnapshot(Tile tile, Document doc, Element tileNode) {
if (tile.getBridge() != null) {
Location realLoc = tile.getBridge().getRawLocation();
tileNode.setAttribute("bridge", realLoc.toString());
}
}
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;
}
@Override
public void loadFromSnapshot(Document doc, Element node) {
NodeList nl = node.getElementsByTagName("player");
for (int i = 0; i < nl.getLength(); i++) {
Element playerEl = (Element) nl.item(i);
Player player = game.getPlayer(Integer.parseInt(playerEl.getAttribute("index")));
castles.put(player, Integer.parseInt(playerEl.getAttribute("castles")));
}
nl = node.getElementsByTagName("castle");
for (int i = 0; i < nl.getLength(); i++) {
Element castleEl = (Element) nl.item(i);
Position pos = XMLUtils.extractPosition(castleEl);
Location loc = Location.valueOf(castleEl.getAttribute("location"));
Castle castle = convertCityToCastle(pos, loc, true);
boolean isNew = XMLUtils.attributeBoolValue(castleEl, "new");
boolean isCompleted = XMLUtils.attributeBoolValue(castleEl, "completed");
if (isNew) {
newCastles.add(castle);
} else if (isCompleted) {
emptyCastles.add(castle);
} else {
scoreableCastleVicinity.put(castle, castle.getVicinity());
}
}
}
@Override
public void loadTileFromSnapshot(Tile tile, Element tileNode) {
if (tileNode.hasAttribute("bridge")) {
Location loc = Location.valueOf(tileNode.getAttribute("bridge"));
tile.placeBridge(loc);
}
}
@Override
public String toString() {
if (location == Location.PRISON) {
return getClass().getSimpleName() + " " + location.toString();
} else {
return super.toString();
}
}
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 convertCityToCastle(Position pos, Location loc, boolean loadFromSnaphot) {
Castle castle1 = replaceCityWithCastle(getBoard().get(pos), loc);
Castle castle2 = replaceCityWithCastle(getBoard().get(pos.add(loc)), loc.rev());
castle1.getEdges()[0] = castle2;
castle2.getEdges()[0] = castle1;
if (!loadFromSnaphot) {
newCastles.add(castle1.getMaster());
}
game.post(new CastleDeployedEvent(game.getActivePlayer(), castle1, castle2));
return castle1.getMaster();
}
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
}
@SuppressWarnings("unchecked")
public List<Meeple> extractTileMeeples(Element tileEl, Game game, Position pos) throws SnapshotCorruptedException {
NodeList nl = tileEl.getElementsByTagName("meeple");
List<Meeple> result = Lists.newArrayList();
for(int i = 0; i < nl.getLength(); i++) {
Element el = (Element) nl.item(i);
Location loc = Location.valueOf(el.getAttribute("loc"));
Class<? extends Meeple> mt = (Class<? extends Meeple>) XmlUtils.classForName(el.getAttribute("type"));
int playerIndex = Integer.parseInt(el.getAttribute("player"));
Meeple meeple = game.getPlayer(playerIndex).getUndeployedMeeple(mt);
meeple.setLocation(loc);
meeple.setPosition(pos);
//don't set feature here. Feature must be set after meeple deployment to correct replace ref during merge
result.add(meeple);
}
return result;
}
@Override
public void loadFromSnapshot(Document doc, Element node) {
NodeList nl = node.getElementsByTagName("tunnel");
for (int i = 0; i < nl.getLength(); i++) {
Element el = (Element) nl.item(i);
Position pos = XmlUtils.extractPosition(el);
Location loc = Location.valueOf(el.getAttribute("location"));
Road road = (Road) getBoard().get(pos).getFeature(loc);
if (!road.isTunnelEnd()) {
logger.error("Tunnel end does not exist.");
continue;
}
Player player = game.getPlayer(Integer.parseInt(el.getAttribute("player")));
boolean isB = "yes".equals(el.getAttribute("b"));
road.setTunnelEnd(getTunnelId(player, isB));
game.post(new TunnelPiecePlacedEvent(player, pos, loc, isB));
}
}
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;
}
public Location getLocation() {
return location.rotateCW(tile.getRotation());
}