private ArrayList<BoardPosition> genericScore(ArrayList<Player> players,
			TileType scoreTileType, boolean hasGameEnded) {

		// Initialize the variables which will hold information about the
		// specific feature. These are reset for each feature.
		int nTiles;
		boolean nullTileFound;
		HashSet<BoardPosition> searched;
		HashSet<BoardPosition> toSearch;
		ArrayList<Meeple> meeplesOnFeature;

		// And other variables.
		ArrayList<BoardPosition> removedMeeples = new ArrayList<BoardPosition>();

		// Run through all the placed meeples.
		Iterator<Meeple> iter = meeplePlacement.keySet().iterator();

		while (iter.hasNext()) {

			// Reset the variables which hold info about specific features.
			nTiles = 0;
			nullTileFound = false;
			searched = new HashSet<BoardPosition>();
			toSearch = new HashSet<BoardPosition>();
			meeplesOnFeature = new ArrayList<Meeple>();
			Object[] featureProperties = { nTiles, nullTileFound };

			// And now the real work begins.
			BoardPosition meeplePosition = meeplePlacement.get(iter.next());

			// Check to see if it is attached to the correct tile type.
			Tile tile = gameBoard[meeplePosition.yBoard][meeplePosition.xBoard];
			TileType tileType = tile.getTileType(meeplePosition.xTile,
					meeplePosition.yTile);

			// If it is attached to the correct tile type.
			if (tileType == scoreTileType) {

				// Init search.
				Point tilePosition = getTilePosition(tile);
				BoardPosition boardPosition = new BoardPosition(tilePosition.x,
						tilePosition.y, meeplePosition.xTile,
						meeplePosition.yTile);

				toSearch.add(boardPosition);

				// Call our search.
				genericScoreRecursive(searched, toSearch, meeplesOnFeature,
						featureProperties);

				// Recover tracker variables from object array.
				nTiles = (Integer) featureProperties[0];
				nullTileFound = (Boolean) featureProperties[1];

				// Score multiplier depends on the feature.
				// The base multiplier is 1.
				int multiplier = 1;

				// Each city tile is worth 2 points during the game.
				if (!hasGameEnded && scoreTileType == TileType.CITY) {
					multiplier = 2;
				}

				// We are scoring if the feature is complete and
				// the game is not over, or if the game is over.
				if (hasGameEnded || (!nullTileFound && !hasGameEnded)) {

					ArrayList<Player> scoringPlayers = getFeatureScorers(
							players, meeplesOnFeature);

					// Remove the meeples from the board.
                    for (Meeple meeple : meeplesOnFeature) {

                        removedMeeples.add(meeplePlacement.get(meeple));
                        meeplePlacement.remove(meeple);
                    }

					// Since we are iterating through meeplePlacement
					// we need to refresh it when it's altered.
					iter = meeplePlacement.keySet().iterator();

					// Recalculate scores.
                    for (Player scoringPlayer : scoringPlayers) {

                        int score = scoringPlayer.getScore();
                        int newScore = (nTiles * multiplier) + score;
                        scoringPlayer.setScore(newScore);
                    }
				}
			}
		}

		return removedMeeples;
	}