0 / 0 / 0
Регистрация: 06.08.2019
Сообщений: 30
1

Консольный "Морской бой", написать передвижение корабля мышью

14.02.2020, 19:33. Показов 2470. Ответов 9
Метки нет (Все метки)

нужно сделать так что бы при расстановке кораблей ,пользователь брал корабль мышкой и переносил в желаемую точку поля
уже неделю сижу,не хватает мозга
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
#include<iostream>
#include<windows.h>
#include<string>
#include<cstring>
#include<vector>
#include<algorithm>
#include<ctime>
#include<conio.h>
using namespace std;
class Mouse
{
public:
    Mouse()
    {
    }
    static POINT getPointMouse()
    {
        POINT point;
#define MY_BUFSIZE 1024 
        HWND hwndFound;
        char pszNewWindowTitle[MY_BUFSIZE];
        char pszOldWindowTitle[MY_BUFSIZE];
        GetConsoleTitle(pszOldWindowTitle, MY_BUFSIZE);
        wsprintf(pszNewWindowTitle, "%d/%d",
            GetTickCount(),
            GetCurrentProcessId());
        SetConsoleTitle(pszNewWindowTitle);
        Sleep(1);
        hwndFound = FindWindow(NULL, pszNewWindowTitle);
        SetConsoleTitle(pszOldWindowTitle);
        RECT r;
        POINT p;
        HWND wh = hwndFound;
        COORD c = { 1,1 };
        GetWindowRect(wh, &r);
        GetCursorPos(&p);
        SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), c);
        point.x = p.x - r.left;
        point.y = p.y - r.top;
        return point;
    }
    static bool checkZone(POINT upLPoint, POINT downRPoint, POINT pMouse)
    {
        if ((upLPoint.x < pMouse.x) && (downRPoint.x > pMouse.x))
            if ((upLPoint.y < pMouse.y) && (downRPoint.y > pMouse.y))
                return true;
 
        return false;
    }
    static bool isLButtonDown()
    {
        SHORT state = GetAsyncKeyState(VK_LBUTTON);
        return (state & 0x8000) != 0;
    }
    static bool isRButtonDown()
    {
        SHORT state = GetAsyncKeyState(VK_RBUTTON);
        return (state & 0x8000) != 0;
    }
    /*bool isMouseMove()
    {
 
        SHORT state = GetAsyncKeyState(VM_MOUSEMOVE);
        if ((state & 0x8000) != 0)
        {
            return true;
        }
        return false;
    }*/
 
};
 
struct KeyPoint
{
    static const int empty = 0;
    static const int deck = 1;
    static const int damage = 10;
    static const int dead = 100;
    static const int DontTouch = 3;
    static const int animationDam = 7;
    KeyPoint() {}
 
};
struct KeyShip
{
    static const int safe = 2;
    static const int Destroyed = 3;
    static const int created = 4;
};
bool lButton()
{
    SHORT state = GetAsyncKeyState(VK_LBUTTON);
    if ((state & 0x8000) != 0)
    {
        return true;
    }
    return false;
}
class Exception
{
    string errorMessage;
public:
    Exception(string str) :errorMessage(str) {}
 
    string getMessage()
    {
        return errorMessage;
    }
};
class OutOfRange :public Exception
{
public:
    OutOfRange() : Exception("OUT OF RANGE") {}
};
class ThisPointIsDeadOrDamage :public Exception
{
public:
    ThisPointIsDeadOrDamage() : Exception("This Point Is Dead Or Damage") {}
};
class Mises :public Exception
{
public:
    Mises() : Exception("you mises") {}
};
class Ship;
class GameZone
{
    const int size = 10;
    vector<vector<pair<int, bool>>> myGameZone;
public:
    GameZone()
    {
        myGameZone.resize(size);
        for (int i = 0; i < size; i++)
            myGameZone[i].resize(size);
        for (int i = 0; i < size; i++)
            for (int j = 0; j < size; j++) {
                myGameZone[i][j].first = KeyPoint::empty;
                myGameZone[i][j].second = false;
            }
    }
 
    int get(int x, int y)
    {
        if (!(x < 0 || x >= size) || (y < 0 || y >= size))
            return myGameZone[y][x].first;
    }
    void set(int x, int y, int state)
    {
        if (!(x < 0 || x >= size) || (y < 0 || y >= size))
            myGameZone[y][x].first = state;
    }
    int getSize()
    {
        return size;
    }
    vector<pair<int, bool>>& operator[](int index) {
        if (index >= 0 && index < size)
            return myGameZone[index];
        else {
            cout << index;
            throw OutOfRange();
        }
    }
};
class Ship
{
    vector<POINT> cells;
    int shipState = KeyShip::safe;
    int size;
    bool horizontal;
    GameZone & gamezone;
public:
 
