private void display() {
final StringBuilder s = new StringBuilder();
int ql = 0;
int fl = 0;
int sl = 0;
int sql = 0;
for (int i = 0; i < stackASize; i++) {
final Turn t = stackA[i].userTurn;
ql += Metric.QUARTER.length(t);
fl += Metric.FACE.length(t);
sl += Metric.SLICE.length(t);
sql += Metric.SLICE_QUARTER.length(t);
s.append(t.toString()).append(' ');
}
if (stackBSize > 0) s.append(". ");
for (int i = 0; i < stackBSize; i++) { // print out Phase B part
final Turn t = stackB[i].userTurn;
ql += Metric.QUARTER.length(t);
fl += Metric.FACE.length(t);
sl += Metric.SLICE.length(t);
sql += Metric.SLICE_QUARTER.length(t);
s.append(t.toString()).append(' ');
}
reporter.sequenceFound(s.substring(0, max(s.length() - 1, 0)), ql, fl, sl, sql);
}
public void check_DialogueGame_invariant() {
Player playerProponent = DialogueGame.this.getProponent();
Set setTurn = playerProponent.getTurn();
// evaluate 'forAll(getNumber()/2=1)':
boolean bForAll = true;
final Iterator iter = setTurn.iterator();
while (bForAll && iter.hasNext()) {
final Turn iter1 = (Turn) iter.next();
int nGetNumber = iter1.getNumber();
float fDivide = nGetNumber / 2;
boolean bEquals = fDivide == 1;
bForAll = bEquals;
}
Player playerOpponent = DialogueGame.this.getOpponent();
Set setTurn0 = playerOpponent.getTurn();
// evaluate 'forAll(getNumber()/2=0)':
boolean bForAll0 = true;
final Iterator iter0 = setTurn0.iterator();
while (bForAll0 && iter0.hasNext()) {
final Turn iter1 = (Turn) iter0.next();
int nGetNumber0 = iter1.getNumber();
float fDivide0 = nGetNumber0 / 2;
boolean bEquals0 = fDivide0 == 0;
bForAll0 = bEquals0;
}
boolean bAnd = bForAll && bForAll0;
if (!bAnd) {
System.err.println("invariant 'invariant' failed for object " + DialogueGame.this);
}
}
public List<GameStateCard> getGameStateInPlay() {
List<GameStateCard> gameStateCards = new ArrayList<GameStateCard>();
for (Object card : cards) {
gameStateCards.add(Turn.cardToGameStateCard(((Card) card)));
}
return gameStateCards;
}
private void searchB(final int maxALength, final int maxBLength) {
stackB[0].length = 0;
stackB[0].turnIndex = 0;
int d = 0;
do {
while (stackB[d].length < maxBLength) {
final BNode node = stackB[d];
if (node.turnIndex >= node.turns.length) {
if (--d < 0) return;
} else {
final Turn userTurn = node.turns[node.turnIndex++];
node.userTurn = userTurn;
final Turn cubeTurn = SymTransform.getTurn(userTurn, node.symmetry);
node.cubeTurn = cubeTurn;
final int length = node.length + metric.length(userTurn);
if (cubeTurn.isB() && maxALength + length <= maxSearchLength && length <= maxBLength) {
final BNode nextNode = stackB[d + 1];
final int mep = transformB.mEdgePosTable.turn(cubeTurn, node.mEdgePos);
final int cp = transformB.cornerPosTable.turn(cubeTurn, node.cornerPos);
bprn++;
if (bprn % CYCLES_BETWEEN_USER_CHECK == 0 && (isInterrupted = reporter.shouldStop()))
return;
final int mep_cp_d =
pruneB.get_mEdgePos_cornerPos_dist(node.mEdgePos_cornerPos_dist, mep, cp);
if (mep_cp_d <= maxBLength - length) {
final int udep = transformB.udEdgePosTable.turn(cubeTurn, node.udEdgePos);
final int mep_udep_d =
pruneB.get_mEdgePos_udEdgePos_dist(node.mEdgePos_udEdgePos_dist, mep, udep);
if (mep_udep_d <= maxBLength - length) {
nextNode.setCubeState(mep, cp, udep);
nextNode.setDists(mep_cp_d, mep_udep_d);
nextNode.setTurnState(node, userTurn, turnListB);
nextNode.length = length;
d++;
} else bpry++;
} else bpry++;
}
}
}
stackBSize = d--;
display();
maxSearchLength = maxALength + maxBLength - (findAll ? 0 : 1);
} while (!isInterrupted && d >= 0);
}
@Property(name = PROPERTY_TURN)
public boolean setTurn(Turn value) {
boolean changed = false;
if (this.turn != value) {
Turn oldValue = this.turn;
Player source = this;
if (this.turn != null) {
this.turn = null;
oldValue.setPlayer(null);
}
this.turn = value;
if (value != null) {
value.setPlayer(this);
}
changed = true;
}
return changed;
}
public static void main(String[] args) throws IOException {
try (BufferedReader br =
new BufferedReader(
new InputStreamReader(Day01.class.getResourceAsStream("/01-input.txt")))) {
Position pos = new Position(), firstVisitedTwice = null;
Direction direction = Direction.NORTH;
Set<Position> visited = new HashSet<>();
visited.add(pos);
for (String move : br.readLine().split(", ")) {
direction = direction.turn(Turn.valueOf(String.valueOf(move.charAt(0))));
for (int i = 0; i < Integer.parseInt(move.substring(1)); i++) {
pos = direction.move(pos);
if (firstVisitedTwice == null && visited.contains(pos)) {
firstVisitedTwice = pos;
}
visited.add(pos);
}
}
System.out.println(pos.distance());
System.out.println(firstVisitedTwice.distance());
}
}
public void addTurn(List<Road> via, Road.End to) {
assert equals(to.getJunction());
Relation existing = null;
for (Turn t : to.getTurns()) {
if (t.getFrom().getOutgoingRoadEnd().equals(getOutgoingRoadEnd()) && t.getVia().equals(via)) {
if (t.getFrom().equals(this)) {
// was already added
return;
}
existing = t.getRelation();
}
}
final Relation r;
if (existing == null) {
r = new Relation();
r.put("type", Constants.TYPE_TURNS);
r.addMember(new RelationMember(Constants.TURN_ROLE_FROM, getOutgoingRoadEnd().getWay()));
if (via.isEmpty()) {
r.addMember(new RelationMember(Constants.TURN_ROLE_VIA, getOutgoingJunction().getNode()));
} else {
for (Way w :
Utils.flattenVia(getOutgoingJunction().getNode(), via, to.getJunction().getNode())) {
r.addMember(new RelationMember(Constants.TURN_ROLE_VIA, w));
}
}
r.addMember(new RelationMember(Constants.TURN_ROLE_TO, to.getWay()));
getOutgoingJunction().getNode().getDataSet().addPrimitive(r);
} else {
r = existing;
}
final String key = isExtra() ? Constants.TURN_KEY_EXTRA_LANES : Constants.TURN_KEY_LANES;
final List<Integer> lanes = Turn.indices(r, key);
lanes.add(getIndex());
r.put(key, Turn.join(lanes));
}
/** End the Game. */
public void endGame(Turn turn) {
System.out.println("Player " + turn.getWinner().name + " won!");
}
public Set<Turn> getTurns() {
return Turn.load(getContainer(), Constants.TURN_ROLE_FROM, getOutgoingRoadEnd().getWay());
}
