piecens field. */
public static final String PIECENS = "piecens";
+ /** The field name of the scores field. */
+ public static final String SCORES = "scores";
+
/** A set containing all of the tiles that are in play in this
* game. */
public DSet tiles = new DSet(VenisonTile.class);
@@ -32,6 +36,9 @@ public class VenisonObject extends TurnGameObject
* board. */
public DSet piecens = new DSet(Piecen.class);
+ /** The scores for each player. */
+ public int[] scores;
+
/**
* Requests that the tiles field be set to the specified
* value.
@@ -113,6 +120,15 @@ public class VenisonObject extends TurnGameObject
requestElementUpdate(PIECENS, elem);
}
+ /**
+ * Requests that the scores field be set to the specified
+ * value.
+ */
+ public void setScores (int[] value)
+ {
+ requestAttributeChange(SCORES, value);
+ }
+
// documentation inherited
protected void toString (StringBuffer buf)
{
@@ -120,5 +136,6 @@ public class VenisonObject extends TurnGameObject
buf.append(", tiles=").append(tiles);
buf.append(", currentTile=").append(currentTile);
buf.append(", piecens=").append(piecens);
+ buf.append(", scores=").append(StringUtil.toString(scores));
}
}
diff --git a/projects/atlanti/src/java/com/samskivert/atlanti/data/Feature.java b/projects/atlanti/src/java/com/samskivert/atlanti/data/Feature.java
index 1a4983dc..050063a5 100644
--- a/projects/atlanti/src/java/com/samskivert/atlanti/data/Feature.java
+++ b/projects/atlanti/src/java/com/samskivert/atlanti/data/Feature.java
@@ -1,5 +1,5 @@
//
-// $Id: Feature.java,v 1.1 2001/10/17 02:19:54 mdb Exp $
+// $Id: Feature.java,v 1.2 2001/10/17 04:34:13 mdb Exp $
package com.threerings.venison;
@@ -334,9 +334,13 @@ public class Feature
return poly;
}
+ /**
+ * Generates a string representation of this feature.
+ */
public String toString ()
{
- return "[type=" + type + ", edgeMask=" + edgeMask + "]";
+ return "[type=" + FeatureUtil.typeToString(type) +
+ ", edgeMask=" + FeatureUtil.edgeMaskToString(edgeMask) + "]";
}
/** Maps feature types to colors. */
diff --git a/projects/atlanti/src/java/com/samskivert/atlanti/server/AtlantiManager.java b/projects/atlanti/src/java/com/samskivert/atlanti/server/AtlantiManager.java
index caff9411..08a9830f 100644
--- a/projects/atlanti/src/java/com/samskivert/atlanti/server/AtlantiManager.java
+++ b/projects/atlanti/src/java/com/samskivert/atlanti/server/AtlantiManager.java
@@ -1,12 +1,16 @@
//
-// $Id: AtlantiManager.java,v 1.8 2001/10/17 02:19:54 mdb Exp $
+// $Id: AtlantiManager.java,v 1.9 2001/10/17 04:34:14 mdb Exp $
package com.threerings.venison;
+import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.Iterator;
import java.util.List;
+import com.samskivert.util.StringUtil;
+
import com.threerings.presents.dobj.DSet;
import com.threerings.presents.dobj.MessageEvent;
@@ -61,6 +65,12 @@ public class VenisonManager
// clear out our board tiles
_tiles.clear();
+ // create a claim group vector
+ _claimGroupVector = new int[_players.length];
+
+ // clear out the scores
+ _venobj.setScores(new int[_players.length]);
+
// clear out the tile and piecen set
_venobj.setTiles(new DSet(VenisonTile.class));
_venobj.setPiecens(new DSet(Piecen.class));
@@ -105,6 +115,110 @@ public class VenisonManager
}
}
+ /**
+ * Determines whether or not the placement of this tile has completed
+ * features that were previously incomplete.
+ */
+ protected void scoreCompletedFeatures (VenisonTile tile)
+ {
+ // potentially score all features on the tile
+ for (int i = 0; i < tile.features.length; i++) {
+ // we only need to worry about ROAD and CITY features because
+ // those are the only features on this tile that we might have
+ // completed
+ Feature f = tile.features[i];
+ if (f.type != TileCodes.CITY && f.type != TileCodes.ROAD) {
+ continue;
+ }
+
+ // see if any piecens are even on a feature in this group
+ int cgroup = tile.claims[i];
+ int[] cgv = getClaimGroupVector(cgroup);
+ if (cgv == null) {
+ // if not, we don't have anything to score
+ Log.info("Not scoring unclaimed feature " +
+ "[ttype=" + tile.type + ", feat=" + f +
+ ", cgroup=" + cgroup + "].");
+ continue;
+ }
+
+ // we do have something to score, so we compute the score for
+ // this feature
+ int score = TileUtil.computeFeatureScore(_tiles, tile, i);
+
+ // if the score is positive, it's a completed feature, so we
+ // dole out the points and clear the associated piecens
+ if (score > 0) {
+ Log.info("Scoring feature [ttype=" + tile.type +
+ ", feature=" + f + ", score=" + score + "].");
+
+ // adjust the scores
+ for (int p = 0; p < cgv.length; p++) {
+ _venobj.scores[p] += (score * cgv[p]);
+ }
+
+ // broadcast the new scores
+ _venobj.setScores(_venobj.scores);
+ Log.info("New scores: " + StringUtil.toString(_venobj.scores));
+
+ // and free up the scored piecens
+ Iterator iter = _venobj.piecens.elements();
+ while (iter.hasNext()) {
+ Piecen p = (Piecen)iter.next();
+ if (p.claimGroup == cgroup) {
+ Log.info("Removing piecen " + p + ".");
+ _venobj.removeFromPiecens(p.getKey());
+ }
+ }
+
+ } else {
+ Log.info("Not scoring incomplete feature " +
+ "[ttype=" + tile.type + ", feat=" + f +
+ ", score=" + score + "].");
+ }
+ }
+ }
+
+ /**
+ * Returns an int array with zeros and ones in the appropriate places
+ * so that a score can be multiplied by a player's position in the
+ * vector to determine whether or not they receive any points for the
+ * scoring of a particular claim group.
+ *
+ * Note that this function returns a static (to this instance) + * vector, so it cannot be called again without overwriting values + * returned previously. + * + * @return an array for the specified claim group or null if no + * players have a piecen claiming the specified claim group. + */ + protected int[] getClaimGroupVector (int claimGroup) + { + // clear out the vector + Arrays.fill(_claimGroupVector, 0); + + // iterate over the piecens + int max = 0; + Iterator iter = _venobj.piecens.elements(); + while (iter.hasNext()) { + Piecen piecen = (Piecen)iter.next(); + if (piecen.claimGroup == claimGroup) { + // color == player index... somewhat sketchy + if (++_claimGroupVector[piecen.color] > max) { + // keep track of the highest scorer + max = _claimGroupVector[piecen.color]; + } + } + } + + // now cut out everyone with scores less than the highest score + for (int i = 0; i < _claimGroupVector.length; i++) { + _claimGroupVector[i] = (_claimGroupVector[i] < max) ? 0 : 1; + } + + return (max == 0) ? null : _claimGroupVector; + } + /** Handles place tile requests. */ protected class PlaceTileHandler implements MessageHandler { @@ -114,17 +228,22 @@ public class VenisonManager // make sure this is a valid placement if (TileUtil.isValidPlacement(_tiles, tile)) { - // add the tile to the lsit + // add the tile to the list and resort it _tiles.add(tile); + Collections.sort(_tiles); // inherit its claim groups TileUtil.inheritClaims(_tiles, tile); - Log.info("Placed tile " + tile + "."); - // add the tile to the tiles set _venobj.addToTiles(tile); + // placing a piece may have completed road or city + // features. if it did, we score them now + scoreCompletedFeatures(tile); + + Log.info("Placed tile " + tile + "."); + } else { Log.warning("Received invalid placement " + event + "."); } @@ -182,4 +301,7 @@ public class VenisonManager /** A sorted list of the tiles that have been placed on the board. */ protected List _tiles = new ArrayList(); + + /** Used to score features groups. */ + protected int[] _claimGroupVector; } diff --git a/projects/atlanti/src/java/com/samskivert/atlanti/util/FeatureUtil.java b/projects/atlanti/src/java/com/samskivert/atlanti/util/FeatureUtil.java index 8867e948..c42515a4 100644 --- a/projects/atlanti/src/java/com/samskivert/atlanti/util/FeatureUtil.java +++ b/projects/atlanti/src/java/com/samskivert/atlanti/util/FeatureUtil.java @@ -1,5 +1,5 @@ // -// $Id: FeatureUtil.java,v 1.1 2001/10/17 02:19:54 mdb Exp $ +// $Id: FeatureUtil.java,v 1.2 2001/10/17 04:34:13 mdb Exp $ package com.threerings.venison; @@ -86,6 +86,39 @@ public class FeatureUtil implements TileCodes return features; } + /** + * Returns a string describing the supplied type code. + */ + public static String typeToString (int type) + { + return TYPE_CODES[type]; + } + + /** + * Returns a string describing the supplied edge mask. + */ + public static String edgeMaskToString (int edgeMask) + { + StringBuffer buf = new StringBuffer(); + if ((edgeMask & NORTH_F) != 0) buf.append("NORTH_F|"); + if ((edgeMask & EAST_F) != 0) buf.append("EAST_F|"); + if ((edgeMask & SOUTH_F) != 0) buf.append("SOUTH_F|"); + if ((edgeMask & WEST_F) != 0) buf.append("WEST_F|"); + if ((edgeMask & NNW_F) != 0) buf.append("NNW_F|"); + if ((edgeMask & NNE_F) != 0) buf.append("NNE_F|"); + if ((edgeMask & SSW_F) != 0) buf.append("SSW_F|"); + if ((edgeMask & SSE_F) != 0) buf.append("SSE_F|"); + if ((edgeMask & WNW_F) != 0) buf.append("WNW_F|"); + if ((edgeMask & WSW_F) != 0) buf.append("WSW_F|"); + if ((edgeMask & ENE_F) != 0) buf.append("ENE_F|"); + if ((edgeMask & ESE_F) != 0) buf.append("ESE_F|"); + // strip off the trailing bar if there is one + if (buf.length() > 0) { + buf.deleteCharAt(buf.length()-1); + } + return buf.toString(); + } + /** * Translates the feature edge mask into the orientation specified. * For a forward translation, provide a positive valued orientation @@ -300,6 +333,10 @@ public class FeatureUtil implements TileCodes { ENE_F, SSE_F, WSW_F, NNW_F }, }; + /** String representations of the feature type codes. */ + protected static final String[] TYPE_CODES = { + "CITY", "GRASS", "ROAD", "CLOISTER" }; + /** A table of features that are used on more than one tile. */ protected static Feature[] _reusedFeatures; diff --git a/projects/atlanti/src/java/com/samskivert/atlanti/util/TileUtil.java b/projects/atlanti/src/java/com/samskivert/atlanti/util/TileUtil.java index 26892e6f..7a826d6d 100644 --- a/projects/atlanti/src/java/com/samskivert/atlanti/util/TileUtil.java +++ b/projects/atlanti/src/java/com/samskivert/atlanti/util/TileUtil.java @@ -1,5 +1,5 @@ // -// $Id: TileUtil.java,v 1.7 2001/10/17 02:19:54 mdb Exp $ +// $Id: TileUtil.java,v 1.8 2001/10/17 04:34:13 mdb Exp $ package com.threerings.venison; @@ -384,6 +384,153 @@ public class TileUtil implements TileCodes } } + /** + * Computes the score for the specified feature and returns it. If the + * feature is complete (has no unconnected edges), the score will be + * positive. If it is incomplete, the score will be negative. + * + * @param tiles a sorted list of the tiles on the board. + * @param tile the tile that contains the feature whose score should + * be computed. + * @param featureIndex the index of the feature in the containing + * tile. + * + * @return a positive score for a completed feature group, a negative + * score for a partial feature group. + */ + public static int computeFeatureScore ( + List tiles, VenisonTile tile, int featureIndex) + { + // determine what kind of feature it is + Feature feature = tile.features[featureIndex]; + + switch (feature.type) { + case ROAD: + return computeFeatureScore(tiles, tile, feature, new ArrayList()); + + case CITY: { + int score = + computeFeatureScore(tiles, tile, feature, new ArrayList()); + // cities receive a 2x multiplier if they are larger than size + // two and are completed + return (score > 2) ? score*2 : score; + } + + case CLOISTER: + // cloister's score specially + return computeCloisterScore(tiles, tile); + + default: + case GRASS: + // grass doesn't score + return 0; + } + } + + /** + * A helper function for {@link + * #computeFeatureScore(List,VenisonTile,int)}. + */ + protected static int computeFeatureScore ( + List tiles, VenisonTile tile, Feature feature, List seen) + { + // if we've already counted this tile, bail + if (seen.contains(tile)) { + return 0; + } + + // otherwise add this tile to the seen list + seen.add(tile); + + // cities have a base score of one but get a one point bonus if + // they have a shield on them + int score = (feature.type == CITY && tile.hasShield) ? 2 : 1; + boolean missedNeighbor = false; + + // now figure out what connected features there are, if any + int ftype = feature.type; + int fmask = feature.edgeMask; + + // iterate over all of the possible adjacency possibilities + for (int c = 0; c < FeatureUtil.ADJACENCY_MAP.length; c += 3) { + int mask = FeatureUtil.ADJACENCY_MAP[c]; + int dir = FeatureUtil.ADJACENCY_MAP[c+1]; + int opp_mask = FeatureUtil.ADJACENCY_MAP[c+2]; + VenisonTile neighbor = null; + + // if this feature doesn't have this edge, skip it + if ((fmask & mask) == 0) { + continue; + } + + // make sure we have a neighbor in this direction + dir = (dir + tile.orientation) % 4; + switch (dir) { + case NORTH: neighbor = findTile(tiles, tile.x, tile.y-1); break; + case EAST: neighbor = findTile(tiles, tile.x+1, tile.y); break; + case SOUTH: neighbor = findTile(tiles, tile.x, tile.y+1); break; + case WEST: neighbor = findTile(tiles, tile.x-1, tile.y); break; + } + if (neighbor == null) { + // if we don't have a neighbor in a direction that we + // need, we're an incomplete feature. alas + missedNeighbor = true; + continue; + } + + // translate the target mask into our orientation + mask = FeatureUtil.translateMask(mask, tile.orientation); + opp_mask = FeatureUtil.translateMask(opp_mask, tile.orientation); + + // propagate, propagate, propagate + int fidx = neighbor.getFeatureIndex(opp_mask); + if (fidx < 0) { + Log.warning("Tile mismatch while scoring [self=" + tile + + ", target=" + neighbor + ", fidx=" + fidx + + ", srcEdge=" + mask + + ", destEdge=" + opp_mask + "]."); + + } else { + // add the score for this neighbor + int nscore = computeFeatureScore( + tiles, neighbor, neighbor.features[fidx], seen); + // if our neighbor returned a negative score, we convert + // it back to positive and make a note to make it negative + // at the end + if (nscore < 0) { + score += -nscore; + missedNeighbor = true; + } else { + score += nscore; + } + } + } + + return missedNeighbor ? -score : score; + } + + /** + * A helper function for {@link + * #computeFeatureScore(List,VenisonTile,int)}. + */ + protected static int computeCloisterScore (List tiles, VenisonTile tile) + { + int score = 0; + + // all we need to know are how many neighbors this guy has (we + // count ourselves as well, just for code simplicity) + for (int dx = -1; dx < 1; dx++) { + for (int dy = -1; dy < 1; dy++) { + if (findTile(tiles, tile.x + dx, tile.y + dy) != null) { + score++; + } + } + } + + // incomplete cloisters return a negative score + return (score == 9) ? 9 : -score; + } + /** * Locates and returns the tile with the specified coordinates. *