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

создание игры "Точки" - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ библиотеки в С++ http://www.cyberforum.ru/cpp-beginners/thread224842.html
#include <iostream> #include <algorithm> #include <iterator> #include <string> что значат эти библиотеки
C++ Даны таблицы А[1..n] ,В[1..m]. Построить таблицу С в которой сначала размещаются все элементы А, затем все элементы таблицы В кто сможет решите: Даны таблицы А ,В. Построить таблицу С в которой сначала размещаются все элементы А, затем все элементы таблицы В http://www.cyberforum.ru/cpp-beginners/thread224839.html
C++ Приведение подобны
Приведение подобных. Многочлен произвольного вида с одним неизвестным задан символьной строкой. Неизвестное выражение представлено одной буквой, операция возведения в степень обозначается "^". Преобразовать многочлен к нормальному виду, приведя подобные члены и определив его массивом коэффициентов. Если подобных членов не окажется, вывести соответствующее сообщение.
Списки C++
Здравствуйте) Нужно решить задачу по спискам!) Буду ждать помощь))) Уже ранее созданные функции: (сделать ко всему этому меню, по заданию) void postroenie (node **phead) // *phead - указатель на заглавное звено. { node *t; int el;
C++ Определить максимальный элемент массива среди положительных нечетных элементов http://www.cyberforum.ru/cpp-beginners/thread224784.html
Помогите бедной девушке решить задачку на С++!Сама не справляюсь:cry: Определить максимальный элемент среди положительных нечетных элементов и минимальный среди положительных четных элементов целочисленного массива X=(x1,x2,…,xn). Удалить из массива все совершенные числа, вывести сообщение, сколько элементов было удалено. Заранее СПАСИБО!!!
C++ Ввод текста на С, его обработка. Задан текст, содержащий произвольное количество строк, в которых отдельные слова могут разделяться одним или несколькими пробелами и знаками пунктуации (перенос слов с одной строки на другую не используется). Сформировать новый текст, который является результатом следующего преобразования исходного текста: удалить строки, в которых нет идентификаторов. Самая большая загвоздка с вводом текста... подробнее

Показать сообщение отдельно
shalisan
 Аватар для shalisan
3 / 3 / 1
Регистрация: 29.08.2012
Сообщений: 40
23.10.2012, 23:02     создание игры "Точки"
Цитата Сообщение от Mr.X Посмотреть сообщение
Ну, это на Си написано. На C++ это примерно так должно выглядеть:
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
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
/////////////////////////////////////////////////////////////////////////////////////////
#include <windows.h>
#include <conio.h>
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <utility>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
class  T_snake
{
    //-----------------------------------------------------------------------------------
    struct  T_col_row
    {
        int     col_;
        int     row_;
        //-------------------------------------------------------------------------------
        T_col_row
            (
                int     col     =   0,
                int     row     =   0
            )
            :
            col_    ( col ),
            row_    ( row )
        {}
        //-------------------------------------------------------------------------------
        bool  operator<(const T_col_row&  pos)  const
        {
            return      std::make_pair
                            (
                                col_,
                                row_
                            )
 
                    <   std::make_pair
                            (
                                pos.col_,
                                pos.row_
                            );
        }
        //-------------------------------------------------------------------------------
        bool  operator!=( T_col_row  pos )      const
        {
            return      *this   <   pos
                    ||  pos     <   *this;
        }
        //-------------------------------------------------------------------------------
        bool  operator==( T_col_row  pos )      const
        {
            return  !( *this    !=  pos );
        }
        //-------------------------------------------------------------------------------
        operator COORD()                        const
        {
            COORD   res =   {
                                col_,
                                row_
                            };
 
            return  res;
        }
        //-------------------------------------------------------------------------------
        void  shift_to_left     ()
        {
            --col_;
        }
        //-------------------------------------------------------------------------------
        void  shift_to_right    ()
        {
            ++col_;
        }
        //-------------------------------------------------------------------------------
        void  shift_up          ()
        {
            --row_;
        }
        //-------------------------------------------------------------------------------
        void  shift_down        ()
        {
            ++row_;
        }
        //-------------------------------------------------------------------------------
    };
    //-----------------------------------------------------------------------------------
    typedef std::deque  <T_col_row>   T_positions_deque;
    typedef std::set    <T_col_row>   T_positions_set;
    //-----------------------------------------------------------------------------------
    enum  T_direction
    {
        LEFT_DIRECTION,
        RIGHT_DIRECTION,
        UP_DIRECTION,
        DOWN_DIRECTION
    };
    //-----------------------------------------------------------------------------------
    enum  T_conrol_key
    {
        LEFT_DIR_KEY    =   75,
        RIGHT_DIR_KEY   =   77,
        UP_DIR_KEY      =   72,
        DOWN_DIR_KEY    =   80,
        PAUSE_KEY       =   ' '
    };
    //-----------------------------------------------------------------------------------
    enum  T_color
    {
        BLUE    =   9,
        GREEN   =   10,
        WHITE   =   11,
        RED     =   12,
        YELLOW  =   14
    };
    //-----------------------------------------------------------------------------------
    typedef std::map<T_conrol_key, T_direction>  T_direction_of_key;
    //-----------------------------------------------------------------------------------
    static const char       FIELD_SYMB                  =   ' ';
    static const char       BORDER_SYMB                 =   '#';
    static const char       SNAKE_HEAD_SYMB             =   1;
    static const char       SNAKE_BODY_SYMB             =   111;
    static const char       APPLE_SYMB                  =   4;
 
    static const char       UPWARDS_ARROW               =   24;
    static const char       DOWNWARDS_ARROW             =   25;
    static const char       RIGHTWARDS_ARROW            =   26;
    static const char       LEFTWARDS_ARROW             =   27;
 
    static const T_color    BORDER_COLOR                =   RED;
    static const T_color    APPLE_COLOR                 =   YELLOW;
    static const T_color    SNAKE_COLOR                 =   GREEN;
 
    static const int        FIELD_WIDTH                 =   80;
    static const int        FIELD_HIGHT                 =   20;
 
    static const int        LEFT_FIELD_COL              =   0;
    static const int        CENTER_FIELD_COL            =   LEFT_FIELD_COL  +   FIELD_WIDTH     /   2;
    static const int        RIGHT_FIELD_COL             =   LEFT_FIELD_COL  +   FIELD_WIDTH     -   1;
 
    static const int        HEADLINE_ROW                =   0;
 
    static const int        TOP_FIELD_ROW               =   1;
    static const int        CENTER_FIELD_ROW            =   TOP_FIELD_ROW   +   FIELD_HIGHT     /   2;
    static const int        BOTTOM_FIELD_ROW            =   TOP_FIELD_ROW   +   FIELD_HIGHT     -   1;
 
    static const int        START_MILLISEC_PER_STEP     =   100;
 
    static const size_t     START_SNAKE_LEN             =   6;
    //-----------------------------------------------------------------------------------
    bool                pause_indicator_;
    HANDLE              hConsole_;
    int                 millisec_per_step_;
 
    T_direction_of_key  direction_of_key_;
    T_positions_deque   snake_body_positions_deque_;
 
    T_col_row           apple_pos_;
    T_conrol_key        cur_conrol_key_;
    T_direction         cur_direction_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_snake()
        :
        pause_indicator_    ( false ),
        hConsole_
            (
                GetStdHandle( STD_OUTPUT_HANDLE )
            ),        
        millisec_per_step_  ( START_MILLISEC_PER_STEP )
        
