Example #1
0
 public void Test_wrap_StdDeck_CardMask_SET()
 {
     StdDeck.CardMask mask = API.wrap_StdDeck_CardMask_RESET();
     mask = API.wrap_StdDeck_CardMask_SET(mask, 10);
     //Assert.AreEqual(API.wrap_StdDeck_MASK(10), mask);
     Debug.Assert(mask.mask == API.wrap_StdDeck_MASK(10).mask);
 }
Example #2
0
 public void TestPokenum()
 {
   StdDeck.CardMask pocket1 = new StdDeck.CardMask();
   pocket1.Set("As");
   pocket1.Set("Ac");
   StdDeck.CardMask pocket2 = new StdDeck.CardMask();
   pocket2.Set("Qs");
   pocket2.Set("Qc");
   StdDeck.CardMask[] pockets = {pocket1, pocket2};
   StdDeck.CardMask board = new StdDeck.CardMask();
   board.Set("Ks");
   board.Set("Kc");
   board.Set("Kh");
   StdDeck.CardMask dead = new StdDeck.CardMask();
   dead.Set("As");
   dead.Set("Ac");
   dead.Set("Qs");
   dead.Set("Qc");
   dead.Set("Ks");
   dead.Set("Kc");
   dead.Set("Kh");
   int npockets = 2;
   int nboard = 3;
   int niter = 1;
   int orderflag = 0;
   EnumResult result = Enum.Sample(Game.holdem, pockets, board, dead, npockets, nboard, niter, orderflag);
   result.Print(pockets, board);
 }
Example #3
0
        static public EnumResult Sample(Game game, StdDeck.CardMask[] pockets, StdDeck.CardMask board, StdDeck.CardMask dead, int npockets, int nboard, int niter, int orderflag)
        {
            EnumResult result = new EnumResult();

            API.enumSample(game, pockets, board, dead, npockets, nboard, niter, orderflag, ref result);
            return(result);
        }
Example #4
0
        public void TestPokenum()
        {
            StdDeck.CardMask pocket1 = new StdDeck.CardMask();
            pocket1.Set("As");
            pocket1.Set("Ac");
            StdDeck.CardMask pocket2 = new StdDeck.CardMask();
            pocket2.Set("Qs");
            pocket2.Set("Qc");
            StdDeck.CardMask[] pockets = { pocket1, pocket2 };
            StdDeck.CardMask   board   = new StdDeck.CardMask();
            board.Set("Ks");
            board.Set("Kc");
            board.Set("Kh");
            StdDeck.CardMask dead = new StdDeck.CardMask();
            dead.Set("As");
            dead.Set("Ac");
            dead.Set("Qs");
            dead.Set("Qc");
            dead.Set("Ks");
            dead.Set("Kc");
            dead.Set("Kh");
            int        npockets  = 2;
            int        nboard    = 3;
            int        niter     = 1;
            int        orderflag = 0;
            EnumResult result    = Enum.Sample(Game.holdem, pockets, board, dead, npockets, nboard, niter, orderflag);

            result.Print(pockets, board);
        }
Example #5
0
 public void TestEnumResult()
 {
   EnumResult result = new EnumResult();
   result.Clear();
   StdDeck.CardMask[] pockets = {};
   StdDeck.CardMask board = new StdDeck.CardMask();
   result.Print(pockets, board);
 }
Example #6
0
 public void Test_wrap_StdDeck_CardMask_NOT()
 {
     StdDeck.CardMask spades = API.wrap_StdDeck_CardMask_RESET();
     spades = API.wrap_StdDeck_CardMask_SET_SPADES(spades, 11);
     StdDeck.CardMask cm = API.wrap_StdDeck_CardMask_NOT(spades);
     //Assert.AreEqual(~11 & ((1 << 13) - 1), API.wrap_StdDeck_CardMask_SPADES(cm));
     Debug.Assert((~11 & ((1 << 13) - 1)) == API.wrap_StdDeck_CardMask_SPADES(cm));
 }
Example #7
0
        public void TestEnumResult()
        {
            EnumResult result = new EnumResult();

            result.Clear();
            StdDeck.CardMask[] pockets = { };
            StdDeck.CardMask   board   = new StdDeck.CardMask();
            result.Print(pockets, board);
        }
