Форум программистов, компьютерный форум CyberForum.ru

Покер - C++

Восстановить пароль Регистрация
 
 
Рейтинг: Рейтинг темы: голосов - 21, средняя оценка - 4.95
vlad_light
4 / 4 / 0
Регистрация: 24.09.2012
Сообщений: 178
10.05.2013, 18:57     Покер #1
Хочу написать простенькую покерную программу на с++. Нужна помощь с архитектурой. Напишите, пожалуйста, какие классы стоит реализовать. Спасибо!
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
10.05.2013, 18:57     Покер
Посмотрите здесь:

C++ Задача Покер
Задача Покер C++
Моделирование игры в покер C++
C++ Проверка на стрит(покер)
Программа для игры в покер C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
vlad_light
4 / 4 / 0
Регистрация: 24.09.2012
Сообщений: 178
12.05.2013, 01:38  [ТС]     Покер #2
Вот что я пока придумал...
Классы:
- карта // объектами будут карты
- колода // состоит из набора карт
- игрок // хранит данные о фишках, возможных ходах и т.п.
- стол // хранит информацию об игроках, текущем ходе, банке и т.п.
- ИИ // н.к.
Подскажите, пожалуйста, что добавить/убрать. После выложу прототипы классов. И ещё неплохо бы заранее придумать, как определть выиграшную комбинацию. Где об этом можно почитать по-подробнее?
Заранее спасибо!
Silvestr1994
 Аватар для Silvestr1994
27 / 27 / 1
Регистрация: 26.10.2012
Сообщений: 101
12.05.2013, 02:20     Покер #3
вот примеры:
вот тут с классами
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
/****************************************************************************/
/*                A simple Texas Hold'em Poker simulartion.                 */
/*                Program runs fine, but gameplay still has some bugs.      */
/*                Contact: [email]danielscocco@gmail.com[/email]                           */
/*                                                                          */
/****************************************************************************/
 
#include <iostream>
#include <iomanip>
#include <string>
#include <cstdlib>
#include <ctime>
using namespace std;
 
string suits[4];
string ranks[13];
 
class Card{
    public:
    int suit;
    int rank;
};
 
int compareCards(const void *card1, const void *card2){
    return (*(Card *)card1).rank - (*(Card *)card2).rank;
}
 
class Deck{
    public:
        Deck(){
            for (int i=0;i<4;i++){
                for (int j=0;j<13;j++){
                    cards[i*13+j].suit = i;
                    cards[i*13+j].rank = j;
                }
            }
            suits[0] = "D";
            suits[1] = "S";
            suits[2] = "H";
            suits[3] = "C";
            ranks[0] = "2";
            ranks[1] = "3";
            ranks[2] = "4";
            ranks[3] = "5";
            ranks[4] = "6";
            ranks[5] = "7";
            ranks[6] = "8";
            ranks[7] = "9";
            ranks[8] = "T";
            ranks[9] = "J";
            ranks[10] = "Q";
            ranks[11] = "K";
            ranks[12] = "A";
        }
 
        void print(){
            cout << "Printing the deck..." << endl;
            sleep(1);
            for (int i=0;i<52;i++)
                cout << ranks[cards[i].rank] << suits[cards[i].suit] << endl;
            cout << endl;
        }
 
        void shuffle(){
            top = 51;
            int x;
            Card tempCard;
            for (int i=0;i<4;i++){
                for (int j=0;j<13;j++){
                    cards[i*13+j].suit = i;
                    cards[i*13+j].rank = j;
                }
            }
            cout << "Shuffling the cards and dealing..." << endl << endl;
            sleep(2);
            for (int i=0;i<52;i++){
                x = rand() % 52;
                tempCard = cards[i];
                cards[i] = cards[x];
                cards[x] = tempCard;
            }
        }
 
        Card hitme(){
            top--;
            return cards[top+1];
        }
 
    private:
    int top;
    Card cards[52];
};
 
class Player{
    public:
    string name;
    int money;
    Card cards[2];
    int playing;
    int round;
    int goodToGo;
};
 
class PokerGame{
    public:
        void start(string name){
            for (int i = 0;i < 6; i++){
                players[i].money = 1000;
                players[i].playing = 1;
            }
            players[0].name = "Carlos";
            players[1].name = "Carla";
            players[2].name =  "Nick";
            players[3].name = "Lisa";
            players[4].name = name;
            players[5].name = "Soarez";
            startGame();
        }
 
 
        void deal(){
            for (int i=0;i<6;i++){
                for (int j=0;j<2;j++){
                    if (players[i].playing){
                        players[i].cards[j] = deck1.hitme();
                    }
                }
            }
            for (int i=0;i<5;i++)
                tableCards[i].rank=-1;
        }
 
        void flop(){
            for (int i=0;i<3;i++)
                tableCards[i] = deck1.hitme();
        }
 
        void turn(){
            tableCards[3] = deck1.hitme();
        }
 
        void river(){
            tableCards[4] = deck1.hitme();
        }
 
        void printTable(){
            cout << "  " << ((players[0].playing) ? (players[0].name) : "      ") << "         " << ((players[1].playing) ? (players[1].name) : "     ") << "           "
            << ((players[2].playing) ? (players[2].name) : "    ") << endl;
            cout << "   $" << setw(4) << ((players[0].playing) ? (players[0].money) : 0) << "         $" << setw(4) << ((players[1].playing) ? (players[1].money) : 0)
            << "           $" << setw(4) << ((players[2].playing) ? (players[2].money) : 0) << endl;
            cout << "     _____________________________" << endl;
            cout << "    / " << ((bind==0) ? "@":" ") << "            " << ((bind==1) ? "@":" ") << "            " << ((bind==2) ? "@":" ") << " \\" << endl;
            cout << "   /  ___   ___   ___   ___   ___  \\" << endl;
            cout << "   | | " << ((tableCards[0].rank)>=0 ? ranks[tableCards[0].rank] : " ") << " | | " << ((tableCards[1].rank)>=0 ? ranks[tableCards[1].rank] : " ") << " | | " << ((tableCards[2].rank)>=0 ? ranks[tableCards[2].rank] : " ") << " | | "
            << ((tableCards[3].rank)>=0 ? ranks[tableCards[3].rank] : " ") << " | | " << ((tableCards[4].rank)>=0 ? ranks[tableCards[4].rank] : " ") << " | |" << endl;
            cout << "   | | " << ((tableCards[0].rank)>=0 ? suits[tableCards[0].suit] : " ") << " | | " << ((tableCards[1].rank)>=0 ? suits[tableCards[1].suit] : " ") << " | | " << ((tableCards[2].rank)>=0 ? suits[tableCards[2].suit] : " ") << " | | "
            << ((tableCards[3].rank)>=0 ? suits[tableCards[3].suit] : " ") << " | | " << ((tableCards[4].rank)>=0 ? suits[tableCards[4].suit] : " ") << " | |" << endl;
            cout << "   | |___| |___| |___| |___| |___| |" << endl;
            cout << "   |                               |" << endl;
            cout << "   |          Pot = $" << setw(4) << pot << "         |" << endl;
            cout << "   \\                               /" << endl;
            cout << "    \\_" << ((bind==5) ? "@":"_") << "_____________" << ((bind==4) ? "@":"_") << "___________" << ((bind==3) ? "@":"_") << "_/" << endl;
            cout << endl;
            cout << "  " << ((players[5].playing) ? (players[5].name) : "      ") << "          " << ((players[4].playing) ? (players[4].name) : "      ") << "         "
            << ((players[3].playing) ? (players[3].name) : "    ") << endl;
            cout << "   $" << setw(4) << ((players[5].playing) ? (players[5].money) : 0) << "          $" << setw(4) << ((players[4].playing) ? (players[4].money) : 0)
            << "         $" << setw(4) << ((players[3].playing) ? (players[3].money) : 0) << endl;
            cout << endl;
            if (players[4].round){
                cout << "   Your hand:" << endl;
                cout << "    ___    ___" << endl;
                cout << "   | " << ranks[players[4].cards[0].rank] << " |  | " << ranks[players[4].cards[1].rank] << " |" << endl;
                cout << "   | " << suits[players[4].cards[0].suit] << " |  | " << suits[players[4].cards[1].suit] << " |" << endl;
                cout << "   |___|  |___|" << endl << endl;
            }
            sleep(3);
        }
 
    private:
        Player players[6];
        Deck deck1;
        int bind;
        Card tableCards[5];
        int pot,action,bet,rational,betOn,winner,maxPoints,roundWinner;
        int handPoints[6];
        int bestHand[6][3];
 
        int playersLeft(){
            int count = 0;
            for (int i = 0; i < 6; i++)
                if (players[i].money>0)
                    count++;
            return count;
        }
 
        int computerAction(int playerNum){
            if (players[playerNum].cards[0].rank < 8 && players[playerNum].cards[1].rank < 8){
                if (players[playerNum].cards[0].rank!=players[playerNum].cards[1].rank)
                    return 0;
                else
                    return 1;
            }
 
            else if (players[playerNum].cards[0].rank < 10 && players[playerNum].cards[1].rank < 10){
                if (players[playerNum].cards[0].rank!=players[playerNum].cards[1].rank)
                    return 1;
                else
                    return 2;
            }
            else{
                return 2;
            }
        }
 
        /*checks if someone still got bet/call*/
        int playersToBet(){
            for (int i = 0;i<6;i++)
                if (players[i].round==1&&players[i].goodToGo==0)
                    return 1;
 
            return 0;
        }
 
        void takeBets(){
            betOn = 0;
            for (int k=0;k<6;k++)
                players[k].goodToGo = 0;
 
            for (int k=bind+1;k<bind+7;k++){
                /* human player actions */
                if (k%6==4&&players[4].round){
                    if (betOn){
                        cout << "Your action: (1) FLOP (3) BET/CALL ";
                        cin >> action;
                        while (action!=1&&action!=3){
                            cout << "Invalid number pressed." << endl;
                            cout << "Your action: (1) FLOP (3) BET/CALL ";
                            cin >> action;
                        }
                    }
                    else{
                        cout << "Your action: (1) FLOP (2) CHECK (3) BET/CALL ";
                        cin >> action;
                        while (action<1||action>3){
                            cout << "Invalid number pressed." << endl;
                            cout << "Your action: (1) FLOP (2) CHECK (3) BET/CALL ";
                            cin >> action;
                        }
                    }
                    cout << endl;
                    if (action==1)
                        players[4].round = 0;
                    else if(action==2)
                        continue;
                    else{
                        if (betOn){
                            pot+=betOn;
                            players[4].money-=betOn;
                            players[4].goodToGo = 1;
                        }
                        else{
                            cout << "How much do you want to bet: ";
                            cin >> bet;
                            while (bet>players[4].money||bet<1){
                                cout << "Invalid number to bet." << endl;
                                cout << "How much do you want to bet: ";
                                cin >> bet;
                                cout << endl << endl;
                            }
                            pot+=bet;
                            players[4].money-=bet;
                            betOn = bet;
                            players[4].goodToGo = 1;
                        }
                    }
                }
 
                /* computers actions */
                else{
                    if (players[k%6].round==0)
                        continue;
                    rational = rand() % 2;
                    if (rational){
                        action = computerAction(k%6);
                    }
                    else{
                        action = rand() % 3;
                    }
                    if (action==0){
                        players[k%6].round=0;
                        cout << players[k%6].name << " flops..." << endl << endl;
                    }
                    else if (action==1&&betOn==0){
                        cout << players[k%6].name << " checks." << endl << endl;
                        continue;
                    }
                    else{
                        if (betOn){
                            pot+=betOn;
                            players[k%6].money -= betOn;
                            cout << players[k%6].name << " calls!" << endl << endl;
                            players[k%6].goodToGo = 1;
                        }
                        else{
                            bet = (rand() % (players[k%6].money / 3) + 10;
                            pot+=bet;
                            players[k%6].money -= bet;
                            cout << '\a';
                            cout << players[k%6].name << " bets " << bet << endl << endl;
                            betOn = bet;
                            players[k%6].goodToGo = 1;
                        }
                    }
                    sleep(1);
                }
            }
 
            if (betOn&&playersToBet()){
                for (int k=bind+1;k<bind+7;k++){
                    if (k%6==4){
                        if (players[4].round&&players[4].goodToGo==0){
                            cout << "Your action: (1) FLOP (3) BET/CALL ";
                            cin >> action;
                            while (action!=1&&action!=3){
                                cout << "Invalid number pressed." << endl;
                                cout << "Your action: (1) FLOP (3) BET/CALL ";
                                cin >> action;
                                cout << endl << endl;
                            }
                            if (action==1)
                                players[4].round = 0;
                            else{
                                pot+=betOn;
                                players[4].money-=betOn;
                                players[4].goodToGo = 1;
                            }
                        }
                    }
 
                    else{
                        if (players[k%6].round==0||players[k%6].goodToGo==1)
                            continue;
                        action = rand() % 2;
                        if (action==0){
                            players[k%6].round=0;
                            cout << players[k%6].name << " flops..." << endl << endl;
                        }
                        else{
                            pot+=betOn;
                            players[k%6].money -= betOn;
                            cout << players[k%6].name << " calls!" << endl << endl;
                            players[k%6].goodToGo = 1;
                        }
                    }
                }
            }
        }
 
        int oneLeft(){
            int count = 0;
            for (int k=0;k<6;k++)
                if (players[k].round)
                    count++;
            if (count==1)
                return 1;
            else
                return 0;
        }
 
        int getWinner(){
            int winner;
            for (int k=0;k<6;k++)
                if (players[k].round)
                    winner = k;
            return winner;
        }
 
        int getScore(Card hand[]){
            qsort(hand,5,sizeof(Card),compareCards);
            int straight,flush,three,four,full,pairs,high;
            int k;
 
            straight = flush = three = four = full = pairs = high = 0;
            k = 0;
 
            /*checks for flush*/
            while (k<4&&hand[k].suit==hand[k+1].suit)
                k++;
            if (k==4)
                flush = 1;
 
            /* checks for straight*/
            k=0;
            while (k<4&&hand[k].rank==hand[k+1].rank-1)
                k++;
            if (k==4)
                straight = 1;
 
            /* checks for fours */
            for (int i=0;i<2;i++){
                k = i;
                while (k<i+3&&hand[k].rank==hand[k+1].rank)
                    k++;
                if (k==i+3){
                    four = 1;
                    high = hand[i].rank;
                }
            }
 
            /*checks for threes and fullhouse*/
            if (!four){
                for (int i=0;i<3;i++){
                    k = i;
                    while (k<i+2&&hand[k].rank==hand[k+1].rank)
                        k++;
                    if (k==i+2){
                        three = 1;
                        high=hand[i].rank;
                        if (i==0){
                            if (hand[3].rank==hand[4].rank)
                                full=1;
                        }
                        else if(i==1){
                            if (hand[0].rank==hand[4].rank)
                                full=1;
                        }
                        else{
                            if (hand[0].rank==hand[1].rank)
                                full=1;
                        }
                    }
                }
            }
 
            if (straight&&flush)
                return 170 + hand[4].rank;
            else if(four)
                return 150 + high;
            else if(full)
                return 130 + high;
            else if(flush)
                return 110;
            else if(straight)
                return 90 + hand[4].rank;
            else if(three)
                return 70 + high;
 
            /* checks for pairs*/
            for (k=0;k<4;k++)
                if (hand[k].rank==hand[k+1].rank){
                    pairs++;
                    if (hand[k].rank>high)
                        high = hand[k].rank;
                }
 
            if (pairs==2)
                return 50 + high;
            else if(pairs)
                return 30 + high;
            else
                return hand[4].rank;
        }
 
        int tryHand(int array[],int player){
            Card hand[5];
 
            /* get cards from table and player */
            for (int i=1;i<4;i++)
                hand[i-1] = tableCards[array[i]];
 
            for (int i=0;i<2;i++)
                hand[i+3] = players[player].cards[i];
 
            return getScore(hand);
 
        }
 
        void evaluateHands(){
            int stack[10],k;
            int currentPoints;
 
            for (int q=0;q<6;q++){
                if (players[q].round){
                    stack[0]=-1; /* -1 is not considered as part of the set */
                    k = 0;
                    while(1){
                        if (stack[k]<4){
                            stack[k+1] = stack[k] + 1;
                            k++;
                        }
 
                        else{
                            stack[k-1]++;
                            k--;
                        }
 
                        if (k==0)
                            break;
 
                        if (k==3){
                            currentPoints = tryHand(stack,q);
                            if (currentPoints>handPoints[q]){
                                handPoints[q] = currentPoints;
                                for (int x=0;x<3;x++)
                                    bestHand[q][x] = stack[x+1];
                            }
                        }
                    }
 
                }
            }
        } /*end of evaluateHands() */
 
        void printWinningHand(int winner){
            Card winningHand[5];
            for (int i=0;i<3;i++)
                winningHand[i] = tableCards[bestHand[winner][i]];
 
            for (int i=0;i<2;i++)
                winningHand[i+3] = players[winner].cards[i];
 
            qsort(winningHand,5,sizeof(Card),compareCards);
 
            cout << "   The winning hand:" << endl;
            cout << "   ___   ___   ___   ___   ___" << endl;
            cout << "  | " << ranks[winningHand[0].rank] << " | | " << ranks[winningHand[1].rank] << " | | " << ranks[winningHand[2].rank] << " | | " << ranks[winningHand[3].rank] << " | | " << ranks[winningHand[4].rank] << " |" << endl;
            cout << "  | " << suits[winningHand[0].suit] << " | | " << suits[winningHand[1].suit] << " | | " << suits[winningHand[2].suit] << " | | " << suits[winningHand[3].suit] << " | | " << suits[winningHand[4].suit] << " |" << endl;
            cout << "  |___| |___| |___| |___| |___|" << endl;
            cout << endl << endl;
            sleep(3);
        }
 
        /* main gameplay function*/
        void startGame(){
            int i = 0;
 
            while(playersLeft()>1){
                /* starting default values*/
                for (int z=0;z<6;z++)
                    if (players[z].money<1){
                        players[z].playing = 0;
                        players[z].round = 0;
                    }
                for (int z=0;z<6;z++){
                    if (players[z].playing)
                        players[z].round = 1;
                    handPoints[z]=-1;
                }
                for (int x=0;x<6;x++){
                    for (int y=0;y<3;y++){
                        bestHand[x][y] = -1;
                    }
                }
 
                /* checking for game over*/
                if(players[4].playing==0){
                    cout << "You are out of money, sorry." << endl;
                    cout << "Game over." << endl;
                    break;
                }
 
                bind = i % 6;
 
                /* paying bind */
                pot = 20;
                if (players[bind].money>=20)
                    players[bind].money-=20;
                else
                    players[bind].playing = 0;
 
                cout << "Get ready for round " << (i+1) << "..." << endl;
                sleep(1);
                deck1.shuffle();
 
                /* pre-flop */
                deal();
                printTable();
                takeBets();
                if (oneLeft()){
                    winner = getWinner();
                    cout << players[winner].name << " wins $" << pot << endl << endl;
                    i++;
                    continue;
                }
 
                /* flop */
                flop();
                cout << endl;
                printTable();
                takeBets();
                if (oneLeft()){
                    winner = getWinner();
                    cout << players[winner].name << " wins $" << pot << endl << endl;
                    i++;
                    continue;
                }
 
                /* turn */
                turn();
                cout << endl;
                printTable();
                takeBets();
                if (oneLeft()){
                    winner = getWinner();
                    cout << players[winner].name << " wins $" << pot << endl << endl;
                    i++;
                    continue;
                }
 
                /* river */
                river();
                cout << endl;
                printTable();
                takeBets();
 
                evaluateHands();
 
                /*find and declare round winner*/
                maxPoints = 0;
                for (int q=0;q<6;q++){
                    if(players[q].round){
                        if (handPoints[q]>maxPoints){
                            maxPoints = handPoints[q];
                            roundWinner = q;
                        }
                    }
                }
                cout << endl;
                cout << players[roundWinner].name << " wins $" << pot << " with ";
                if (maxPoints<30)
                    cout << "HIGH CARD";
                else if (maxPoints<50)
                    cout << "SINGLE PAIR";
                else if (maxPoints<70)
                    cout << "TWO PAIRS";
                else if (maxPoints<90)
                    cout << "THREE OF A KIND";
                else if(maxPoints<110)
                    cout << "STRAIGHT";
                else if(maxPoints<130)
                    cout << "FLUSH";
                else if(maxPoints<150)
                    cout << "FULL HOUSE";
                else if(maxPoints<170)
                    cout << "FOUR OF A KIND";
                else
                    cout << "STRAIGHT FLUSH";
                cout << endl << endl;
 
                printWinningHand(roundWinner);
 
                players[roundWinner].money+=pot;
 
                i++;
            }
        }
};
 
 
int main(){
    string name;
    PokerGame game1;
 
    srand(time(NULL));
 
    cout << "Welcome to..." << endl << endl;
    sleep(1);
    cout << "#######                        ###### " << endl;
    cout << "   #    ###### #    # #####    #     #  ####  #    # ###### #####" << endl;
    cout << "   #    #       #  #    #      #     # #    # #   #  #      #    #" << endl;
    cout << "   #    #####    ##     #      ######  #    # ####   #####  #    #" << endl;
    cout << "   #    #        ##     #      #       #    # #  #   #      #####" << endl;
    cout << "   #    #       #  #    #      #       #    # #   #  #      #   #" << endl;
    cout << "   #    ###### #    #   #      #        ####  #    # ###### #    #" << endl << endl;
 
    cout << "Please type your name: ";
 
    cin >> name;
 
    cout << "OK " << name << " let's play some poker!" << endl << endl;
    sleep(2);
 
    game1.start(name);
 
    return 0;
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include <iostream>
#include <cstdlib>
#include <string>
#include <ctime>
using namespace std;
 
int main()
{
    srand(time(0));
    int deck[52];
    int i;
    string suitnames[4]={"spades", "diamonds", "clubs", "hearts"};
    string ranknames[13]={"ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "jack", "queen", "king"};
 
    // create a new deck, with cards in order, but unique
    for(i=0; i<52; i++)
    {
        deck[i] = i;
    }
 
    // shuffle the deck:
    for(i=0; i<52; i++)
    {
        // generate a random index to swap with the card at index i.
        int j = rand() % 52;
        int temp = deck[i];
        deck[i] = deck[j];
        deck[j] = temp;
    }
 
 
    // print all the cards
    for(i=0; i<52; i++)
    {
        int suitnumber = deck[i] / 13; // 0 - 3
        int rank = deck[i] % 13;
        cout << ranknames[rank] << " of " << suitnames[suitnumber]<< "\n";
    }
 
    // Check first 5 cards for an ace
    cout << endl;
    for(i=0; i<5; i++)
    {
        int acerank = 0;
        int currentCardRank = deck[i]%13;
        if(currentCardRank == acerank)
        {
            cout << "Got an ace!" << endl;
        }
    }
 
    // Get the rank of the first 5 cards
    int R[5]; // = {4, 7, 6, 3, 5}; // rank of the first 5 cards
    int S[5];
    for(i=0; i<5; i++)
    {
        R[i] = deck[i]%13;
        S[i] = deck[i]/13;
    }
 
    // Sort the R array
    bool swapped = false;
    do
    {
        // 1 pass of the bubble sort
        swapped = false;
        for(int i=0; i<4; i++)
        {
            if(R[i] > R[i+1])
            {
                int temp = R[i];
                R[i] = R[i+1];
                R[i+1] = temp;
                swapped = true;
            }
        }
    }
    while(swapped == true);
 
    // print the sorted ranks and suits
    for(i=0; i<5; i++)
    {
        cout << ranknames[R[i]] << " of " << suitnames[S[i]]<< "\n";
    }
 
    // Check for a straight:
    if(R[1]==R[0]+1 && R[2]==R[1]+1 && R[3]==R[2]+1 && R[4]==R[3]+1)
    {
        cout << "You got a straight! (you must have cheated)" << endl;
    }
    else
    {
        cout << "No straight" << endl;
    }
 
    // Check first 5 cards for any pair
    if(R[0] == R[1] || R[1]==R[2] || R[2]==R[3] || R[3]==R[4])
    {
        cout << "You got a pair!" << endl;
    }
    else
    {
        cout << "No pair" << endl;
    }
 
    // Check for a flush (all the same suit)
    if(S[0] == S[1] && S[1]==S[2] && S[2]==S[3] && S[3]==S[4])
    {
        cout << "You got a flush!" << endl;
    }
    else
    {
        cout << "No flush" << endl;
    }
 
    // Check for straight flush
 
    // Check for 4 of a kind
 
    // Check for full house
 system("pause");
    return 0;
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
#include <iostream>
 
using namespace std;
char szBw[] = "Black Win";
char szWw[] = "White Win";
char szN[] = "Pit";
int nBStar1 =0;
int nBStar2= 0;
int nWStar1 = 0;
int nWStar2 = 0;
int nBStar3= 0;
int nWStar3 = 0;
 
int velichina (char v) {
    switch (v) {
        case 'T':
        return 10;
        case 'J':
        return 11;
        case 'Q':
        return 12;
        case 'K':
        return 13;
        case 'A':
        return 14;
    }
    return atoi(&v);
}
bool strit(char szRuka[15],int nWho) {
    int nVelich[5]={velichina(szRuka[0]),velichina(szRuka[3]),velichina(szRuka[6]),velichina(szRuka[9]),velichina(szRuka[12])};
    bool bImeetsa;
    int nPosled;
    for (int i=2;i<11;i++) {
        nPosled=0;
        for (int k=i;k<=(i+4);k++) {
            bImeetsa = 0;
            for (int z=0;z<5;z++) {
                 if(nVelich[z]==k) {
                     bImeetsa=1;
                 }
            }
            if(bImeetsa) {
                nPosled++;
            }else{
                break;
            }
        }
        if(nPosled==5)  {
            return 1;
        }
    }
    return 0;
}
bool flash(char szRuka[15],int nWho) {
    char szMast[6]={szRuka[1],szRuka[4],szRuka[7],szRuka[10],szRuka[13]};
    for (int i=0;i<5;i++) {
        if(szMast[i]!=szMast[0]) {
            return 0;
        }
    }
    return 1;
}
 
int kombinaziya (char szRuka[15],int nWho)  {
    bool nKolKomb=0;
    char szKarta;
    if(strit(szRuka,nWho) and flash(szRuka,nWho)) {
        return 8;
    }
    if(flash(szRuka,nWho)) {
        return 5;
    }
    if(strit(szRuka,nWho)) {
        return 4;
    }
    char szVelich[6]={szRuka[0],szRuka[3],szRuka[6],szRuka[9],szRuka[12]};
    int nInd=1;
    int nPomosh=0;
    for (int i=0;i<6;i++) {
        for (int b=i+1;b<6;b++) {
            if(szVelich[i]==szVelich[b] and szVelich[b] !='z') {
                szKarta = szVelich[i];
                szVelich[b]='z';
                nInd++;
            }
        }
        switch(nInd) {
            case 2:
            if (!nKolKomb) {
                if (nWho==0) {
                    nBStar1= velichina(szKarta);
                } else {
                    nWStar1= velichina(szKarta);
                }
                nKolKomb =1;
            }else{
                if (nWho==0) {
                    nBStar2= velichina(szKarta);
                } else {
                    nWStar2= velichina(szKarta);
                }
            }
            nPomosh +=2;
            break;
            case 3:
            if (nWho==0) {
                nBStar3= velichina(szKarta);
            } else {
                nWStar3= velichina(szKarta);
            }
            nKolKomb =1;
            nPomosh +=3;
            break;
            case 4:
            if (nWho==0) {
                nBStar1= velichina(szKarta);
            } else {
                nWStar1= velichina(szKarta);
            }
            nKolKomb =1;
            nPomosh +=4;
            break;
        }
        nInd=1;
    }
    switch(nPomosh) {
        case 2:
        return 1;
        case 4:
        if((nBStar2+nWStar2)==0) {
            return 8;
        }
        return 2;
        case 3:
        return 3;
        case 5:
        return 6;
    }
    return 0;
}
char* starshaya (char bRuka[15],char wRuka[15], int nKomb) {
    int nBlack[5] = {velichina(bRuka[0]),velichina(bRuka[3]),velichina(bRuka[6]),velichina(bRuka[9]),velichina(bRuka[12])};
    int nWhite[5] = {velichina(wRuka[0]),velichina(wRuka[3]),velichina(wRuka[6]),velichina(wRuka[9]),velichina(wRuka[12])};
    int bNaibolsh;
    int wNaibolsh;
    if (nKomb==1) {
        if (nBStar1>nWStar1) {
            return &szBw[0];
        }
        if (nBStar1<nWStar1) {
            return &szWw[0];
        }
        if (nBStar1==nWStar1) {
            nKomb=0;
        }
    }
    if (nKomb==2) {
        if (nBStar1<nBStar2) {
            nBStar1 = nBStar1 + nBStar2;
            nBStar2 = nBStar1 - nBStar2;
            nBStar1 = nBStar1 - nBStar2;
        }
        if (nWStar1<nWStar2) {
            nWStar1 = nWStar1 + nWStar2;
            nWStar2 = nWStar1 - nWStar2;
            nWStar1 = nWStar1 - nWStar2;
        }
        if (nBStar1>nWStar1) {
            return &szBw[0];
        }
        if (nBStar1<nWStar1) {
            return &szWw[0];
        }
        if (nBStar1==nWStar1) {
            if (nBStar2>nWStar2) {
                return &szBw[0];
            }
            if (nBStar2<nWStar2) {
                return &szWw[0];
            }
            if (nBStar2==nWStar2) {
                nKomb=0;
            }
        }
    }
    if (nKomb==3) {
        if (nBStar3>nWStar3) {
            return &szBw[0];
        }
        if (nBStar3<nWStar3) {
            return &szWw[0];
        }
    }
    if (nKomb==4 or nKomb==5 or nKomb==8) {
        nKomb=0;
    }
    if (nKomb==6) {
        if (nBStar3>nWStar3) {
            return &szBw[0];
        }
        if (nBStar3<nBStar3) {
            return &szWw[0];
        }
    }
    if (nKomb==7) {
        if (nBStar1>nWStar1) {
            return &szBw[0];
        }
        if (nBStar1<nWStar1) {
            return &szWw[0];
        }
        if (nBStar1==nWStar1) {
            return &szN[0];
        }
    }
    if (nKomb==0) {
        for (int c=0;c<5;c++) {
            bNaibolsh = nBlack[0] ;
            for (int i=0;i<5;i++) {
                if (nBlack[i]>bNaibolsh) {
                    bNaibolsh = nBlack[i];
                }
            }
            wNaibolsh = nWhite[0] ;
            for (int i=0;i<5;i++) {
                if (nWhite[i]>wNaibolsh) {
                    wNaibolsh = nWhite[i];
                }
            }
            if (bNaibolsh>wNaibolsh and bNaibolsh>1 and wNaibolsh>1) {
                return &szBw[0];
            }
            if (bNaibolsh<wNaibolsh and bNaibolsh>1 and wNaibolsh>1) {
                return &szWw[0];
            }
            for (int i=0;i<5;i++) {
                if(nWhite[i]==wNaibolsh) {
                    nWhite[i]=0;
                }
            }
            for (int i=0;i<5;i++) {
                if(nBlack[i]==bNaibolsh) {
                    nBlack[i]=0;
                }
            }
        }
    }
    return &szN[0];
}
 
int main()
{
    char szKarti[30];
    char szRukaBlack[15];
    char szRukaWhite[15];
    int nKombBlack;
    int nKombWhite;
    gets(szKarti);
 
    for(int i=0;i<15;i++) {
        szRukaBlack[i]=szKarti[i];
    }
    for(int i=0;i<15;i++) {
        szRukaWhite[i]=szKarti[i+15];
    }
 
    nKombBlack = kombinaziya(szRukaBlack,0);
    nKombWhite = kombinaziya(szRukaWhite,1);
    if (nKombBlack>nKombWhite) {
        cout << szBw<< "\n";
    }
    if (nKombWhite>nKombBlack) {
        cout << szWw << "\n";
    }
    if (nKombWhite==nKombBlack) {
        cout << starshaya (szRukaBlack,szRukaWhite, nKombBlack) <<"\n";
    }
    system("PAUSE");
}
vlad_light
4 / 4 / 0
Регистрация: 24.09.2012
Сообщений: 178
12.05.2013, 23:11  [ТС]     Покер #4
Большое спасибо!

Не по теме:

Кстати, в первой программе классы определены именно так, как я и написал


Попробую написать прототипы классов без "шпаргалки", поскольку только учу с++ и хочу всё сделать самостоятельно

Добавлено через 7 часов 19 минут
вот, что я пока написал. Гляньте, пожалуйста, и укажите на явные ошибки. Спасибо!
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
/****************************************************************
*                           Card.h                              *
****************************************************************/
#pragma once
 
#include <vector>
 
#include <iostream>
 
class Card
{
public:
    Card ();
    Card (const Card& card);
    Card (const int rank, const int suit);
 
    ~Card ();
 
    Card operator= (const Card& card);
 
    void set (const int rank, const int suit);
 
    int getRank () const;
    int getSuit () const;   
 
    void view () const;
 
private:
    int rank_; // Empty - 0, A - 1, 2 - 2, 3 - 3, ..., 
               // 9 - 9, T - 10, J - 11, Q - 12, K - 13, A - 14
    int suit_; // Hearts - 0, Diamonds - 1, Clubs - 2, Spades - 3
 
    std::vector<char> notation_; // rank/suit
 
    void initializeNotation_ ();
 
 
};
 
/****************************************************************
*                           Card.cpp                            *
****************************************************************/
 
#include "Card.h"
 
Card::Card ()
{
    rank_ = 0;
    suit_ = 0;  
 
    notation_.push_back ('#');
    notation_.push_back ('#');
}
 
Card::Card (const Card& card)
{
    rank_ = card.rank_;
    suit_ = card.suit_; 
 
    notation_ = card.notation_;
}
 
Card::Card (const int rank, const int suit)
{
    rank_ = rank;
    suit_ = suit;
 
    initializeNotation_ ();
}
 
Card::~Card ()
{
 
}
 
Card Card::operator= (const Card& card)
{
    rank_ = card.rank_;
    suit_ = card.suit_;
 
    notation_ = card.notation_;
 
    return *this;
}
 
void Card::initializeNotation_ ()
{
    if (rank_ == 0)
    {
        notation_.push_back ('#');
        notation_.push_back ('#');
        return;
    }
 
    if (rank_ < 10)
    {
        notation_.push_back ((char) '0' + rank_);
    }
    else
    {
        switch (rank_)
        {
        case 10 :
            notation_.push_back ('T');
            break;
 
        case 11 :
            notation_.push_back ('J');
            break;
 
        case 12 :
            notation_.push_back ('Q');
            break;
 
        case 13 :
            notation_.push_back ('K');
            break;
 
        case 14 :
            notation_.push_back ('A');
            break;
        }
    }
 
    notation_.push_back ((char) suit_ + 3);
}
 
void Card::set (const int rank, const int suit)
{
    rank_ = rank;
    suit_ = suit;
 
    initializeNotation_ ();
}
 
int Card::getRank () const
{
    return rank_;
}
 
int Card::getSuit () const
{
    return suit_;
}
 
void Card::view () const
{
    std::cout << notation_.at (0) << notation_.at (1);
}

Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
/****************************************************************
*                           Deck.h                              *
****************************************************************/
#pragma once
 
#include "Card.h"
 
#include <ctime>
#include <cstdlib>
 
class Deck
{
public:
    Deck ();
    Deck (const Deck& deck);
 
    ~Deck ();
 
    Deck operator= (const Deck& deck);
 
    void initialize ();
    void shuffle (const int iterations);
 
    Card getTopCard ();
 
    void view () const;
 
private:
    std::vector<Card> cards_;
 
    void swapCards_ (const int cardNo1, const int cardNo2);
};
 
 
/****************************************************************
*                           Deck.cpp                            *
****************************************************************/
#include "Deck.h"
 
Deck::Deck ()
{
 
}
 
Deck::Deck (const Deck& deck)
{
    cards_ = deck.cards_;
}
 
Deck::~Deck ()
{
 
}
 
Deck Deck::operator= (const Deck& deck)
{
    cards_ = deck.cards_;
 
    return *this;
}
 
void Deck::initialize ()
{
    cards_.clear ();
    cards_.reserve (52);
 
    for (int suit = 0; suit < 4; ++suit)
        for (int rank = 2; rank < 15; ++rank)
            cards_.push_back (Card (rank, suit));
}
 
void Deck::shuffle (const int iterations)
{
    const int CURRENT_DECK_SIZE = cards_.size ();
 
    srand (time (0));
 
    for (int i = 0; i < iterations; ++i)
        swapCards_ (rand () % CURRENT_DECK_SIZE, rand () % CURRENT_DECK_SIZE);
}
 
Card Deck::getTopCard ()
{
    Card topCard (*cards_.crbegin ());
 
    cards_.pop_back ();
 
    return topCard;
}
 
void Deck::swapCards_ (const int cardNo1, const int cardNo2)
{
    Card temporaryCard (cards_.at (cardNo1));
    cards_.at (cardNo1) = cards_.at (cardNo2);
    cards_.at (cardNo2) = temporaryCard;
}
 
void Deck::view () const
{
    const int CURRENT_DECK_SIZE = cards_.size ();
 
    for (int i = 0; i < CURRENT_DECK_SIZE; ++i)
    {
        cards_.at (i).view ();
        std::cout << " ";
 
        if ((i + 1) % 13 == 0)
            std::cout << std::endl;
    }
}

Позже попробую написать более сложные классы: игрок и стол.
ninja2
 Аватар для ninja2
230 / 186 / 7
Регистрация: 26.09.2012
Сообщений: 2,018
Завершенные тесты: 1
12.05.2013, 23:33     Покер #5
vlad_light, Я уже честно не помню но мне кажется намного проще сделать все в одном классе класс Poker например.

Как они у тебя взаимодействуют эти Card и Deck ???? Пиши все в одном головняка меньше будет.

Добавлено через 14 минут
Цитата Сообщение от vlad_light Посмотреть сообщение
Нужна помощь с архитектурой. Напишите, пожалуйста, какие классы стоит реализовать. Спасибо!
Ладно я тебе уже помогу с архитектурой. Создай класс Poker в нем создай метод menu() - он будет выводить режими игры на 2 игрока либо с компом. Потом создай еще один метод game() в котором будет спрашиваться начать партию и выход из игры, если выбрать начать партию, то сдаются карты, значит придется создать метод для сдачи карт, а затем комп уже АИМ за него выберет скоко карт менять и тебе задаст вопрос какие карты ты хочешь поменять, значит создай метод для проверки комбинации и замены карт. Дальше уже ищем победителя, можно тот же самый метод "для проверки комбинации и замены карт вызвать только передать ему в качестве параметра допустим 1 (по умолчанию 0 будет) и сделать просто проверку определить кто победил (например в классе какой нибудь член победитель будет равен 0 если победил камп мы его ставим в один, если игрок то в 0), а затем уже просто в каком нить методе проверяем кто победил и выводим на экран победителя.
Jupiter
Каратель
Эксперт C++
6543 / 3963 / 226
Регистрация: 26.03.2010
Сообщений: 9,273
Записей в блоге: 1
Завершенные тесты: 2
12.05.2013, 23:44     Покер #6
Цитата Сообщение от vlad_light Посмотреть сообщение
Card operator= (const Card& card);
нафига такой оператор сдался

Добавлено через 19 секунд
Цитата Сообщение от ninja2 Посмотреть сообщение
Как они у тебя взаимодействуют эти Card и Deck ???? Пиши все в одном головняка меньше будет.
разделяй и властвуй, учитывая что ваша репутация отрицательная я бы не стал доверять вашим советам

Добавлено через 24 секунды
Цитата Сообщение от vlad_light Посмотреть сообщение
std::vector<char> notation_; // rank/suit
что за вектор? для чего он?

Добавлено через 3 минуты
Цитата Сообщение от vlad_light Посмотреть сообщение
Deck operator= (const Deck& deck);
снова, нафига этот оператор?

Добавлено через 27 секунд
Цитата Сообщение от vlad_light Посмотреть сообщение
Card::~Card ()
{
}
нафига пустой деструктор?

Добавлено через 1 минуту
Цитата Сообщение от vlad_light Посмотреть сообщение
void Deck::shuffle (const int iterations)
{
* * const int CURRENT_DECK_SIZE = cards_.size ();
srand (time (0));
for (int i = 0; i < iterations; ++i)
* * * * swapCards_ (rand () % CURRENT_DECK_SIZE, rand () % CURRENT_DECK_SIZE);
}
ты серьёзно думаешь что напишешь алгоритм shuffle лучше чем он реализован в стандартной библиотеке?
ninja2
 Аватар для ninja2
230 / 186 / 7
Регистрация: 26.09.2012
Сообщений: 2,018
Завершенные тесты: 1
12.05.2013, 23:57     Покер #7
vlad_light, Репутация это необъективно, главное это толковый совет, а я тебе советую все делать в одном классе ты не запутаешься и проще намного.
Хотя можно сделать традиционную иерархию дерево, но как ее можно сюда втулить? Корень(базовый класс) что будет? Делать проще в одном путаться не будешь, для данной программы это оптимальное решение. Сам подумай.

Добавлено через 1 минуту
Просто можешь делать вложенные классы.

Добавлено через 4 минуты
Цитата Сообщение от Jupiter Посмотреть сообщение
ты серьёзно думаешь что напишешь алгоритм shuffle лучше чем он реализован в стандартной библиотеке?
Да можно написать. есть так называемый эффективный алгоритм тосования колоды карт, там за одни проход цикла тасуется вся колода. (проход по всем картам количество итераци равно количеству карт) я уже этот алгоритм не помню, но он в Дейтелов есть.
vlad_light
4 / 4 / 0
Регистрация: 24.09.2012
Сообщений: 178
13.05.2013, 00:07  [ТС]     Покер #8
нафига такой оператор сдался
Я где-то читал (если правильно помню), что конструктор по умолчания, копии, деструктор и оператор присваивания создаются автоматически, если их не написать вручную. Так вот я их и написал, чтоб (если вдруг что) в будущем их подправить. И вообще мне кто-то говорил, что лучше их всё-таки писать (даже пустые), чем не писать вообще во избежании проблем в будущем.
что за вектор? для чего он?
Ммм... ну, я использую его для оператора view (). Суть в том, чтоб в ситуациях, где нужно много раз выводить одну и ту же карту не использовать метод initializeNotation_ (), а брать данные сразу из "таблички". Или ты не это имел ввиду?
ты серьёзно думаешь что напишешь алгоритм shuffle лучше чем он реализован в стандартной библиотеке?
Нет, конечно! Я просто не знал о его существовании Можно линк?
ты серьёзно думаешь что напишешь алгоритм shuffle лучше чем он реализован в стандартной библиотеке?
Да можно написать.
Очень сомневаюсь
Просто можешь делать вложенные классы.
Я пока не знаю, что это такое, но думаю, что я что-то подобное и использую
Делать проще в одном путаться не будешь, для данной программы это оптимальное решение.
В оптимальность тоже слабо верится, хотя и не имею достаточно опыта, чтоб утверждать это... А вот разделять всё на разные классы наоборот делает алгоритм более читабельным (по крайней мере для меня).
ninja2
 Аватар для ninja2
230 / 186 / 7
Регистрация: 26.09.2012
Сообщений: 2,018
Завершенные тесты: 1
13.05.2013, 00:28     Покер #9
vlad_light, Да ну что у тебя два класса Card и класс Deck, ну что тут за разделение Card это карта я так понял, а Deck это колода, ну и что? Deck у тебя толжно иметь Card ты можешь сделать Deck : public Card либо создать указатель на Card в самом Deck, И чем это тебе проще становиться от этого? Наоборот все запутано становиться. Как по мне так проще все в одном классе создать намного проще.

А дальше мне просто интересно какой же еще класс будет class Game наверно который должен иметь Deck? то есть Game : public Deck. Знаешь старина это то же самое что ты в одном классе все создаешь просто что разделение на классы и головомотня. Хотя кто его знает это просто мое ИМХО, я б не делил бы. Тем более программа на 400 строк, (я точно помню я не более 400, а может и 500 строк писал когда делал)


Цитата Сообщение от vlad_light Посмотреть сообщение
ты серьёзно думаешь что напишешь алгоритм shuffle лучше чем он реализован в стандартной библиотеке?
Да можно написать.
Очень сомневаюсь
Да не сомневайся, конечно он наверно не лучше чем в стандартной библиотеке, но там за один проход цикла все тасовалось и вроде даже и без rand() я щас точно не вспомню и лень ковырятся в файлах щас искать, что протормазонов кода потосуется колода как с rand(), это кода я первый раз делал, не зная про этот алгоритм нету, попробуй в гугле набрать эффективный алгоритм тасования колоды карт мб на него попадешь.
vlad_light
4 / 4 / 0
Регистрация: 24.09.2012
Сообщений: 178
13.05.2013, 00:44  [ТС]     Покер #10
и вроде даже и без rand()
В это уже точно не поверю!!!
у тебя два класса
Это я написал 2 класса, ещё допишу классы игрок, стол и ИИ. Возможно ещё что-то.
ты можешь сделать Deck : public Card либо создать указатель на Card в самом Deck
Это ещё что такое?!
ninja2
 Аватар для ninja2
230 / 186 / 7
Регистрация: 26.09.2012
Сообщений: 2,018
Завершенные тесты: 1
13.05.2013, 00:50     Покер #11
Цитата Сообщение от vlad_light Посмотреть сообщение
ты можешь сделать Deck : public Card либо создать указатель на Card в самом Deck
Это ещё что такое?!
А как у тебя классы будут взаимодействовать? В каких отношениях у тебя находятся классы Deck и Card? Или это просто у тебя структуры данных? Deck - это колода, Card - это карта, а в колоде (Deck) должны быть карты (Card), значит Deck имеет Card, а как построить такое отношение? Есть два способа сделать Deck : public Card или Хронить объект на Card в Deck. Я сам просто не сильно шарю, да вринципе шарю норм, просто по другому не получается. Подумай!
vlad_light
13.05.2013, 00:58  [ТС]
  #12

Не по теме:

Ерунду пишешь!

ninja2
13.05.2013, 01:01
  #13

Не по теме:

Ладно ты не шаришь.

MihalNik
55 / 55 / 6
Регистрация: 01.12.2012
Сообщений: 431
13.05.2013, 01:49     Покер #14
- карта // объектами будут карты
- колода // состоит из набора карт
- игрок // хранит данные о фишках, возможных ходах и т.п.
- стол // хранит информацию об игроках, текущем ходе, банке и т.п.
- ИИ // н.к.
Вот я бы не делал карты объектами. А просто числами. Пару функций для масти и достоинства делаются делением как частное и остаток. Названия или картинки для карт - массивом. В колоду массив чисел, перемешивать очень удобно, сдавать и т.п. Вообще для любых карточных игр, не только покера.
stima
430 / 285 / 16
Регистрация: 22.03.2011
Сообщений: 929
Завершенные тесты: 1
13.05.2013, 02:09     Покер #15
Я бы сделал как-то так. Соответственно разбив это на обьявление и имлементацию.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
class Card
{
 
public:
    enum Rank { _6, _7, _8, _9, _10, J, Q, K, A };
    enum Suit { Hearts, Diamonds, Clubs, Spades };
 
    Card(const Suit& suit, const Rank& rank)
        : _suit(suit), _rank(rank) {}
 
    Suit suit() const { return _suit; }
    Rank rank() const { return _rank; }
 
    bool operator== (const Card& other) const
    {
        return _suit == other._suit && _rank == other._rank;
    }
 
    bool operator> (const Card& other) const
    {
        return _suit > other._suit && _rank > other._rank;
    }
 
private:
    Suit _suit;
    Rank _rank;
};
 
class Deck
{
    typedef Card& iterator;
    typedef const Card& const_iterator;
 
public:
    Deck()
    {
        for (int suit = Card::Hearts; suit <= Card::Spades; ++suit)
            for (int rank = Card::_6; rank <= Card::A; ++rank)
                _cards.push_back(Card(Card::Suit(suit), Card::Rank(rank)));
    }
 
    void shuffle() { std::random_shuffle(_cards.begin(), _cards.end()); }
 
    iterator begin() { return *_cards.begin(); }
    const_iterator cbegin() const { return *_cards.begin(); }
 
    iterator end() { return *_cards.end(); }
    const_iterator end() const { return *_cards.end(); }
 
    Card& operator[](int index) { return _cards[index]; }
    const Card& operator[](int index) const { return _cards[index]; }
 
private:
    std::vector<Card> _cards;
};
 
class Player
{
    
public:
    Player(const std::string& name)
        : _name(name) {}
 
    std::string name() const { return _name; }
 
    void add_card(Card* card) { _cards.push_back(card); }
    void remove_card(Card* card) { _cards.remove(card); }
 
private:
    std::string _name;
    std::list<Card*> _cards;
};
Добавлено через 7 минут
п.с. Тут не все. Так кратенький набросок.
lemegeton
 Аватар для lemegeton
2910 / 1339 / 133
Регистрация: 29.11.2010
Сообщений: 2,720
13.05.2013, 02:27     Покер #16
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <iostream>
#include <string>
 
/**
 * Игральная карта. Один байт в памяти.
 */
class Card {
 public:
  static const std::string SUIT_NAMES[];
  static const std::string RANK_NAMES[];
  Card(unsigned char id) : id(id) {}
  Card(unsigned char rankId, unsigned char suitId) : id((suitId << 5) | rankId) {}
  unsigned char getId() const { return id; }
  unsigned char getRankId() const { return id & 31; }
  unsigned char getSuitId() const { return id >> 5; }
  const std::string &getRankName() const { return RANK_NAMES[getRankId()]; }
  const std::string &getSuitName() const { return SUIT_NAMES[getSuitId()]; }
 private:
  unsigned char id;
};
 
const std::string Card::SUIT_NAMES[] = {"spades", "diamonds", "clubs",
  "hearts"};
const std::string Card::RANK_NAMES[] = {"2", "3", "4", "5", "6", "7",
  "8", "9", "10", "jack", "queen", "king", "ace"};
 
bool operator<(const Card &a, const Card &b) {
  return a.getId() < b.getId();
}
 
std::ostream &operator<<(std::ostream &stream, const Card &c) {
  return stream << c.getRankName() << " of " << c.getSuitName();
}
Набор карт можно сделать просто набором битов. 52 карты уложатся в восемь байт.
Шаффл вообще не нужен -- нужно просто брать рандомную карту.

Добавлено через 7 минут
std::bitset поможет, кстати.
stima
430 / 285 / 16
Регистрация: 22.03.2011
Сообщений: 929
Завершенные тесты: 1
13.05.2013, 02:55     Покер #17
2lemegeton
1. Ну один байт это если запретить выравнивание.
2. Card card(255). Это что за карта?
3. А теперь представьте. Ваш покер пользуется популярностью и Вы все улучшаете его и улучшаете. Кода все больше и больше. Время для переписывания все меньше и меньше. Как Вы думаете, Вы сразу сообразите что это
C++
1
unsigned char getSuitId() const { return id >> 5; }
4.
Цитата Сообщение от lemegeton Посмотреть сообщение
Шаффл вообще не нужен -- нужно просто брать рандомную карту.
Каждый раз рандомить + хранить какая карта выбыла? Или все таки один раз перемешать.
vlad_light
4 / 4 / 0
Регистрация: 24.09.2012
Сообщений: 178
13.05.2013, 02:59  [ТС]     Покер #18
Я бы сделал как-то так. Соответственно разбив это на обьявление и имлементацию.
В принципе, я где-то так и сделал... Спасибо!
сделать просто набором битов
Ой, тяжело мне даются эти штуки с умножением на 31 == (1 << 5) - 1 и т.п. Можно было тогда вообще всю колоду в 7 байтов (два unsigned int или один unsigned long long ) обозначить
Например 4 бубен и король пик имеет вид (масти HDCS, ранг от 2 до А):
##...#23...KA23456...QKA
00....000...0000100....010 = 68719476738.

Добавлено через 1 минуту
Каждый раз рандомить + хранить какая карта выбыла? Или все таки один раз перемешать.
Я это тоже хотел спросить

Добавлено через 2 минуты
Вы сразу сообразите что это
C++
1
unsigned char getSuitId() const { return id >> 5; }
Скорее, что это:
C++
1
unsigned char getRankId() const { return id & 31; }

Не по теме:

Вот, раскритиковали человека, а на самом деле очень умные вещи рассказывает. Просто мне до них ещё далеко, поэтому и не воспринимаю я такое...

lemegeton
 Аватар для lemegeton
2910 / 1339 / 133
Регистрация: 29.11.2010
Сообщений: 2,720
13.05.2013, 03:02     Покер #19
Цитата Сообщение от stima Посмотреть сообщение
1. Ну один байт это если запретить выравнивание.
Ок.

Цитата Сообщение от stima Посмотреть сообщение
Каждый раз рандомить + хранить какая карта выбыла?
Я предлагаю сделать битсет, и хранить в нем все возможные карты. Перемешивать особо не выйдет.

Цитата Сообщение от stima Посмотреть сообщение
3. А теперь представьте. Ваш покер пользуется популярностью и Вы все улучшаете его и улучшаете. Кода все больше и больше. Время для переписывания все меньше и меньше. Как Вы думаете, Вы сразу сообразите что это
Да. Обязательная документация.

Цитата Сообщение от stima Посмотреть сообщение
2. Card card(255). Это что за карта?
Тот же смысл, что и Card card(255, 255).
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
13.05.2013, 03:03     Покер
Еще ссылки по теме:

Покер C++
C++ Графический покер
C++ Покер

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
vlad_light
4 / 4 / 0
Регистрация: 24.09.2012
Сообщений: 178
13.05.2013, 03:03  [ТС]     Покер #20
2. Card card(255). Это что за карта?
такой, как я понял -- нету. И задаваться они будут в стиле Card card ((suit << 5) + rank), если я правильно понял код...
Yandex
Объявления
13.05.2013, 03:03     Покер
Ответ Создать тему
Опции темы

Текущее время: 18:38. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru