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

Игра Арканоид - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Не могу запустить g++ http://www.cyberforum.ru/cpp-beginners/thread1545707.html
Добрый день, только что установила MinGW для win32, пробовала прописывать путь до папки C:\MinGW\bin в системные переменные Path или PATH, но при запуске g++ из cmd он не определяется.
C++ В чем плюсы лямбд? В чем очевидные и/или измеряемые плюсы лямбд в C++? Повышает ли это скорость кода? Или памяти меньше? Или еще что-то? Ну кроме повышения ЧСВ и того что это стильно-модно-молодежно? Слышал еще, что знание лямбд позволяет подкатывать к девушкам (типа "Детка, пойдем ко мне? Покажу тебе свои лямбда-исчисления8-) А затем мы апплицируем одну интересную лямбда-абстракцию под номером 69 которую я только... http://www.cyberforum.ru/cpp-beginners/thread1545696.html
Доступ к private переменной класса из его потомка C++
Здравствуйте! Как получить доступ к закрытой переменной родительского класса в методе наследника? #include <stdio.h> class Fowler { private: int c; };
Вывод данных из двумерного вектора C++
Здравстуйте, проблема состоит в том, что мне надо записать несколько строк разных данных в разные вектора, эти вектора вложить в другой вектора и потом вывести. Как вкладывать данные в вектор знаю, как вывести одномерный вектор знаю, но не получается вывести в конце уже данные из большего вектора.
C++ Написать программу-обработчик запись слов в обратном порядке http://www.cyberforum.ru/cpp-beginners/thread1545682.html
Написать программу-обработчик текстовых файлов, которая создавала бы текстовый файл, в котором слова будут написаны наоборот. Слова которые начинаются с большой буквы, должны начинаться с большой. Файл-источник, файл приемщик написать в командной строке сразу за исполнительным файлом. подскажите как каждое слово записать в обратном порядке?
C++ Расшифровка шифра Виженера Здравствуйте, помогите пожалуйста разобраться. У меня задания расшифровать шифр Виженера. Ключ <=5 Дальше весь закодированный текст писать не буду. Я так понимаю сначала надо найти длину ключа, потом сам ключ и дальше кодировать. Подскажите пожалуйста как это делать сделать нужно на С++. Где можно почитать. А еще лучше где с примерами. Или кто сам опытом поделится подробнее

Показать сообщение отдельно
UltraPenguin
222 / 88 / 22
Регистрация: 20.03.2014
Сообщений: 296
Завершенные тесты: 1
06.10.2015, 18:49     Игра Арканоид
1) Не используйте "магических цифр". Любую константу старайтесь именовать. Облегчает чтение и понимание кода.
2) Классы на то и классы, что должны аккумулировать внутри себя логику поведения объекта и предоставлять интерфейс в виде функций для воздействия на объект. Поэтому я перенес некоторые переменные и логику из Field в нужные классы.
3) Про правило 1 класс - 2 файла не забываем. Так же сделаете сами.

Может что-то уже забыл... если вспомню дополню.

Что я сделал: отрефакторил код архитектурно.
Что я не сделал: не менял логику работы и вычислений (вроде бы).
Кое-что, помеченное TODO, я специально оставил для ваших рук.

Вот вам пластилин для дальнейшего творчества:
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
namespace Constants
{
    const int coordsNum         = 4;
    const int leftBottomCoords  = 0;
    const int leftTopCoords     = 3;
    const int rightBottomCoords = 1;
    const int rightTopCoords    = 2;
 
    const int defaultRadius = 5;
    const int defaultSpeed  = 3;
 
    const int defaultHalfWidth  = 25;
    const int defaultHalfHeight = 5;
}
//==================================================================================================
typedef struct strControls
{
    //TODO: дать возможность переназначать клавиши
    unsigned char goLeft = 97;
    unsigned char goRight = 100;
    unsigned char shootBall = 49;
} Controls;
Controls controls;
//==================================================================================================
typedef struct strCoords
{
    int x;
    int y;
    strCoords() : x(0), y(0){}
    strCoords(int x, int y) : x(x), y(y) {}
    void setXY(const int& x, const int& y) { this->x = x; this->y = y;}
} Coords;
 
class Object {
private:
    Coords center;
    bool deleted; // Метка на удаление
    int red; //Не стоит постоянно передавать одни и те же параметры, сделаем цвет хранимым
    int green;
    int blue;
public:
    Object() : deleted(false){}
    Object(int x, int y) : center(x, y), deleted(false){}
 