Example #8
0
 public void Test_wrap_StdDeck_CardMask_IS_EMPTY()
 {
     StdDeck.CardMask mask = API.wrap_StdDeck_CardMask_RESET();
     //Assert.AreEqual(1, API.wrap_StdDeck_CardMask_IS_EMPTY(mask));
     Debug.Assert(1 == API.wrap_StdDeck_CardMask_IS_EMPTY(mask));
     mask = API.wrap_StdDeck_CardMask_SET(mask, 12);
     //Assert.AreEqual(0, API.wrap_StdDeck_CardMask_IS_EMPTY(mask));
     Debug.Assert(0 == API.wrap_StdDeck_CardMask_IS_EMPTY(mask));
 }
Example #9
0
 public void TestCardMask()
 {
   int card = StdDeck.StringToCard("As");
   StdDeck.CardMask mask = new StdDeck.CardMask();
   mask = API.wrap_StdDeck_CardMask_SET(mask, card);
   card = StdDeck.StringToCard("Ac");
   mask = API.wrap_StdDeck_CardMask_SET(mask, card);
   mask = API.wrap_StdDeck_CardMask_RESET();
   Assert.AreEqual(0, mask.mask);
 }
Example #10
0
 public void Test_wrap_StdDeck_CardMask_XOR()
 {
     StdDeck.CardMask spades1 = API.wrap_StdDeck_CardMask_RESET();
     StdDeck.CardMask spades2 = API.wrap_StdDeck_CardMask_RESET();
     spades1 = API.wrap_StdDeck_CardMask_SET_SPADES(spades1, 7);
     spades2 = API.wrap_StdDeck_CardMask_SET_SPADES(spades2, 1);
     StdDeck.CardMask cm = API.wrap_StdDeck_CardMask_XOR(spades1, spades2);
     //Assert.AreEqual(6, API.wrap_StdDeck_CardMask_SPADES(cm));
     Debug.Assert(6 == API.wrap_StdDeck_CardMask_SPADES(cm));
 }
Example #11
0
 public void Test_wrap_StdDeck_CardMask_SET_SPADES()
 {
     StdDeck.CardMask cm = API.wrap_StdDeck_CardMask_RESET();
     for (int i = 0; i < (1 << 13) - 1; ++i)
     {
         cm = API.wrap_StdDeck_CardMask_SET_SPADES(cm, i);
         int bit = API.wrap_StdDeck_CardMask_SPADES(cm);
         //Assert.AreEqual(i, bit);
         Debug.Assert(bit == i);
     }
 }
Example #12
0
        public void TestCardMask()
        {
            int card = StdDeck.StringToCard("As");

            StdDeck.CardMask mask = new StdDeck.CardMask();
            mask = API.wrap_StdDeck_CardMask_SET(mask, card);
            card = StdDeck.StringToCard("Ac");
            mask = API.wrap_StdDeck_CardMask_SET(mask, card);
            mask = API.wrap_StdDeck_CardMask_RESET();
            Assert.AreEqual(0, mask.mask);
        }
Example #13
0
 public void Test_wrap_StdDeck_CardMask_OR()
 {
     StdDeck.CardMask hearts = API.wrap_StdDeck_CardMask_RESET();
     StdDeck.CardMask spades = API.wrap_StdDeck_CardMask_RESET();
     spades = API.wrap_StdDeck_CardMask_SET_SPADES(spades, 11);
     hearts = API.wrap_StdDeck_CardMask_SET_HEARTS(hearts, 12);
     StdDeck.CardMask cm = API.wrap_StdDeck_CardMask_OR(spades, hearts);
     //Assert.AreEqual(11, API.wrap_StdDeck_CardMask_SPADES(cm));
     Debug.Assert(11 == API.wrap_StdDeck_CardMask_SPADES(cm));
     //Assert.AreEqual(12, API.wrap_StdDeck_CardMask_HEARTS(cm));
     Debug.Assert(11 == API.wrap_StdDeck_CardMask_HEARTS(cm));
 }
Example #14
0
 public void Test_wrap_StdDeck_CardMask_EQUAL()
 {
     StdDeck.CardMask one = API.wrap_StdDeck_CardMask_RESET();
     StdDeck.CardMask two = API.wrap_StdDeck_CardMask_RESET();
     one = API.wrap_StdDeck_CardMask_SET(one, 12);
     one = API.wrap_StdDeck_CardMask_SET(one, 13);
     two = API.wrap_StdDeck_CardMask_SET(two, 12);
     //Assert.AreEqual(0, API.wrap_StdDeck_CardMask_EQUAL(one, two));
     Debug.Assert(0 == API.wrap_StdDeck_CardMask_EQUAL(one, two));
     two = API.wrap_StdDeck_CardMask_SET(two, 13);
     //Assert.AreEqual(1, API.wrap_StdDeck_CardMask_EQUAL(one, two));
     Debug.Assert(1 == API.wrap_StdDeck_CardMask_EQUAL(one, two));
 }
