private void genericScoreRecursive(HashSet<BoardPosition> searched,
			HashSet<BoardPosition> toSearch,
			ArrayList<Meeple> meeplesOnFeature, Object[] featureProperties) {

		// Take a position from the toSearch map to search.
		Iterator<BoardPosition> toSearchIterator = toSearch.iterator();
		BoardPosition boardPosition;

		if (toSearchIterator.hasNext()) {
			boardPosition = toSearchIterator.next();
		} else {
			return;
		}

		int xBoard = boardPosition.xBoard;
		int yBoard = boardPosition.yBoard;
		int xTile = boardPosition.xTile;
		int yTile = boardPosition.yTile;

		Tile currentTile = gameBoard[yBoard][xBoard];

		// Search the position & add it to searched map.
		Meeple meeple = getMeeple(xBoard, yBoard, xTile, yTile);

		if (meeple != null) {
			// Add the meeple on the tile to our list.
			meeplesOnFeature.add(meeple);
		}

		toSearch.remove(boardPosition);
		searched.add(boardPosition);

		// Add valid neighbors of position to toSearch map.
		// A neighbor is valid if it is in neither map,
		// and is of the same tile type.
		TileType currentTileType = currentTile.getTileType(xTile, yTile);

		// Add to an array. And run through adding each to toSearch.
		BoardPosition[] neighborTiles = getTileNeighbors(xBoard, yBoard, xTile,
				yTile);

        for (BoardPosition neighborTile : neighborTiles) {

            // Check the tile is not null.
            Tile tile = gameBoard[neighborTile.yBoard][neighborTile.xBoard];

            if (tile != null) {

                // Check that the tile has the same tile type.
                TileType tileType = tile.getTileType(neighborTile.xTile,
                        neighborTile.yTile);

                if (tileType == currentTileType) {

                    BoardPosition toAdd = new BoardPosition(
                            neighborTile.xBoard, neighborTile.yBoard,
                            neighborTile.xTile, neighborTile.yTile);

                    // Check the tile is not already in searched or toSearch.
                    if (!toSearch.contains(toAdd) && !searched.contains(toAdd)) {
                        toSearch.add(toAdd);
                    }
                }

            } else {
                // If we have a neighboring tile which is null then the
                // feature is not complete.
                featureProperties[1] = true;
            }
        }

		// If there are still tiles in toSearch then continue searching.
		if (!toSearch.isEmpty()) {
			genericScoreRecursive(searched, toSearch, meeplesOnFeature,
                    featureProperties);
        } else {
            // Get the number of tiles searched.
            HashSet<BoardPosition> searchedTiles = new HashSet<BoardPosition>();

            // Filter out multiple tiles by excluding the xTile & yTile values.
            for (BoardPosition searchedPosition : searched) {

                BoardPosition tilePosition = new BoardPosition(
                        searchedPosition.xBoard,
                        searchedPosition.yBoard, 0, 0);

                searchedTiles.add(tilePosition);
            }

            // Set the number of tiles searched.
            featureProperties[0] = searchedTiles.size();
		}
	}