alle möglichen Züge aller Spieler

Question

in einem einfachen Spiel ich habe 4 möglichen Züge (oben, unten, links, rechts) für jeden Spieler

public struct Point 
{ 
    public int x; 
    public int y; 
} 
Point[] directions = new Point[] 
{ 
    new Point() {x=0,y=1 }, 
    new Point() {x=0,y=-1 }, 
    new Point() {x=1,y=0 }, 
    new Point() {x=-1,y=0 } 
}; 

i n Spieler haben, zum Beispiel 3, aber diese Nummer ist nicht konstant.

Ich muss alle möglichen Bewegungen in ein Array aufzählen. zum Beispiel:

player1: up, player2:up, player3:up 
    player1: up, player2:up, player3:left 
    player1: up, player2:up, player3:right 
    player1: up, player2:up, player3:down 
    player1: up, player2:left, player3:up 
    .... 
    .... 

was ist der beste Weg, um alle möglichen Züge aller Spieler in ein Array aufzuzählen?

muss das resultierende Array sein:

item[0] = {up,up,up}; 
item[1] = {up,up,down}; 
item[2] = {up,up,left}; 
item[3] = {up,up,right}; 
item[4] = {up,down,up}; 
.... 

bitte, können Sie mir helfen?

Answer 1

Angenommen, Sie haben eine Enumeration wie

enum Move 
{ 
    Up, 
    Down, 
    Left, 
    Right 
} 

Ein Weg ist es, eine ganze Zahl zu wiederholen und wandeln diese ganze Zahl an der Basis wird 4. Das Ergebnis sein:

0000 -> 0001 ---> 0002 ---> 0003 -> 0010 -> ... ---> 3333

können Sie Nimm jede Ziffer der Zahlen und wirf sie auf t o der Enum-Wert.Hier ist die resultierende Methode:

private static List<Move[]> GetPossibleMoves(int NumberOfPlayers) 
{ 
    int Combination = 0; 
    List<Move[]> PossibleMoves = new List<Move[]>(); 
    while (true) 
    { 
     List<int> Digits = IntToString(Combination, new char[] { '0', '1', '2', '3' }) 
      .PadLeft(NumberOfPlayers, '0') 
      .Select(D => Convert.ToInt32(D.ToString())) 
      .ToList(); 

     if (Digits.Count() > NumberOfPlayers) 
     { 
      break; 
     } 
     else 
     { 
      Move[] Moves = new Move[NumberOfPlayers]; 
      for (int Player = 0; Player < NumberOfPlayers; Player++) 
      { 
       Moves[Player] = (Move)Digits[Player]; 
      } 
      PossibleMoves.Add(Moves);     
     } 
     Combination++; 
    } 
    return PossibleMoves; 
} 

Als Helfer an der Basis zu konvertieren 4 Sie die Methode von Dirk Vollmar bei this question nehmen:

private static string IntToString(int value, char[] baseChars) 
{ 
    string result = string.Empty; 
    int targetBase = baseChars.Length; 

    do 
    { 
     result = baseChars[value % targetBase] + result; 
     value = value/targetBase; 
    } 
    while (value > 0); 

    return result; 
} 

Das Ergebnis wird sein:

Auf, Auf, Auf, Auf

Auf, Auf, Auf, Ab

Up, Up, Up, Left

Up, Up, Up, Right

Up, Up, Down, Up

...

Rechts, Rechts, Rechts Rechts

Answer 2

Nehmen wir an, Sie haben 4 Spieler und jeder hat 4 mögliche Züge. Insgesamt 256 Kombinationen. n Spieler, 4 Züge => 4^n Ordnen Sie Ihre Züge zu den Nummern Up - 0, Down - 1, Links - 2, Rechts - 3 Dann konvertieren Sie die 256 (Basis von 10) zur Basis von 4 und Sie wird 10000 bekommen. Also von 0 bis 3333 (in der Basis von 4) iterieren und jeden Zahlenplatz extrahieren und entsprechend für jeden Spieler abbilden. In Beispiel eine Anzahl von 2330 würde bedeuten, - 1. Spieler - links, 2. Spieler - rechts, 3. - rechts, 4. Spieler - bis

Answer 3

Mit dieser Enumeration:

public enum Direction 
{ 
    Up, 
    Down, 
    Right, 
    Left 
} 

Versuchen über die ENUM-Werte iterieren mit Enum.GetValues Method und verwenden this Linq Select Überlastung (die Sie jede Kombination aus zwei IEnumerables Elemente erstellen können), um alle Kombinationen zu erstellen:

var options = Enum.GetValues(typeof(Direction)).Cast<Direction>() 
       .SelectMany(firstValue => Enum.GetValues(typeof(Direction)).Cast<Direction>(), 
       (firstValue, secondValue) => new { firstValue, secondValue}) 
       .SelecyMany(firstValues => Enum.GetValues(typeof(Direction)).Cast<Direction>(), 
       (firstValues, lastValue) => new {firstValues.firstValue, firstValues.secondValue, lastValue}).ToList(); 

Sie können auch die letzte Select ersetzen eine 3 lengt erstellen h Array als Listenelement anstelle der annonymous Typ, ersetzen Sie einfach die letzte Zeile mit:

(firstValues, lastValue) => new Direction[] {firstValues.firstValue, firstValues.secondValue, lastValue}).ToList();