Example #15
0
 public void Test_wrap_StdDeck_CardMask_SPADES()
 {
     for (int i = 0; i < 39; ++i)
     {
         StdDeck.CardMask card = API.wrap_StdDeck_MASK(i);
         int bit = API.wrap_StdDeck_CardMask_SPADES(card);
         //Assert.AreEqual(0, bit);
         Debug.Assert(bit == 0);
     }
     for (int i = 39; i < 52; ++i)
     {
         StdDeck.CardMask card = API.wrap_StdDeck_MASK(i);
         int bit = API.wrap_StdDeck_CardMask_SPADES(card);
         //Assert.AreEqual(1 << (i - 39), bit);
         Debug.Assert(bit == (1 << (i - 39)));
     }
 }
Example #16
0
 public void Test_wrap_StdDeck_CardMask_ANY_SET()
 {
     StdDeck.CardMask mask = API.wrap_StdDeck_CardMask_RESET();
     mask = API.wrap_StdDeck_CardMask_SET(mask, 10);
     mask = API.wrap_StdDeck_CardMask_SET(mask, 11);
     mask = API.wrap_StdDeck_CardMask_SET(mask, 12);
     StdDeck.CardMask ok = API.wrap_StdDeck_CardMask_RESET();
     ok = API.wrap_StdDeck_CardMask_SET(ok, 11);
     ok = API.wrap_StdDeck_CardMask_SET(ok, 12);
     ok = API.wrap_StdDeck_CardMask_SET(ok, 13);
     //Assert.AreEqual(1, API.wrap_StdDeck_CardMask_ANY_SET(mask, ok));
     Debug.Assert(1 == API.wrap_StdDeck_CardMask_ANY_SET(mask, ok));
     StdDeck.CardMask ko = API.wrap_StdDeck_CardMask_RESET();
     ko = API.wrap_StdDeck_CardMask_SET(ko, 13);
     //Assert.AreEqual(0, API.wrap_StdDeck_CardMask_ANY_SET(mask, ko));
     Debug.Assert(0 == API.wrap_StdDeck_CardMask_ANY_SET(mask, ko));
 }
Example #17
0
 public void Test_wrap_StdDeck_CardMask_HEARTS()
 {
     for (int i = 0; i < 13; ++i)
     {
         StdDeck.CardMask card = API.wrap_StdDeck_MASK(i);
         int bit = API.wrap_StdDeck_CardMask_HEARTS(card);
         //Assert.AreEqual(1 << i, bit);
         Debug.Assert(bit == 1 << i);
     }
     for (int i = 13; i < 52; ++i)
     {
         StdDeck.CardMask card = API.wrap_StdDeck_MASK(i);
         int bit = API.wrap_StdDeck_CardMask_HEARTS(card);
         //Assert.AreEqual(0, bit);
         Debug.Assert(bit == 0);
     }
 }
Example #18
0
 public void Test_wrap_StdDeck_CardMask_DIAMONDS()
 {
     for (int i = 0; i < 13; ++i)
     {
         StdDeck.CardMask card = API.wrap_StdDeck_MASK(i);
         int bit = API.wrap_StdDeck_CardMask_DIAMONDS(card);
         //Assert.AreEqual(0, bit);
         Debug.Assert(bit == 0);
     }
     for (int i = 13; i < 26; ++i)
     {
         StdDeck.CardMask card = API.wrap_StdDeck_MASK(i);
         int bit = API.wrap_StdDeck_CardMask_DIAMONDS(card);
         //Assert.AreEqual(1 << (i - 13), bit);
         Debug.Assert(bit == 1 << (i - 13));
     }
     for (int i = 39; i < 52; ++i)
     {
         StdDeck.CardMask card = API.wrap_StdDeck_MASK(i);
         int bit = API.wrap_StdDeck_CardMask_DIAMONDS(card);
         //Assert.AreEqual(0, bit);
         Debug.Assert(bit == 0);
     }
 }
Example #19
0
 public static extern StdDeck.CardMask wrap_StdDeck_CardMask_NOT(StdDeck.CardMask cm);
Example #20
0
 public static extern int enumSample(Game game, StdDeck.CardMask[] pockets,
                                     StdDeck.CardMask board, StdDeck.CardMask dead,
                                     int npockets, int nboard, int niter, int orderflag,
                                     ref EnumResult result);
Example #21
0
 public static extern int wrap_StdDeck_CardMask_IS_EMPTY(StdDeck.CardMask mask);
Example #22
0
 public static extern StdDeck.CardMask wrap_StdDeck_CardMask_XOR(StdDeck.CardMask op1, StdDeck.CardMask op2);
Example #23
0
 public void Print(StdDeck.CardMask[] pockets, StdDeck.CardMask board)
 {
     API.enumResultPrint(ref this, pockets, board);
 }
Example #24
0
 public static extern void enumResultPrintTerse(ref EnumResult result,
                                                StdDeck.CardMask[] pockets,
                                                StdDeck.CardMask board);
Example #25
0
 public static extern int wrap_StdDeck_CardMask_ANY_SET(StdDeck.CardMask mask1, StdDeck.CardMask mask2);
Example #26
0
 public void Test_wrap_StdDeck_CardMask_RESET()
 {
     StdDeck.CardMask mask = API.wrap_StdDeck_CardMask_RESET();
     //Assert.AreEqual(0, mask.mask);
     Debug.Assert(0 == mask.mask);
 }
Example #27
0
 public void Test_wrap_StdDeck_Mask()
 {
     long[] cardMasksTable =
     {
         0x0001000000000000L,
         0x0002000000000000L,
         0x0004000000000000L,
         0x0008000000000000L,
         0x0010000000000000L,
         0x0020000000000000L,
         0x0040000000000000L,
         0x0080000000000000L,
         0x0100000000000000L,
         0x0200000000000000L,
         0x0400000000000000L,
         0x0800000000000000L,
         0x1000000000000000L,
         0x0000000100000000L,
         0x0000000200000000L,
         0x0000000400000000L,
         0x0000000800000000L,
         0x0000001000000000L,
         0x0000002000000000L,
         0x0000004000000000L,
         0x0000008000000000L,
         0x0000010000000000L,
         0x0000020000000000L,
         0x0000040000000000L,
         0x0000080000000000L,
         0x0000100000000000L,
         0x0000000000010000L,
         0x0000000000020000L,
         0x0000000000040000L,
         0x0000000000080000L,
         0x0000000000100000L,
         0x0000000000200000L,
         0x0000000000400000L,
         0x0000000000800000L,
         0x0000000001000000L,
         0x0000000002000000L,
         0x0000000004000000L,
         0x0000000008000000L,
         0x0000000010000000L,
         0x0000000000000001L,
         0x0000000000000002L,
         0x0000000000000004L,
         0x0000000000000008L,
         0x0000000000000010L,
         0x0000000000000020L,
         0x0000000000000040L,
         0x0000000000000080L,
         0x0000000000000100L,
         0x0000000000000200L,
         0x0000000000000400L,
         0x0000000000000800L,
         0x0000000000001000L
     };
     for (int i = 0; i < cardMasksTable.Length; ++i)
     {
         StdDeck.CardMask card = API.wrap_StdDeck_MASK(i);
         //Assert.AreEqual(cardMasksTable[i], card.mask);
         Debug.Assert(cardMasksTable[i] == card.mask);
     }
 }
Example #28
0
 public static extern int wrap_StdDeck_CardMask_CARD_IS_SET(StdDeck.CardMask mask, int index);
Example #29
0
 public static extern StdDeck.CardMask wrap_StdDeck_CardMask_SET_DIAMONDS(StdDeck.CardMask cm, int ranks);
Example #30
0
 public static extern StdDeck.CardMask wrap_StdDeck_CardMask_SET_SPADES(StdDeck.CardMask cm, int ranks);
Example #31
0
 public static extern StdDeck.CardMask wrap_StdDeck_CardMask_UNSET(StdDeck.CardMask mask, int index);
Example #32
0
 public static extern int wrap_StdDeck_CardMask_HEARTS(StdDeck.CardMask cm);
Example #33
0
 public static extern int wrap_StdDeck_CardMask_EQUAL(StdDeck.CardMask mask1, StdDeck.CardMask mask2);