Dividing monopoly streets in groups

Question

I'm new to object-oriented programming, to java, and to programming in general, and as my first real project I'm trying to program the board game Monopoly.

What I've got so far is an array that can store objects of the class Square (which has various subclasses, like properties, the railroads, chance cards etc.). Player objects take turns in moving around on the board, calling a landedOn() method for whatever square they land on. Properties can be marked with an owner, and thus this owner will receive money if someone lands on his property.

Everything is going good so far, but there is one little thing that bugs me. I'm unsure about how to elegantly divide the houses in groups, or colors. There are a couple of groups of streets on the board, and you can only buy houses if you own all properties in the group. I can imagine how to program this, but the solution seems a bit dirty and "non-general" to me. How do I make a nice general solution?

To clear up: I want to be able to check whether all properties of one type are owned by the same player, in a general way, so that if the groups are changed, a property is added, or changes group, etc., I would not have to change a lot of code.

Answer 1

The most elegant answer is probably an Enum.

Create an enum value for each color group, and when you create your Property object (which inherits from Square), pass the color group as a constructor parameter (since it is a required value to have a valid Property). Railroad, Utility and the like will not take this parameter, since they don't have groups, and they also inherit directly from Square (not Property).*

To check whether a player has all the properties in a given group, you could use a Lambda expression if you're using Java 8, or simply have a foreach loop along the lines of

for (property: allProperties)
{
   if (property.getGroup() == targetGroup && property.getOwner() != targetOwner) return false;
}
return true;

* It would also be valid to have a GroupedSquare class between Property and Square, with Railroad and Utility also inheriting from it and passing a hard-coded enum value, but I think that's less elegant.

Answer 2

An alternative to an enum by Bobson might be to have the groups as independent objects. By this you don't have to iterate over all atreets to see if a group omplte but can check the individual group only. In Pseudocode the impleemntation might look like this:

class Group {
    Set<Road> roads;

    bool hasAll(Player player) {
        for (road: roads) {
            if (road.getOwner() != player) {
                return false;
            }
        }
        return true;
  }
}

class Road {
    Player owner;
    Group group;

    bool canBuildHouses(Player player) {
        return group.hasAll(player);
    }
}

Over the enum approach this has the benefit that you can mov the group specific logic all in the Group class.

Now OO designes will still not like this due to the cyclic dependency (a Group has to know its member Roads and a Road has to know its Group) which can be solved by an event-based approach this would make this specific issue notably more complex but give way more flexibility for i.e. adding special rules as one could add extra rules like bonusses if a player contains a full side of the board or all roads starting with the same letter or something quite easily.