    const bool isDeleted(void) const { return deleted; }
    void markForDelete(void) { deleted = true; } // Сеттер не нужен. То что помечено, должно быть удалено.
    const int getX(void) const { return center.x; }
    const int getY(void) const { return center.y; }
    void setX(const int& x) { this->center.x = x; }
    void setY(const int& y) { this->center.y = y; }
    void setXY(const int& x, const int& y) { this->center.setXY(x, y); }
    void setRGB(const int& Red, const int& Green, const int& Blue) { red = Red; green = Green; blue = Blue;}
    virtual void draw(void) = 0;
};
//==================================================================================================
class Elems : public Object
{
private:
    Coords coords[Constants::coordsNum];
public:
    Elems() : Object() {
        setCoords();
    }
    Elems(int x, int y) : Object(x, y){
        setCoords();
    }
 
    const int getLeftBX(void) const { return coords[Constants::leftBottomCoords].x; }
    const int getLeftBY(void) const { return coords[Constants::leftBottomCoords].y; }
    const int getLeftTX(void) const { return coords[Constants::leftTopCoords].x; }
    const int getLeftTY(void) const { return coords[Constants::leftTopCoords].y; }
 
    const int getRightBX(void) const { return coords[Constants::rightBottomCoords].x; }
    const int getRightBY(void) const { return coords[Constants::rightBottomCoords].y; }
    const int getRightTX(void) const { return coords[Constants::rightTopCoords].x; }
    const int getRightTY(void) const { return coords[Constants::rightTopCoords].y; }
 
    void setCoords(void) {
        int x = getX(), y = getY();
        coords[0].setXY(x - Constants::defaultHalfWidth, y - Constants::defaultHalfHeight);
        coords[1].setXY(x + Constants::defaultHalfWidth, y - Constants::defaultHalfHeight);
        coords[2].setXY(x + Constants::defaultHalfWidth, y + Constants::defaultHalfHeight);
        coords[3].setXY(x - Constants::defaultHalfWidth, y + Constants::defaultHalfHeight);
    }
 
    void ballCollisionOccured(void) // Теперь можно добавить разные типы блоков и по разному обрабатывать столкновения
    {
        markForDelete();
    }
 
    virtual void draw(void) {
        setCoords();
        glColor3d(red, green, blue);
        glBegin(GL_POLYGON);
        glVertex2d(coords[0].getX(), coords[0].getY());
        glVertex2d(coords[1].getX(), coords[1].getY());
        glVertex2d(coords[2].getX(), coords[2].getY());
        glVertex2d(coords[3].getX(), coords[3].getY());
        glEnd();
    }
};
//==================================================================================================
class Player : public Elems
{
    //TODO: добавить текущий счет и имя игрока
    //TODO: границы также можно проименовать
public:
    Player() : Elems() {}
    Player(int x, int y) : Elems(x, y) {}
    // Будем держать всю логику перемещений игрока в одном месте.
    void move(const int& dist)
    {
        int x = getX();
        if ((dist > 0 && x < 125) || (dist < 0 && x > -125))
            setX(x + dist);
    }
};
//==================================================================================================
class Ball : public Object
{
private :
    unsigned int Radius;
    int velocity[2];
public:
    Ball() : Object(), Radius(Constants::defaultRadius) {}
    Ball(int x, int y) : Object(x, y), Radius(Constants::defaultRadius) {}
 
    const unsigned int getRadius(void) const { return Radius; }
    void setRadius(const unsigned int& Radius) { this->Radius = Radius; }
 
    void setVelocityX(const int& x) { velocity[0] = x; }
    void setVelocityY(const int& y) { velocity[1] = y; }
 
    virtual void draw(void)
    {
        glColor3d(red, green, blue);
        glBegin(GL_POINTS);
        int BallX, BallY, x = getX() , y = getY();
        for (float angle = 0.3; angle < 6.4; angle += 0.1) {
            BallX = Radius * cosf(angle);
            BallY = Radius * sinf(angle);
            glVertex2d(BallX + x, BallY + y);
        }
        glEnd();
    }
 
    void checkCollisionWithPlayer(const Player* player)
    {
        if (getY() == player->getY() + 2 &&
            getX() > player->getLeftTX() - Radius &&
            getX() < player->getRightTX() + Radius)
            velocity[1] = 1;
    }
 
    bool checkCollisionWithBlock(const Elems* block)
    {
        int x = getX(), y = getY();
        if (block->getLeftBY() == y &&
            x > block->getLeftBX() - 2 &&
            x < block->getRightBX() + 2)
        {
            velocity[1] = -1;
            return true;
        }
 
        if (block->getLeftTY() == y &&
            x > block->getLeftTX() - 2 &&
            x < block->getRightTX() + 2)
        {
            velocity[1] = 1;
            return true;
        }
 
        if (block->getLeftBX() == x &&
            y > block->getLeftBY() + 1 &&
            y < block->getLeftTY() - 1)
        {
            velocity[0] = -1;
            return true;
        }
 
        if (block->getRightBX() == x &&
            y > block->getRightBY() + 1 &&
            y < block->getRightTY() - 1)
        {
            velocity[0] = 1;
            return true;
        }
        return false;
    }
 
    void move(void)
    {
        setX(getX() + velocity[0]);
        setY(getY() + velocity[1]);
        if (getX() < -150)
            velocity[0] = 1;
        else
        {
            if (getX() > 150) // Внес внутри блока чтобы проверка не срабатывала вхолостую
                velocity[0] = -1;
        }
 
        if (getY() > 120)
            velocity[1] = -1;
        else
        {
            if (getY() < -120) // Внес внутри блока чтобы проверка не срабатывала вхолостую
                velocity[1] = 1;
        }
    }
};
//==================================================================================================
class Field {
private:
    bool ballState;
    int speed = Constants::defaultSpeed;
 
    std::vector<Elems*> blocks;
    Player player;
    Ball ball;
 
    void createField(void) {
        //TODO: сделать сохранение/загрузку уровней
        unsigned int BlocksNum = 16;
        Elems* block;
        for (int i = 0, x = -105, y = 100; i < BlocksNum; ++i, x += 70)
        {
            block = new Elems;
            block->setXY(x, y);
            blocks.push_back(block);
 
            if (i % 4 == 3)
            {
                x -= 280;
                y -= 25;
            }
        }
    }
public:
 
    Field() :
        player(0, -100), ball(player.getX(), player.getY() + 10), ballState(false)
    {
        player.setRGB(255, 0, 0); //TODO: этого кода можно избежать, используя конструкторы
        ball.setRGB(0, 0, 255);
        createField();
        int num = blocks.size();
        for (int i = 0; i < num; ++i)
            blocks[i]->setRGB(255, 255, 0);
    }
    ~Field()
    {
        if (!blocks.empty())
        {
            for (int i = 0; i < blocks.size(); ++i)
                delete blocks[i];
        }
    }
 
    void setBallState(const bool& ballState) { this->ballState = ballState; }
 
    void draw(void)
    {
        int num = blocks.size();
        for (int i = 0; i < num; ++i)
            blocks[i]->draw();
        player.draw();
        ball.draw();
    }
 
    void playerMove(const unsigned char& key)
    {
        if (key == controls.goRight)
            player.move(5);
        else // Убрал лишнюю проверку, у нас и так либо одна клавиша либо другая за счет keyboard()
            player.move(-5);
        if (ballState == false)
        {
            ball.setX(player.getX());
            if (player.getX() < 0)
            {
                ball.setVelocityX(-1);
                ball.setVelocityY(1);
            }
            else
            {
                ball.setVelocityX(1);
                ball.setVelocityY(1);
            }
        }
    }
 
    void ballTick(void)
    {
        for (int j = 0; j < speed; ++j)
        {
            ball.move();
 
            ball.checkCollisionWithPlayer(&player);
 
            int num = blocks.size();
            for (int i = 0; i < num; ++i)//перебор всех блоков
                if (ball.checkCollisionWithBlock(blocks[i]))
                    blocks[i]->ballCollisionOccured();
 
            for (int i = 0; i < blocks.size(); ++i)
                if (blocks[i]->isDeleted())
                    delete blocks[i];
 
        }
    }
} field;
//==================================================================================================
void displayGame(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    field.draw();
    field.ballTick();
    glFlush();
}
//==================================================================================================
void keyboard(unsigned char key, int, int)
{
    if (key == controls.goRight || key == controls.goLeft)
    {
        field.playerMove(key);
        return;
    }
 
    if (key == controls.shootBall)
        field.setBallState(true);
}
 
Текущее время: 07:21. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru