java – 是哈希一个合适的解决方案吗？我过度复杂吗？

我写了一个2D平台游戏,我需要房间(最多4个)门.我用 Java编写它,但语言是无关紧要的.

每个房间可以在顶部,底部和侧面设有4扇门.我称他们为北,南,东,西.当我建立一个房间时,我只给它一个整数,整数的每一位都代表一个门.

例如,如果我想要一个有3扇门的房间
(一个在北部,一个在东部,在西部)
我给房间的号码：11(1011在二进制).

因此,每个门都有一个整数,识别它.

NORTH = 8;//1000
SOUTH = 4;//0100
EAST =  2;//0010
WEST =  1;//0001

如果我生成一个房间,我给它们这些标识符的组合.

例如：前面提到的房间会得到标识符

doorStock = NORTH | EAST | WEST;

我把这些门存放在一个简单的阵列中：

Door doors[] = new Door[4];

我的问题是：我需要一个可以将标识符映射到数组中的正确索引的函数.我并不总是需要4扇门.

我最初做的一切似乎是最简单的：门阵列总是有4个元素,我不会使用的索引将简单地保持为空.

public Door getDoor(int doorID){
    switch(doorID){
        case NORTH:{
            return doors[0];
        }
        case SOUTH:{
            return doors[1];
        }
        case EAST:{
            return doors[2];
        }
        case WEST:{
            return doors[3];
        }
    }
    return null;
}

为了安全起见,我需要确定我要求的门是否真的存在于房间里.

private boolean doorExists(int doorID){
    return (doorID & doorStock) != 0
}

所以这样,查询功能如下所示：

public Door getDoor(int doorID){
    switch(doorID){
        case NORTH:{
            if(doorExists(NORTH))return doors[0];
            else return null;
        }
        case SOUTH:{
            if(doorExists(NORTH))return doors[1];
            else return null;
        }
        case EAST:{
            if(doorExists(NORTH))return doors[2];
            else return null;
        }
        case WEST:{
            if(doorExists(NORTH))return doors[3];
            else return null;
        }
    }
    return null;
}

哪个工作但！这样,阵列可能会使用未使用的元素浪费空间.加上门可能会有任何尺寸,增加内存浪费.

更不用说,我可能需要更多的“插槽”的门(例如,如果我尝试在3D中实现这一点),所以我决定尝试使门阵列的大小取决于门的标识符：

Door doors = new Door[Integer.bitCount(doorStock)];

这给了一个IndexOutOfBounds错误真正快速.我并不惊讶,因为门阵列可以是从0到4的任何大小,所以我需要一个新的哈希方法.

我想出了两个哈希表,一个是数组索引：

private final int[][] doorhash = {
    /* NORTH  SOUTH   EAST    WEST doorStock*/
    { -1,-1,-1} /*0000*/,{ -1,0} /*0001*/,-1} /*0010*/,1} /*0011*/,-1} /*0100*/,1} /*0101*/,1,-1} /*0110*/,2} /*0111*/,{  0,-1} /*1000*/,1} /*1001*/,-1} /*1010*/,2} /*1011*/,-1} /*1100*/,2} /*1101*/,2,-1} /*1110*/,3} /*1111*/
};

一个,有助于帮助映射上一张表：

private final int[] directionHash = {
    -1,/*0000*/
     3,/*0001 - WEST*/
     2,/*0010 - EAST*/
    -1,/*0011*/
     1,/*0100 - SOUTH*/
    -1,/*0101*/
    -1,/*0110*/
    -1,/*0111*/
     0,/*1000 - NORTH*/
};

所以我目前的映射功能如下所示：

public Door getDoor(int doorID){
    switch(doorID){
        case NORTH:{
            if(doorExists(NORTH))return doors[doorhash[doorStock][directionHash[NORTH]]];
            else return null;
        }
        case SOUTH:{
            if(doorExists(NORTH))return doors[doorhash[doorStock][directionHash[SOUTH]]];
            else return null;
        }
        case EAST:{
            if(doorExists(NORTH))return doors[doorhash[doorStock][directionHash[EAST]]];
            else return null;
        }
        case WEST:{
            if(doorExists(NORTH))return doors[doorhash[doorStock][directionHash[WEST]]];
            else return null;
        }
    }
    return null;
}

这也似乎工作正常,但我觉得这个问题有一个更简单的解决方案,或者一个浪费更少的哈希表.我觉得这不像应该是渐近的灵活,或者我是过于复杂的事情.什么会是更好的方法？

感谢您的时间！

// Each possible direction - with Up/Down added to show extendability.
public enum Dir {
  North,South,East,West,Up,Down;
}

class Room {
  // The doors.
  EnumSet doors = EnumSet.noneOf(Dir.class);

  // Many other possible constructors.
  public Room ( Dir ... doors) {
    this.doors.addAll(Arrays.asList(doors));
  }

  public boolean doorExists (Dir dir) {
    return doors.contains(dir);
  }
}