    Ship(GameZone & gamezone) :gamezone(gamezone) {}
    bool Create(int size, int x, int y, const bool horizontal)
    {
        if (shipState == KeyShip::created)
            return true;
 
        this->size = size;
        this->horizontal = horizontal;
        if (horizontal)
            if ((x + size) - 1 >= gamezone.getSize() - 1)
                return false;
 
        if ((y + size) - 1 >= gamezone.getSize() - 1)
            return false;
        cout << size;
        for (int i = 0; i < size; i++)
        {
            if (!(gamezone[y][x].first == KeyPoint::empty))
                return false;
            if (x > 0 && y > 0)
                if (!(gamezone[y - 1][x - 1].first == KeyPoint::empty))
                    return false;
            if (x > 0)
                if (!(gamezone[y][x - 1].first == KeyPoint::empty))
                    return false;
            if (x > 0 && y + 1 < gamezone.getSize())
                if (!(gamezone[y + 1][x - 1].first == KeyPoint::empty))
                    return false;
            if (y > 0)
                if (!(gamezone[y - 1][x].first == KeyPoint::empty))
                    return false;
            if (y + 1 < gamezone.getSize())
                if (!(gamezone[y + 1][x].first == KeyPoint::empty))
                    return false;
            if (x + 1 < gamezone.getSize() && y > 0)
                if (!(gamezone[y - 1][x + 1].first == KeyPoint::empty))
                    return false;
            if (x + 1 < gamezone.getSize())
                if (!(gamezone[y][x + 1].first == KeyPoint::empty))
                    return false;
            if (x + 1 < gamezone.getSize())
                if (!(gamezone[y][x + 1].first == KeyPoint::empty))
                    return false;
            if (x > 0 && y > 0)
                if (!(gamezone[y - 1][x - 1].first == KeyPoint::empty))
                    return false;
            if (y + 1 < gamezone.getSize() && (x + 1 < gamezone.getSize()))
                if (!(gamezone[y + 1][x + 1].first == KeyPoint::empty))
                    return false;
 
            if (horizontal)
                x++;
            else
                y++;
 
        }
        if (horizontal)
            x -= size;
        else
            y -= size;
        size++;
        cells.resize(size);
        cells[0].x = x;
        cells[0].y = y;
        gamezone[cells[0].y][cells[0].x].first = KeyPoint::deck;
        gamezone[cells[0].y][cells[0].x].second = horizontal;
        for (int i = 1; i < size; i++)
        {
            if (horizontal) {
                cells[i].x = x++;
                cells[i].y = y;
                gamezone[cells[i].y][cells[i].x].first = KeyPoint::deck;
                gamezone[cells[i].y][cells[i].x].second = horizontal;
            }
            else
            {
                cells[i].x = x;
                cells[i].y = y++;
                gamezone[cells[i].y][cells[i].x].first = KeyPoint::deck;
                gamezone[cells[i].y][cells[i].x].second = horizontal;
            }
        }
        shipState = KeyShip::created;
        return true;
    }
    void shoot(int x, int y)
    {
        if (gamezone[y][x].first == KeyPoint::animationDam || gamezone[y][x].first == KeyPoint::damage || gamezone[y][x].first == KeyPoint::dead || gamezone[y][x].first == KeyPoint::DontTouch)
        {
            throw ThisPointIsDeadOrDamage();
            return;
        }
        if (gamezone[y][x].first == KeyPoint::empty) {
            throw Mises();
            return;
        }
        if (gamezone[y][x].first == KeyPoint::deck) {
            gamezone[y][x].first = KeyPoint::animationDam;
            for (int i = 0; i < size; i++)
                if (gamezone[cells[i].y][cells[i].x].first == KeyPoint::animationDam || gamezone[cells[i].y][cells[i].x].first == KeyPoint::damage)
                    shipState = KeyShip::Destroyed;
                else {
                    shipState = KeyShip::safe;
                    return;
                }
        }
        if (shipState == KeyShip::Destroyed)
        {
 
            for (int i = 0; i < size; i++)
            {
                gamezone[cells[i].y][cells[i].x].first = KeyPoint::dead;
                int lx = cells[i].x;
                int ly = cells[i].y;
                if (lx - 1 >= 0 && ly - 1 >= 0 && (gamezone[ly - 1][lx - 1].first == KeyPoint::empty || gamezone[ly - 1][lx - 1].first == KeyPoint::DontTouch))
                    gamezone[ly - 1][lx - 1].first = KeyPoint::DontTouch;
 
                if (lx - 1 >= 0 && (gamezone[ly][lx - 1].first == KeyPoint::empty || gamezone[ly][lx - 1].first == KeyPoint::DontTouch))
                    gamezone[ly][lx - 1].first = KeyPoint::DontTouch;
 
                if (lx - 1 >= 0 && ly + 1 < gamezone.getSize() && (gamezone[ly + 1][lx - 1].first == KeyPoint::empty || gamezone[ly + 1][lx - 1].first == KeyPoint::DontTouch))
                    gamezone[ly + 1][lx - 1].first = KeyPoint::DontTouch;
 
                if (ly - 1 >= 0 && (gamezone[ly - 1][lx].first == KeyPoint::empty || gamezone[ly - 1][lx].first == KeyPoint::DontTouch))
                    gamezone[ly - 1][lx].first = KeyPoint::DontTouch;
 
                if (ly + 1 < gamezone.getSize() && (gamezone[ly + 1][lx].first == KeyPoint::empty || gamezone[ly + 1][lx].first == KeyPoint::DontTouch))
                    gamezone[ly + 1][lx].first = KeyPoint::DontTouch;
 
                if (lx + 1 < gamezone.getSize() && ly - 1 >= 0 && (gamezone[ly - 1][lx + 1].first == KeyPoint::empty || gamezone[ly - 1][lx + 1].first == KeyPoint::DontTouch))
                    gamezone[ly - 1][lx + 1].first = KeyPoint::DontTouch;
 
                if (lx + 1 < gamezone.getSize() && (gamezone[ly][lx + 1].first == KeyPoint::empty || gamezone[ly][lx + 1].first == KeyPoint::DontTouch))
                    gamezone[ly][lx + 1].first = KeyPoint::DontTouch;
 
                if (lx + 1 < gamezone.getSize() && ly + 1 < gamezone.getSize() && (gamezone[ly + 1][lx + 1].first == KeyPoint::empty || gamezone[ly + 1][lx + 1].first == KeyPoint::DontTouch))
                    gamezone[ly + 1][lx + 1].first = KeyPoint::DontTouch;
            }
        }
    }
    int getSize()
    {
        return size;
    }
    bool getHorizontal()
    {
        return  horizontal;
 
    }
    bool isMyCord(int x, int y)
    {
        for (int i = 0; i < size; i++)
            if (x == cells[i].x&&y == cells[i].y)
                return true;
        return false;
    }
    POINT getCord(int index)
    {
        if (index < size)
            return cells[index];
        else
            throw OutOfRange();
    }
    void remove()
    {
        for (int i = 0; i < size; i++)
            gamezone[cells[i].y][cells[i].x].first = KeyPoint::empty;
        size = 0;
        shipState = KeyShip::safe;
    }
 
};
class Colors
{
public:
    Colors() {  }
    static void setColorBgTex(int Bg = 0, int Tex = 15) {
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        Bg = Bg << 4 | Tex;
        SetConsoleTextAttribute(hConsole, Bg);
    }
    void Normal()
    {
        setColorBgTex();
    }
    void Blue()
    {
        setColorBgTex(17, 8);
    }
    void RedBg()
    {
        setColorBgTex(12, 15);
    }
    void Red()
    {
        setColorBgTex(4, 15);
    }
    void RedBlue()
    {
        setColorBgTex(17, 4);
    }
    void Yel()
    {
        setColorBgTex(6, 15);
    }
};
 
class Print
{
    Colors setCollor;
public:
    Print() { }
    void print(GameZone & myGameZone, GameZone & fireGameZone)
    {
        cout << "\n\n";
        cout << "\n  0 1 2 3 4 5 6 7 8 9  \t\t   0 1 2 3 4 5 6 7 8 9";
        int asciLat = 65;
        for (int i = 0; i < myGameZone.getSize(); i++)
        {
            cout << endl;
            cout << (char)asciLat;
            cout << " ";
            for (int j = 0; j < myGameZone.getSize(); j++)
            {
 
                if (myGameZone[i][j].second&&myGameZone[i][j < myGameZone.getSize() - 1 ? j + 1 : j - 1].first != KeyPoint::deck&& myGameZone[i][j < myGameZone.getSize() - 1 ? j + 1 : j - 1].first != KeyPoint::damage&& myGameZone[i][j < myGameZone.getSize() - 1 ? j + 1 : j - 1].first != KeyPoint::dead)
                {
 
                    prSymbol(myGameZone[i][j].first, false);
                    cout << " ";
                }
                else
                    if (myGameZone[i][j].second)
                        prSymbol(myGameZone[i][j].first, j == myGameZone.getSize() - 1 ? false : myGameZone[i][j].second);
                    else
                    {
                        prSymbol(myGameZone[i][j].first, j == myGameZone.getSize() - 1 ? false : myGameZone[i][j].second);
                        cout << " ";
                    }
 
 
            }
            cout << "\t\t";
            cout << (char)asciLat++;
            cout << "  ";
            for (int j = 0; j < myGameZone.getSize(); j++)
            {
 
                if (fireGameZone[i][j].second&&fireGameZone[i][j < fireGameZone.getSize() - 1 ? j + 1 : j - 1].first != KeyPoint::deck&& fireGameZone[i][j < fireGameZone.getSize() - 1 ? j + 1 : j - 1].first != KeyPoint::damage&& fireGameZone[i][j < fireGameZone.getSize() - 1 ? j + 1 : j - 1].first != KeyPoint::dead)
                {
                    if (fireGameZone[i][j].first == KeyPoint::deck)
                        prSymbol(KeyPoint::empty, false);
                    else
                        prSymbol(fireGameZone[i][j].first, false);
                    cout << " ";
                }
                else
                    if (fireGameZone[i][j].second)
                    {
                        if (fireGameZone[i][j].first == KeyPoint::deck) {
                            prSymbol(KeyPoint::empty, j == fireGameZone.getSize() - 1 ? false : fireGameZone[i][j].second);
                            cout << " ";
                        }
                        else
                            prSymbol(fireGameZone[i][j].first, j == fireGameZone.getSize() - 1 ? false : fireGameZone[i][j].second);
                    }
                    else
                    {
                        if (fireGameZone[i][j].first == KeyPoint::deck)
                            prSymbol(KeyPoint::empty, j == fireGameZone.getSize() - 1 ? false : fireGameZone[i][j].second);
                        else
                            prSymbol(fireGameZone[i][j].first, j == fireGameZone.getSize() - 1 ? false : fireGameZone[i][j].second);
                        cout << " ";
                    }
            }
 
        }
    }
    void prSymbol(int num, bool horizontal)
    {
        Colors setCollor;
        switch (num)
        {
        case KeyPoint::empty:
        {
 
            cout << "#";
            break;
        }
        case KeyPoint::deck:
        {
            setCollor.Blue();
            cout << "O";
            setCollor.Normal();
            if (horizontal)
            {
                setCollor.Blue();
                cout << " ";
                setCollor.Normal();
            }
            break;
        }
        case KeyPoint::DontTouch:
        {
            setCollor.Blue();
            cout << "*";
            setCollor.Normal();
            break;
        }
        case KeyPoint::animationDam:
        {
            setCollor.Red();
            cout << (char)178;
            Sleep(200);
            cout << '\b';
            setCollor.Yel();
            cout << (char)255;
            Sleep(200);
            cout << '\b';
            setCollor.RedBlue();
            cout << (char)254;
            Sleep(200);
            cout << '\b';
            setCollor.Red();
            cout << (char)176;
            setCollor.Normal();
            break;
 
        }
        case KeyPoint::dead:
        {
            setCollor.Red();
            cout << "X";
            setCollor.Normal();
            if (horizontal)
            {
                setCollor.Red();
                cout << " ";
                setCollor.Normal();
            }
            break;
        }
        case KeyPoint::damage:
        {
            setCollor.RedBg();
            cout << (char)176;
            setCollor.Normal();
            if (horizontal)
            {
                setCollor.RedBg();
                cout << " ";
                setCollor.Normal();
            }
            break;
        }
        default:
        {
            cout << (char)num;
            break;
        }
        }
    }
 
 
};
class Button : public Mouse
{
    POINT startPoint;
    string text;
    POINT upLPoint;
    POINT downRPoint;
public:
    Button(int  xcursorPoint, int ycursorPoint, string text, int xUpLPoint, int yUpLPoint, int xDownRPoint, int yDownRPoint)
    {
        upLPoint.x = xUpLPoint;
        upLPoint.y = yUpLPoint;
        downRPoint.x = xDownRPoint;
        downRPoint.y = yDownRPoint;
        startPoint.x = xcursorPoint;
        startPoint.y = ycursorPoint;
        this->text = text;
    }
    void print()
    {
        COORD p;
        Colors setColor;
        p.X = startPoint.x;
        p.Y = startPoint.y;
        SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), p);
        setColor.Yel();
        cout << text;
        setColor.Normal();
    }
    bool check(POINT mouse)
    {
        if (checkZone(upLPoint, downRPoint, mouse))
            if (isLButtonDown())
            {
                while (!isLButtonDown());
                return true;
            }
        return false;
 
    }
};
 
class Game
{
    GameZone myGameZone;
    GameZone fireGameZone;
    Ship myShips[10]{ myGameZone,myGameZone,myGameZone,myGameZone,myGameZone,myGameZone,myGameZone,myGameZone,myGameZone,fireGameZone };
    Ship fireShips[10]{ fireGameZone,fireGameZone,fireGameZone,fireGameZone,fireGameZone,fireGameZone,fireGameZone,fireGameZone,fireGameZone,fireGameZone };
public:
    Game()
    {
 
        int l = 4;
        for (int i = 0; i < 10; i++) {
            if (i == 1)
                l--;
            if (i == 4)
                l--;
            if (i == 5)
                l--;
            while (!myShips[i].Create(l, rand() % 10, rand() % 10, rand() % 2));
            while (!fireShips[i].Create(l, rand() % 10, rand() % 10, rand() % 2));
        }
    }
    void game()
    {
        POINT pMouse = Mouse::getPointMouse();
        cout << "\n\n\t\t\t ARRANGE YOUR SHIPS " << endl;
        POINT  upL;
        POINT downR;
        upL.x = 24;
        upL.y = 127;
        downR.x = 39;
        downR.y = 141;
        Button startB(32, 24, "start", 264, 319, 305, 331);
        while (!startB.check(pMouse))
        {
          pMouse = Mouse::getPointMouse();
          print();
          if (Mouse::isRButtonDown())//эта часть!
          {
              POINT cell = getCellGameZone(upL, downR, pMouse);
              if (cell.x == -1)
                  continue;
              for (int i = 0; i < 10; i++)
                  if (myShips[i].isMyCord(cell.x, cell.y))
                      while (Mouse::isRButtonDown())
                      {
                        
                          bool horizontal = myShips[i].getHorizontal();
                          POINT cell1 = getCellGameZone(upL, downR, pMouse);
                          const int size = myShips[i].getSize();
                          if (cell1.x != cell.x || cell1.y != cell.y)
                          {
                        
                              POINT newCordShip;
                              if ((cell.x - cell1.x) == 0)
                                  newCordShip.x = 0;
                              else
                              newCordShip.x = (cell.x - cell1.x)*-1;
                              if ((cell.y - cell1.y) == 0)
                                  newCordShip.y = 0;
                              else
                              newCordShip.y = (cell.y - cell1.y)*-1;
                              POINT oldCordShip = myShips[i].getCord(0);
                              newCordShip.x += oldCordShip.x;       
                              newCordShip.y += oldCordShip.y;
                              myShips[i].remove();
                              if (myShips[i].Create(size, newCordShip.x, newCordShip.y, horizontal))
                                  cell = cell1;
                          }
 
 
                      }
          }
 
        }
        cout << "autofack";
    }
    POINT getCellGameZone(POINT upLFirstCell, POINT downRFirstCell, POINT pMouse)
    {
    
            POINT get;
            get.x = -1;
            get.y = -1;
        const int xmU = upLFirstCell.x;
        const int xmD = downRFirstCell.x;
            int lenght;
        for (int i = 0; i < myGameZone.getSize(); i++) {
            for (int j = 0; j < myGameZone.getSize(); j++)
            {
                
                if (Mouse::checkZone(upLFirstCell, downRFirstCell,pMouse))
                {
                    get.x = j;
                    get.y = i;
                    return get;
                }
                 lenght = downRFirstCell.x - upLFirstCell.x;
                upLFirstCell.x +=lenght;
                downRFirstCell.x += lenght;
            }
             lenght = downRFirstCell.y - upLFirstCell.y;
            upLFirstCell.y +=lenght+2;
            downRFirstCell.y += lenght+2;
            downRFirstCell.x = xmD;
            upLFirstCell.x = xmU;
        }
        return get;
    }
    void print()
    {
        Print  print;
        print.print(myGameZone, fireGameZone);
    }
};
void main()
{
 
    Button button(32, 24, "start", 264, 319, 305, 331);
    Game game;
        game.game();
    
    system("pause");
}
__________________
Помощь в написании контрольных, курсовых и дипломных работ, диссертаций здесь
0
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
14.02.2020, 19:33
Ответы с готовыми решениями:

Написать алгоритмы реализации игры "Морской бой"
Здравствуйте. На форуме в первый раз, если что то куда то не туда написал, прошу не пинайте. Вот...

Написать консольный морской бой с использованием ООП
Вечер добрый! Хочу написать консольный морской бой. Требования такие: 1. Поле должно быть...

Случайное распределение кораблей по полю в игре "морской бой"
Привет всем кто читал мой предыдущий пост про векторы в морском боем, в той же фунции появилась...

"Морской Бой": найти причины возникновения ошибок в коде
Доброго добра Всем тем, кто сейчас зашёл на эту страницу. Помогите понять, почему arr1 и arr2 в...

9
6574 / 4559 / 1843
Регистрация: 07.05.2019
Сообщений: 13,726
14.02.2020, 19:46 2
Лучший ответ Сообщение было отмечено lamerman как решение

Решение

Цитата Сообщение от lamerman Посмотреть сообщение
нужно сделать так что бы при расстановке кораблей ,пользователь брал корабль мышкой и переносил в желаемую точку поля
уже неделю сижу,не хватает мозга
Рекомендую забить на корабли и сделать для начала простое консольное приложение - которое просто перетаскивает точку мышкой. А уже потом усложнять задачу.
1
Нарушитель
8298 / 4372 / 1002
Регистрация: 12.03.2015
Сообщений: 20,433
14.02.2020, 20:42 3
Рекомендую забить на простое консольное приложение и начинать делать GUI-программу с отрисовкой кораблёв с помощью GDI (пока без плюса).

А то смотрю в кодовой врезке эти 54 метра кода консольного безумия и глаза мои кровоточат.
0
6574 / 4559 / 1843
Регистрация: 07.05.2019
Сообщений: 13,726
14.02.2020, 20:47 4
Цитата Сообщение от Verevkin Посмотреть сообщение
Рекомендую забить на простое консольное приложение и начинать делать GUI-программу с отрисовкой кораблёв с помощью GDI (пока без плюса).
А то смотрю в кодовой врезке эти 54 метра кода консольного безумия и глаза мои кровоточат.
А что поменяется?
0
Нарушитель
8298 / 4372 / 1002
Регистрация: 12.03.2015
Сообщений: 20,433
14.02.2020, 21:21 5
Цитата Сообщение от oleg-m1973 Посмотреть сообщение
А что поменяется?
Концепция.
0
6574 / 4559 / 1843
Регистрация: 07.05.2019
Сообщений: 13,726
14.02.2020, 21:27 6
Цитата Сообщение от Verevkin Посмотреть сообщение
Концепция.
Не, не поменяется. Проблемы просто станут другими. Станет проще посоветовать, как управлять мышкой, но всё остальное - сложнее.
0
Нарушитель
8298 / 4372 / 1002
Регистрация: 12.03.2015
Сообщений: 20,433
14.02.2020, 21:33 7
Цитата Сообщение от oleg-m1973 Посмотреть сообщение
Не, не поменяется. Проблемы просто станут другими. Станет проще посоветовать, как управлять мышкой, но всё остальное - сложнее.
Не буду спорить, патамушта лень.
Я - delphi-программёр.
0
5667 / 3113 / 1299
Регистрация: 07.02.2019
Сообщений: 7,807
14.02.2020, 23:42 8
Лучший ответ Сообщение было отмечено lamerman как решение

Решение

lamerman, страдал фигней когда то, рисунок можно перетаскивать мышкой, может пригодится
Кликните здесь для просмотра всего текста
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
#include <Windows.h> 
#include <vector>
#include <cctype>
#include <cmath>
////////////////////////////////////////////////////////////////////////////////////////////////////
#define SET_FLAG(val, flag) ((val) |= (flag))
#define UNSET_FLAG(val, flag) ((val) &= ~(flag))
////////////////////////////////////////////////////////////////////////////////////////////////////
enum class BColor
{   // цвета фона
    Black = 0,
    Red = BACKGROUND_RED,
    Green = BACKGROUND_GREEN,
    Blue = BACKGROUND_BLUE,
    Yellow = Red | Green,
    Violet = Red | Blue,
    Turquoise = Green | Blue,
    White = Red | Green | Blue
};
////////////////////////////////////////////////////////////////////////////////////////////////////
enum class FColor
{   // цвета символа
    Black = 0,
    Red = FOREGROUND_RED,
    Green = FOREGROUND_GREEN,
    Blue = FOREGROUND_BLUE,
    Yellow = Red | Green,
    Violet = Red | Blue,
    Turquoise = Green | Blue,
    White = Red | Green | Blue
};
////////////////////////////////////////////////////////////////////////////////////////////////////
struct Sprite
{   // стандартный объект для отрисовки
    PCHAR texture{};                    // указатель на буфер символов
    COORD size{};                       // размер буфера (X - столбцы, Y - строки)
    COORD pos{};                        // координаты верхнего левого угла
    FColor textColor{ FColor::White };  // цвет символов
    BColor backColor{ BColor::Black };  // цвет фона(используется только если transperent == false)
    bool transparent{ true };           // флаг отрисовки цвета фона
};
////////////////////////////////////////////////////////////////////////////////////////////////////
struct NonCopy
{
    NonCopy() = default;
    NonCopy(const NonCopy&) = delete;
    NonCopy& operator=(const NonCopy&) = delete;
};
////////////////////////////////////////////////////////////////////////////////////////////////////
class ScreenBuffer : NonCopy
{
public:
    
    ScreenBuffer(COORD size);
    ~ScreenBuffer();
    
    void Draw(PCHAR data, COORD size, COORD pos, FColor textColor = FColor::White, BColor backColor = BColor::Black, bool transparent = true);
    void Draw(const Sprite& obj);
    void DrawChar(CHAR ch, COORD pos, FColor color);
    void DrawLine(COORD first, COORD second, CHAR ch, FColor color);
    
    void Clear(BColor color);
    void Display();
    bool IsOpen();
    void Close();
 
    bool PollEvent(INPUT_RECORD& event);
 
    int GetError();
 
private:
 
    int error{};                    // код ошибки
    bool state{};                   // состояние
    HANDLE hDefault;                // сохраненный дескриптор экранного буфера консоли
    HANDLE hOutput;                 // дескриптор создаваемого экранного буфера консоли
    HANDLE hInput;                  // дескриптор 
    COORD bufSize;                  // размер буфера
    SMALL_RECT winRect;             // прямоугольник окна
    std::vector<CHAR_INFO> bufData; // временный буфер данных (в него предварительно рисуем)
};
////////////////////////////////////////////////////////////////////////////////////////////////////
#include <iostream>
////////////////////////////////////////////////////////////////////////////////////////////////////
struct Rect
{   // объект, который можно перетаскивать мышкой
    Sprite image{};
    bool selected{};
    COORD lastPos{};
 
    void update(COORD mousePos, bool lButton);
};
////////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    COORD winSize{ 80, 40 };
    ScreenBuffer win(winSize);
 
    if (!win.IsOpen())
    {
        std::cerr << win.GetError() << '\t' << GetLastError() << '\n';
    };
 
    CHAR texture[]
    {
        "##########"
        "#        #"
        "# ###### #"
        "# #    # #"
        "# # ## # #"
        "# # ## # #"
        "# #    # #"
        "# ###### #"
        "#        #"
        "##########"
    };
 
    Rect obj;
    obj.image.pos = COORD{ 10, 10 };
    obj.image.size = COORD{ 10, 10 };
    obj.image.texture = texture;
    obj.image.textColor = FColor::Red;
    
    while (win.IsOpen())
    {
        INPUT_RECORD eve;
        while (win.PollEvent(eve))
        {
            switch (eve.EventType)
            {
            case KEY_EVENT:
                if (eve.Event.KeyEvent.wVirtualKeyCode == VK_ESCAPE)
                    win.Close();
                break;
            case MOUSE_EVENT:
                obj.update
                (
                    eve.Event.MouseEvent.dwMousePosition,
                    eve.Event.MouseEvent.dwButtonState & FROM_LEFT_1ST_BUTTON_PRESSED
                );
                break;
            }
        }
 
        win.Clear(BColor::White);
        win.Draw(obj.image);
        win.Display();
    }
}
////////////////////////////////////////////////////////////////////////////////////////////////////
void Rect::update(COORD mousePos, bool lButton)
{
    if (!lButton)
    {
        selected = false;
        image.textColor = FColor::Red;
        return;
    }
    if (!selected)
    {
        if (image.pos.X <= mousePos.X &&
            mousePos.X <= image.pos.X + image.size.X &&
            image.pos.Y <= mousePos.Y &&
            mousePos.Y <= image.pos.Y + image.size.Y)
        {
            selected = true;
            image.textColor = FColor::Green;
            lastPos = mousePos;
            return;
        }
    }
    else
    {
        image.pos.X += mousePos.X - lastPos.X;
        image.pos.Y += mousePos.Y - lastPos.Y;
        lastPos = mousePos;
    }
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// конструктор принимает размер окна
// size.X - ширина
// size.Y - высота
ScreenBuffer::ScreenBuffer(COORD size)
    :
    hDefault(GetStdHandle(STD_OUTPUT_HANDLE)),
    hOutput(CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL)),
    hInput(GetStdHandle(STD_INPUT_HANDLE)),
    bufSize(size),
    winRect{ 0, 0, size.X - 1, size.Y - 1 }
{                                                                                       // коды ошибок (можно получить методом GetError)
    if (size.X < 0 || size.Y < 0) return; ++error;                                      // 0
    bufData.resize(size.X * size.Y);
    CONSOLE_CURSOR_INFO hideCursor{ 1, FALSE };
    if
        (
            hDefault != INVALID_HANDLE_VALUE && ++error &&                              // 1
            hOutput != INVALID_HANDLE_VALUE && ++error &&                               // 2
            hInput != INVALID_HANDLE_VALUE && ++error &&                                // 3
            SetConsoleCursorInfo(hOutput, &hideCursor) && ++error &&                    // 4
            SetConsoleWindowInfo(hOutput, TRUE, &winRect) && ++error &&                 // 5
            SetConsoleScreenBufferSize(hOutput, size) && ++error &&                     // 6
            SetConsoleWindowInfo(hOutput, TRUE, &winRect) && ++error &&                 // 7
            SetConsoleActiveScreenBuffer(hOutput) && ++error &&                         // 8
            SetConsoleMode(hInput, ENABLE_MOUSE_INPUT) && ++error                       // 9
            )
        state = true;
}
 
ScreenBuffer::~ScreenBuffer()
{
    Close();
    CloseHandle(hDefault);
    CloseHandle(hOutput);
    CloseHandle(hInput);
}
 
void ScreenBuffer::Draw(PCHAR data, COORD size, COORD pos, FColor textColor, BColor backColor, bool transparent)
{   // отрисовка буфера символов во временный буфер
    // смысл параметров аналогичен полям класса Sprite
    if (!data) return;
 
    int jMax = min(bufSize.X, pos.X + size.X);
    int iMax = min(bufSize.Y, pos.Y + size.Y);
    for (int i = max(0, pos.Y); i < iMax; ++i)
    {
        for (int j = max(0, pos.X); j < jMax; ++j)
        {
            int jSrc = j - pos.X;
            int iSrc = i - pos.Y;
 
            auto& ch_in = data[iSrc * size.X + jSrc];
            if (!ch_in || std::isspace(ch_in)) continue;
 
            auto& ch_out = bufData[i * bufSize.X + j];
            ch_out.Char.AsciiChar = ch_in;
 
            UNSET_FLAG(ch_out.Attributes, static_cast<WORD>(FColor::White));
            SET_FLAG(ch_out.Attributes, static_cast<WORD>(textColor));
            if (!transparent)
            {
                UNSET_FLAG(ch_out.Attributes, static_cast<WORD>(BColor::White));
                SET_FLAG(ch_out.Attributes, static_cast<WORD>(backColor));
            }
        }
    }
}
 
void ScreenBuffer::Draw(const Sprite & obj)
{   // отрисовка стандартного объекта
    Draw(obj.texture, obj.size, obj.pos, obj.textColor, obj.backColor, obj.transparent);
}
 
void ScreenBuffer::DrawChar(CHAR ch, COORD pos, FColor color)
{   // отрисовка символа по координатам
    int idx = pos.Y * bufSize.X + pos.X;
    if (0 <= idx && idx < bufData.size())
    {
        bufData[idx].Char.AsciiChar = ch;
        UNSET_FLAG(bufData[idx].Attributes, static_cast<WORD>(FColor::White));
        SET_FLAG(bufData[idx].Attributes, static_cast<WORD>(color));
    }
}
 
void ScreenBuffer::DrawLine(COORD first, COORD second, CHAR ch, FColor color)
{   // отрисовка линии (алгоритм Брезенхэма)
    const int deltaX = std::abs(static_cast<int>(second.X) - first.X);
    const int deltaY = std::abs(static_cast<int>(second.Y) - first.Y);
    const SHORT signX = first.X < second.X ? 1 : -1;
    const SHORT signY = first.Y < second.Y ? 1 : -1;
 
    int delta = deltaX < deltaY ? deltaY : deltaX;
    int errorX{}, errorY{};
 
    DrawChar(ch, first, color);
    while (first.X != second.X || first.Y != second.Y)
    {
        errorX += deltaX;
        errorY += deltaY;
 
        if (delta < errorX)
        {
            errorX -= delta;
            first.X += signX;
        }
        if (delta < errorY)
        {
            errorY -= delta;
            first.Y += signY;
        }
        DrawChar(ch, first, color);
    }
}
 
void ScreenBuffer::Clear(BColor color)
{   // очистка временного буфера цветом color
    CHAR_INFO ch{ bufData[0] };
    UNSET_FLAG(ch.Attributes, static_cast<WORD>(BColor::White));
    SET_FLAG(ch.Attributes, static_cast<WORD>(color));
    ch.Char.AsciiChar = ' ';
    std::vector<CHAR_INFO>{ bufData.size(), ch }.swap(bufData);
}
 
void ScreenBuffer::Display()
{   // отображение содержимого временного буфера на экране
    if (state)
    {
        state = WriteConsoleOutput(hOutput, bufData.data(), bufSize, {}, &winRect); // 10
        if (!state) ++error;
    }
}
 
bool ScreenBuffer::IsOpen()
{   // состояние буфера
    return state;
}
 
void ScreenBuffer::Close()
{   // закрытие буфера
    ++error;
    state = false;
    SetConsoleActiveScreenBuffer(hDefault);
}
 
bool ScreenBuffer::PollEvent(INPUT_RECORD & event)
{   // считывает события
    if (!state) return false;
    DWORD count = 0;
    GetNumberOfConsoleInputEvents(hInput, &count);
    if (!count) return false;
    state = ReadConsoleInput(hInput, &event, 1, &count); // 11
    if (!state) ++error;
    return count;
}
 
int ScreenBuffer::GetError()
{   // возвращает код ошибки
    return error;
}
0
585 / 559 / 91
Регистрация: 29.05.2015
Сообщений: 3,609
15.02.2020, 09:00 9
Круче консольного приложения с графикой может быть только приложение на ассемблере с графикой.
0
Don't worry, be happy
17779 / 10543 / 2035
Регистрация: 27.09.2012
Сообщений: 26,513
Записей в блоге: 1
15.02.2020, 09:26 10
Цитата Сообщение от alexu_007 Посмотреть сообщение
может быть только приложение на ассемблере с графикой.
Оно сводится к вызову апи-функций, что просто более многословно, но не особо сложнее.

Не по теме:

P.S. Где-то у меня был морской бой на асме с gui. В прошлом году писал. )

0
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
15.02.2020, 09:26
Помогаю со студенческими работами здесь

Есть у кого-нибудь исходник игры "Морской Бой"?
Ребят, может у кого завалялся исходник &quot;Морского Боя&quot;?

Найти и исправить ошибки (игра "Морской бой")
Ребят. На с++ пишу недавно. Решил сделать простенькую игру: &quot;Морской бой&quot;. Игра будет происходит...

Проблемы с реализацией игры "Морской бой": найти и исправить ошибки в коде
Доброго времени суток. У меня вопрос по игре &quot;Морской бой&quot;. Я вывел поле с написанными координатами...

"Морской бой": массив указателей на объекты vs контейнер stl. Что лучше?
Задание такое: Задача№2 Разработать программу «Морской бой», где пользователь будет видеть свои 2...


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

Или воспользуйтесь поиском по форуму:
10
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin
Copyright ©2000 - 2023, CyberForum.ru