    {
        direction_of_key_[ LEFT_DIR_KEY     ]   =   LEFT_DIRECTION;
        direction_of_key_[ RIGHT_DIR_KEY    ]   =   RIGHT_DIRECTION;
        direction_of_key_[ UP_DIR_KEY       ]   =   UP_DIRECTION;
        direction_of_key_[ DOWN_DIR_KEY     ]   =   DOWN_DIRECTION;
 
        make_start_snake_body   ();
        draw_snake_body         ();
        draw_apple_in_rand_pos  ();
    }
    //-----------------------------------------------------------------------------------
    void  make_start_snake_body()
    {
        cur_direction_  =   rand() % 2
                                ? RIGHT_DIRECTION
                                : LEFT_DIRECTION;
 
        T_col_row   cur_snake_body_pos
                        (
                            CENTER_FIELD_COL,
                            CENTER_FIELD_ROW
                        );
 
        for( int  i = 0; i < START_SNAKE_LEN; ++i )
        {
            snake_body_positions_deque_.push_front( cur_snake_body_pos );
 
            shift_position_in_direction
                (
                    cur_snake_body_pos,
                    cur_direction_
                );
        }
    }
    //-----------------------------------------------------------------------------------
    void  play()
    {
        print_field_border                                                          ();
        print_info                                                                  ();
        operated_eating_of_apples_before_collision_with_border_or_with_own_body     ();
        clear_screen                                                                ();
        print_result                                                                ();
        make_pause_to_pressing_of_any_key                                           ();
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    static void  clear_screen()
    {
        system("cls");
    }
    //-----------------------------------------------------------------------------------
    void  print_result()    const
    {
        int     result  =   snake_body_positions_deque_.size() - START_SNAKE_LEN;
 
        std::ostringstream  sout;
        sout    <<  "Съедено яблок "
                <<  result
                <<  ".";
 
        print_text_with_color_with_center_in_pos
            (
                sout.str(),
                RED,
                T_col_row
                    (
                        CENTER_FIELD_COL,
                        CENTER_FIELD_ROW
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    static void  make_pause_to_pressing_of_any_key()
    {
        _getch();
    }
    //-----------------------------------------------------------------------------------
    static T_col_row  get_rand_pos
        (
            int     left_col,
            int     right_col,
            int     top_row,
            int     botom_row
        )
    {
        int     rand_col    =   get_rand_val
                                    (
                                        left_col,
                                        right_col
                                    );
 
        int     rand_row    =   get_rand_val
                                    (
                                        top_row,
                                        botom_row
                                    );
 
        return  T_col_row
                    (
                        rand_col,
                        rand_row
                    );
    }
    //-----------------------------------------------------------------------------------
    static int  get_rand_val
        (
            int     min_val,
            int     max_val
        )
    {
        return  rand() % (max_val - min_val + 1) + min_val;
    }
    //-----------------------------------------------------------------------------------
    void  set_rand_apple_pos()
    {
        do
        {
            apple_pos_  =   get_rand_pos
                                (
                                    LEFT_FIELD_COL,
                                    RIGHT_FIELD_COL,
                                    TOP_FIELD_ROW,
                                    BOTTOM_FIELD_ROW
                                );
        }while  (
                        position_belongs_to_snake_body  ( apple_pos_    )
                    ||  position_belongs_to_border      ( apple_pos_    )
                );
    }
    //-----------------------------------------------------------------------------------
    bool  position_belongs_to_snake_body( const T_col_row&  pos )       const
    {
        return      std::find
                        (
                            snake_body_positions_deque_.begin   (),
                            snake_body_positions_deque_.end     (),
                            pos
                        )
 
                !=  snake_body_positions_deque_.end();
    }
    //-----------------------------------------------------------------------------------
    void  print_text_with_color_in_pos
        ( 
            const T_str&        text,
            T_color             color,
            const T_col_row&    pos
        )                                                               const
    {
 
        SetConsoleCursorPosition
            (
                hConsole_,
                pos
            );
 
        SetConsoleTextAttribute
            (
                hConsole_, 
                color
            );
 
        std::cout   <<  text;
 
        SetConsoleTextAttribute
            (
                hConsole_, 
                WHITE
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_symb_with_color_in_pos
        (
            char                symb,
            T_color             color,
            const T_col_row&    pos
        )                                                               const
    {
        print_text_with_color_in_pos
            (
                T_str(1, symb),
                color,
                pos
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_field_border()                                          const
    {
        for( int  row = TOP_FIELD_ROW; row <= BOTTOM_FIELD_ROW; ++row )
        {
            for( int  col = LEFT_FIELD_COL; col <= RIGHT_FIELD_COL; ++col )
            {
                T_col_row   cur_pos(col, row);
                if  (
                        position_belongs_to_border( cur_pos )
                    )
                {
                    print_border_symb_in_pos( cur_pos );
                }
            }//for
        }//for
    }
    //-----------------------------------------------------------------------------------
    void  print_border_symb_in_pos(const T_col_row&  pos)               const
    {
        print_symb_with_color_in_pos
            (
                BORDER_SYMB,
                BORDER_COLOR,
                pos
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_text_with_color_with_center_in_pos
        ( 
            T_str       text,
            T_color     text_color,
            T_col_row   pos
        )                                                               const
    {
        int     text_left_col   =       pos.col_
 
                                    -       (
                                                text.size() - 1 
                                            )
                                        
                                        /   2;
 
        print_text_with_color_in_pos
            (
                text,
                text_color,
                T_col_row
                    (
                        text_left_col,
                        pos.row_
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_info()                                                  const
    {
        int     cur_row     =   BOTTOM_FIELD_ROW + 1;
 
        print_text_with_color_in_pos(   "Управление:",      BLUE,   T_col_row(  CENTER_FIELD_COL,     cur_row )   );
 
        ++cur_row;
        print_symb_with_color_in_pos(   UPWARDS_ARROW,      GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "\t- вверх,",       BLUE,   T_col_row(  CENTER_FIELD_COL + 1, cur_row )   );
 
        ++cur_row;
        print_symb_with_color_in_pos(   DOWNWARDS_ARROW,    GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "\t- вниз,",        BLUE,   T_col_row(  CENTER_FIELD_COL + 1, cur_row )   );
 
        ++cur_row;
        print_symb_with_color_in_pos(   LEFTWARDS_ARROW,    GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "\t- влево,",       BLUE,   T_col_row(  CENTER_FIELD_COL + 1, cur_row )   );
 
        ++cur_row;
        print_symb_with_color_in_pos(   RIGHTWARDS_ARROW,   GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "\t- вправо,",      BLUE,   T_col_row(  CENTER_FIELD_COL + 1, cur_row )   );
 
        ++cur_row;
        print_text_with_color_in_pos(   "пробел",           GREEN,  T_col_row(  CENTER_FIELD_COL,     cur_row )   );
        print_text_with_color_in_pos(   "- пауза.",         BLUE,   T_col_row(  CENTER_FIELD_COL + 8, cur_row )   );
    }
    //-----------------------------------------------------------------------------------
    void  operated_eating_of_apples_before_collision_with_border_or_with_own_body()
    {
        for(;;)
        {
            //Пока ничего не нажато.
            while   (
                        !_kbhit()
                    )
            {
                print_speed_value                                       ();
                make_step_to_current_direction_and_to_eat_apple_if_got  ();
                Sleep                                                   ( millisec_per_step_ );
 
                if  (
                            is_collision_with_border    ()
                        ||  is_collision_with_own_body  ()
                    )
                {
                    return;
                }      
 
                if  (
                        is_collision_with_apple()
                    )
                {    
                    to_increase_speed       ();
                    draw_apple_in_rand_pos  ();
                }
            }            
            input_cur_control_key                                   ();
            set_pause_indicator_from_cur_conrol_key                 ();
            set_cur_direction_from_cur_conrol_key                   ();
            if_it_is_necessary_make_pause_to_pressing_of_any_key    ();
        }//for
    }
    //-----------------------------------------------------------------------------------
    void  print_speed_value()       const
    {
        std::ostringstream  sout;
        int     speed   =   round( 1000.0 / millisec_per_step_ );
        sout    <<  "Скорость "
                <<  speed
                <<  " символов в секунду.";
 
        print_text_with_color_with_center_in_pos
            (
                sout.str(),
                YELLOW,
                T_col_row
                    (
                        CENTER_FIELD_COL,
                        HEADLINE_ROW
                    )
            );
    }
    //-----------------------------------------------------------------------------------
    static int  round( double  x )
    {
        return  int(x + 0.5);
    }
    //-----------------------------------------------------------------------------------
    void  to_increase_speed()
    {
        double  k   =   0.2;
        millisec_per_step_  =   int
                                    (
                                            double( millisec_per_step_ )
                                        *   snake_body_positions_deque_.size()
                                        /   (
                                                    snake_body_positions_deque_.size()
                                                +   k
                                            )
                                    );
    }
    //-----------------------------------------------------------------------------------
    void  draw_apple_in_rand_pos()
    {
        set_rand_apple_pos();
 
        print_symb_with_color_in_pos
            (
                APPLE_SYMB,
                APPLE_COLOR,
                apple_pos_
            );
    }
    //-----------------------------------------------------------------------------------
    void  input_cur_control_key()
    {
        cur_conrol_key_     =   static_cast<T_conrol_key>
                                    (
                                        _getch()
                                    );
    }
    //-----------------------------------------------------------------------------------
    void  set_pause_indicator_from_cur_conrol_key()
    {
        if  (
                cur_conrol_key_     ==  PAUSE_KEY
            )
        {
            pause_indicator_    =   true;
        }
    }
    //-----------------------------------------------------------------------------------
    void  set_cur_direction_from_cur_conrol_key()
    {
        T_direction_of_key::const_iterator  key_direction_it    =   direction_of_key_.find( cur_conrol_key_ );
        if  ( 
                key_direction_it != direction_of_key_.end() 
            )
        {
            T_direction     new_direction   =   key_direction_it->second;
            if  (
                    !directions_are_opposite
                        (
                            cur_direction_,
                            new_direction
                        )
                )
            {
                cur_direction_  =   new_direction;
            }
        }
    }
    //-----------------------------------------------------------------------------------
    static bool  directions_are_opposite
        (
            T_direction     L,
            T_direction     R
        )
    {
        return          L   ==  LEFT_DIRECTION
                    &&  R   ==  RIGHT_DIRECTION
 
                ||      L   ==  RIGHT_DIRECTION
                    &&  R   ==  LEFT_DIRECTION
 
                ||      L   ==  UP_DIRECTION
                    &&  R   ==  DOWN_DIRECTION
 
                ||      L   ==  DOWN_DIRECTION
                    &&  R   ==  UP_DIRECTION;
    }
    //-----------------------------------------------------------------------------------
    void  if_it_is_necessary_make_pause_to_pressing_of_any_key()
    {
        if( pause_indicator_ )
        {
            _getch();
            pause_indicator_    =   false;
        }
    }
    //-----------------------------------------------------------------------------------
    void  make_step_to_current_direction_and_to_eat_apple_if_got()
    {
        T_col_row   old_head_pos    =   snake_body_positions_deque_.front   ();
        T_col_row   old_tail_pos    =   snake_body_positions_deque_.back    ();
        T_col_row   new_head_pos    =   old_head_pos;
 
        shift_position_in_direction
            (
                new_head_pos,
                cur_direction_
            );
 
        draw_head_in_pos        ( new_head_pos );
        draw_body_elem_in_pos   ( old_head_pos );
 
        snake_body_positions_deque_.push_front( new_head_pos );
 
        if( new_head_pos != apple_pos_ )
        {
            draw_field_elem_in_pos( old_tail_pos );
            snake_body_positions_deque_.pop_back();
        }
    }
    //-----------------------------------------------------------------------------------
    void  draw_head_in_pos( const T_col_row&  pos )         const
    {
        print_symb_with_color_in_pos
            (
                SNAKE_HEAD_SYMB,
                SNAKE_COLOR,
                pos
            );
    }
    //-----------------------------------------------------------------------------------
    void  draw_body_elem_in_pos( const T_col_row&  pos )    const
    {
        print_symb_with_color_in_pos
            (
                SNAKE_BODY_SYMB,
                SNAKE_COLOR,
                pos
            );
    }
    //-----------------------------------------------------------------------------------
    void  draw_field_elem_in_pos( const T_col_row&  pos )   const
    {
            print_symb_with_color_in_pos
                (
                    FIELD_SYMB,
                    WHITE,
                    pos
                );
    }
    //-----------------------------------------------------------------------------------
    static void  shift_position_in_direction
        (
            T_col_row&      pos,
            T_direction     direction
        )
    {
        switch( direction )
        {
        case LEFT_DIRECTION:
            pos.shift_to_left   ();
            break;
 
        case RIGHT_DIRECTION:
            pos.shift_to_right  ();
            break;
 
        case UP_DIRECTION:
            pos.shift_up        ();
            break;
 
        case DOWN_DIRECTION:
            pos.shift_down      ();
            break;
        }//switch
    }
    //-----------------------------------------------------------------------------------
    void  draw_snake_body()                 const
    {
        for (
                T_positions_deque::const_iterator
                snake_body_pos_it   =   snake_body_positions_deque_.begin   ();
                snake_body_pos_it   !=  snake_body_positions_deque_.end     ();
                ++snake_body_pos_it
            )
        {
            snake_body_pos_it == snake_body_positions_deque_.begin()
                ? draw_head_in_pos          ( *snake_body_pos_it )
                : draw_body_elem_in_pos     ( *snake_body_pos_it );
        }
    }
    //-----------------------------------------------------------------------------------
    bool  is_collision_with_border()        const
    {
        return  position_belongs_to_border
                    (
                        snake_body_positions_deque_.front()
                    );
    }
    //-----------------------------------------------------------------------------------
    static bool  position_belongs_to_border( const T_col_row&  pos )
    {
        return      pos.col_    ==  LEFT_FIELD_COL
                ||  pos.col_    ==  RIGHT_FIELD_COL
                ||  pos.row_    ==  TOP_FIELD_ROW
                ||  pos.row_    ==  BOTTOM_FIELD_ROW;
    }
    //-----------------------------------------------------------------------------------
    bool  is_collision_with_own_body()      const
    {
        T_positions_set     snake_body_positions_set
                                (
                                    snake_body_positions_deque_.begin   (),
                                    snake_body_positions_deque_.end     ()
                                );
 
        return  snake_body_positions_set.size() != snake_body_positions_deque_.size();
    }
    //-----------------------------------------------------------------------------------
    bool  is_collision_with_apple()         const
    {
        return  position_belongs_to_snake_body( apple_pos_ );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    srand(unsigned(time(0)));
    T_snake  snake;
    snake.play();
}
большое спасибо за ответ но я начал познавать ActionScript 3.0 =)
 
Текущее время: 16:05. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru