mjhjmtu

I'm currently working on a Dungeon game project which is composed of multiples rooms connected to each other.

Depending on the room you're in you can go to rooms next to yours by picking directions (North, South, East, West).

I've represented the directions with an Enum class and I'm looking for a way to implements that North is the opposite of South, East for West (and so on ...) for the sake of creating the layout of all the rooms in the final form of the game.

Here is my Enum class :

public enum Direction 
 NORTH,
 EAST,
 SOUTH,
 WEST;

 public Direction getOppositeDirection() 
 return Direction.values()[(this.ordinal()+2)%4];
 

The problem is that currently the method is not very safe, any change in the order of declarations in the direction will break the method, any suggestions on how to do this in a better way?

You could make the method abstract, and implement it for each constant.

enum Direction 
 NORTH() 
 public Direction getOppositeDirection() 
 return SOUTH;
 
 ,
 EAST() 
 public Direction getOppositeDirection() 
 return WEST;
 
 ,
 SOUTH() 
 public Direction getOppositeDirection() 
 return NORTH;
 
 ,
 WEST() 
 public Direction getOppositeDirection() 
 return EAST;
 
 ;

 public abstract Direction getOppositeDirection();

It's a bit wordy, though.

The next method is shorter but more difficult to read.

enum Direction 
 NORTH, EAST, SOUTH, WEST;

 static 
 (SOUTH.oppositeDirection = NORTH).oppositeDirection = SOUTH;
 (WEST.oppositeDirection = EAST).oppositeDirection = WEST;
 

 private Direction oppositeDirection;

 public Direction getOppositeDirection() 
 return oppositeDirection;
 

You may also want to look in lambda for other case, but you will need to use a little cheat code because NORTH and EAST can't reference constant/field before they are defined:

import java.util.function.Supplier;

public enum Direction 
 NORTH,
 EAST,
 SOUTH,
 WEST;

 private Supplier<Direction> opposite;

 private Direction() 
 

 static // initialize opposite field
 for (final Direction direction : Direction.values()) 
 direction.opposite = oppositeOf(direction);
 
 

 private static Supplier<Direction> oppositeOf(final Direction self) 
 switch (self) 
 case NORTH: return () -> SOUTH;
 case WEST: return () -> EAST;
 case EAST: return () -> WEST;
 case SOUTH: return () -> NORTH;
 default: throw new IllegalStateException("Invalid opposite: " + self);
 
 

 public final Direction getOppositeDirection() 
 return opposite.get();
 

 public static void main(final String args) 
 for (final Direction dir : Direction.values()) 
 System.out.println(dir + " is opposite of " + dir.getOppositeDirection());
 
 

This does the same than having abstract method, but is more concise (except here because you need to add more to the code): you read directly what is the opposite direction instead of having the verbose method declaration (it is another matter if you need to also add other methods).

Also, it will not create pseudo class for each enums constant (eg: Direction$1, Direction$2, ...) because there is no need to.

The concise answer is:

public Direction getOppositeDirection() 
 return
 this==NORTH ? SOUTH :
 this==EAST ? WEST :
 this==SOUTH ? NORTH :
 EAST;

You might prefer case statement

public Direction getOppositeDirection() 
 switch (this) 
 case NORTH: return SOUTH;
 case EAST: return WEST;
 case SOUTH: return NORTH;
 case WEST: return EAST;
 default: throw new Error();
 

Another option could be to use a Map (perhaps even an EnumMap), e.g.:

public enum Direction 

 NORTH,
 EAST,
 SOUTH,
 WEST;

 private static final Map<Direction, Direction> OPPOSITES = ImmutableMap.of(
 NORTH, SOUTH,
 EAST, WEST,
 SOUTH, NORTH,
 WEST, EAST
 );

 public Direction oppositeDirection() 
 return OPPOSITES.get(this);
 

I feel like the easiest way would be to do it the way you originally proposed, but accept a parameter in the constructor:

public static enum Direction 
 NORTH(0),
 WEST(1),
 SOUTH(2),
 EAST(3);

 private int dir;

 private Direction(int dir) 
 this.dir = dir;
 

 public static Direction getNewDirection(int dir) 
 // ensure direction is in [0, 4)
 dir %= 4;
 if (dir < 0) dir += 4;
 for (Direction d : Direction.values()) 
 if (d.dir == dir) return d;
 
 throw new Error();
 

 public Direction getOppositeDirection() 
 return getNewDirection(dir + 2);
 

The advantages to this are numerous: directions essentially form a group of rotations, which correspond to the integers modulo 4. They have a natural representation as integers modulo 4. Now, if we want to get the direction that is clockwise, we can do that easily (getNewDirection(dir + 1)), or counterclockwise (getNewDirection(dir - 1)). If the character is facing direction d1 and we want to know which way to turn to face a new direction d2, this corresponds to subtraction, etc. All of the operations that you might want to do have a natural way to do it with the integers modulo 4.