（如何操作）使用ENUM进行扑克定位

Question

假设我创建了以下类：

public enum Position {

   Dealer(1), //1
   SB(2),     //2
   BB(3),     //3
   UTG(4),    //4
   UTG1(5),   //5
   UTG2(6),   //6
   UTG3(7),   //7
   HJ(8),     //8
   CO(9);     //9

   //Constructor
   int code;

   Position(int code) {
     this.code = code;
   }
}

如何使用括号中的数字来操作 ENUM？ 例如，在我的扑克桌课上，我会培养新玩家。每个玩家传递参数Position。 所以一开始，

player[1].getPosition() = Dealer  
player[2].getPosition() = SB  
player[3].getPosition() = BB   
etc etc etc 

手牌结束后，所有的位置都需要移一位。
所以玩家[1]需要有CO(9)位置。
玩家[2]需要拥有庄家(1)位置。
玩家[3]需要拥有SB(2)位置。
等等

我知道我可以创建一个 for 循环，其中的变量循环遍历数字 1 到 9，但是如何根据 PositionENUM 内的整数访问位置？

---

编辑： 我已经有了 getter 和 setter。

    public int getCode() {
        return code;
    }
    public void setCode(int code) {
        this.code = code;
    }

然而，吸气剂和吸气剂并没有为我提供每轮正确改变球员位置的信息。

在每轮下注之后，我需要更改每个玩家的位置，因此我需要弄清楚如何在每轮下注之后移动每个玩家的 ENUM 位置。

Answer 1

可以根据其代码的值来选择枚举实例。您可以使用静态 Map 来执行此操作。唯一的问题是它必须位于静态内部类中：

public enum Position {

    ...

    Position(int code) {
        this.code = code;
        MapHolder.BY_CODE.put(code, this);
    }

    private static class MapHolder {
        private static final Map<Integer, Position> BY_CODE = new HashMap<Integer, Position>();
    }

    public static Position findByCode(int code) {
        return MapHolder.BY_CODE.get(code);
    }

我还建议将选择下一个位置的逻辑委托给枚举本身。只需将此方法添加到 Position 枚举中即可：

public Position nextPosition() {
     return findByCode((this.code + 1) % Position.values().length);
}

然后，您的客户端代码可以简单地执行：

for (Player player : players) {
    player.setPosition(player.getPosition().nextPosition());
}

Answer 2

看这里是一个在线扑克游戏示例

    #include <iostream>
#include <stdlib.h>
#include <cctype>
#include <memory.h>
#include "logic.h"

using namespace std;
// & means location
// * value of location

struct Cards {

enum Value {Two = 2, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King, Ace};
Value V;
int Suite;
enum Suite {Hearts, Diamonds, Clubs, Spades};
};

struct Hand {
Cards [5];

};

struct Deck {
Cards [52];

};

char * personsName [20]; //this means location with *
int numNames = 0;
char * Name;
char * search;
bool Continue;

int main ()
{
do {
for(int x = 0; x < 20; x++){
cout << "Enter a name, type END to stop: ";
Name = readString ();

if(strcmp (Name, "END") != 0){
personsName [x] = Name;
numNames++;
}
else{
Continue = (strcmp (Name, "END") != 0);
break;
}

}
cout << "Pre-sorted Names" << endl;
printNames(personsName,numNames);

bubbleSort(personsName,numNames);

cout << "Post-sorted Names" << endl;
printNames(personsName,numNames);

cout << "What would you like to find?" << endl;
search = readString();
cout << "The name is at index " << binarySearch(personsName,search,numNames) << endl;

} while (Continue);
delete [] * personsName;
return 0;
}

Answer 3

我不确定我是否正确理解您的问题，但您可以为您的枚举声明一个 getCode() 方法：

public enum Position {

  Dealer(1), //1
  SB(2),     //2
  BB(3),     //3
  UTG(4),    //4
  UTG1(5),   //5
  UTG2(6),   //6
  UTG3(7),   //7
  HJ(8),     //8
  CO(9);     //9

  int code;

  //Constructor
  Position(int code) {
    this.code = code;
  }

  public int getCode() {
    return code;
  }
}

Answer 4

code 是包访问范围。

如果您从包内调用，那么您可能需要执行以下操作：

Position.BB.code

如果您从包外部调用，则可能需要在枚举类内提供访问器。

public int getCode(){
    return this.code;
}

Answer 5

你可以只使用ordinal()作为位置（从0开始，就像下标一样）。此外，如果枚举按相反顺序（因为交易传递到左侧）可能会更容易，如下面的代码。这在短游戏中不起作用（您需要对玩家数量进行取模）。

enum Position {
    Dealer, CO, HJ, UTG3, UTG2, UTG, BB, SS;
    Position next() {
        return values()[(ordinal() + 1) % values().length];
    }
}
class Player {
    Player(Position position) {
        this.position = position;
    }
    void next() {
        position = position.next();
    }
    Position position;
}
public class Main {
    public static void main(String[] args) {
        Player[] players = new Player[Position.values().length];
        for (Position position : Position.values())
            players[position.ordinal()] = new Player(position);
        for (Player player : players)
            System.out.println(player.position);
        for (int i = 0; i < Position.values().length; i++)
            for (Player player : players)
                player.next();
        for (Player player : players)
            System.out.println(player.position);
    }
}

Answer 6

我不太确定这是否是您的要求。看看下面给出的代码是否有帮助：

public enum Position {

    Dealer(1), // 1
    SB(2), // 2
    BB(3), // 3
    UTG(4), // 4
    UTG1(5), // 5
    UTG2(6), // 6
    UTG3(7), // 7
    HJ(8), // 8
    CO(9); // 9

    // Constructor
    int code;

    Position(int code) {
        this.code = code;
    }

    private static Position[] currentPosition = Position.values();

    public static Position[] getCurrentPosition() {
        return currentPosition;
    }

    private static List<Position> positionWrap = Arrays.asList(currentPosition);

    public static void shiftPostion() {
        Collections.rotate(positionWrap, 1);
        updatePositions();
    }

    private static void updatePositions() {
        for (int i = 0; i < currentPosition.length; i++){
            currentPosition[i].code = i + 1;
        }
    }

    public static void main(String[] args) {
        Position[] pos = getCurrentPosition();
        System.out.println(Arrays.toString(pos));
        Position.shiftPostion();
        System.out.println(Arrays.toString(pos));
        Position.shiftPostion();
        System.out.println(Arrays.toString(pos));

    }

    @Override
    public String toString() {

        return this.name() + "(" + code + ")";
    }
}