Неизвестно почему нерабочий тетрис в 400 строк

#ifndef TETRIS_H
#define TETRIS_H
 
#include <cstdlib>
#include <GL/freeglut.h>
#include <iostream>
#include <stdlib.h>
#include <time.h>
 
using namespace std;
 
 
#define _SCALE 20
#define _HEIGHT 12
#define _WIDTH 8
#define _TICK 250
 
#define _RIGHT 0
#define _RIGHT_KEY GLUT_KEY_RIGHT
#define _UP 1
#define _UP_KEY GLUT_KEY_UP
#define _LEFT 2
#define _LEFT_KEY GLUT_KEY_LEFT
#define _DOWN 3
#define _DOWN_KEY GLUT_KEY_DOWN
 
#endif /* MAIN_H */

#include "tetris.h"
 
bool rotation;
bool accelerate;
 
class entity
{
public:
    int _X1;
    int _X2;
    int _Y1;
    int _Y2;
    int _ENTITY_NUMBER;
    bool _MOVABLE;
    bool _STATIC;
    bool _DRAWED;
 
    entity()
    {
    _MOVABLE = false;
    _STATIC = false;
    _DRAWED = false;
    }
 
    void parameters(bool x, bool z)
    {
    _MOVABLE = x;
    _STATIC = z;
    }
 
    void entityNumber(int f)
    {
    _ENTITY_NUMBER = f;
    }
 
    void initialize(int a, int b, int c)
    {
    _X1 = a;
    _X2 = _X1 + 20;
    _Y1 = b;
    _Y2 = _Y1 + 20;
    _ENTITY_NUMBER = c;
    }
    void Destroy()
    {
    glColor3f(0.0, 0.0, 0.0);
    glRectf(_X1, _Y1, _X2, _Y2);
    _DRAWED = false;
    glEnd();
    }
 
    void drawEntity()
    {
    glColor3f(1.0, 0.7, 0.3);
    glRectf(_X1, _Y1, _X2, _Y2);
    _DRAWED = true;
    glEnd();
    }
 
    bool showStatic()
    {
    return _STATIC;
    }
 
    bool showMovable()
    {
    return _MOVABLE;
    }
 
    int showX1()
    {
    return _X1;
    }
 
    int showX2()
    {
    return _X2;
    }
 
    int showY1()
    {
    return _Y1;
    }
 
    int showY2()
    {
    return _Y2;
    }
 
    bool showDrawned()
    {
    return _DRAWED;
    }
} entities[96];
 
class Tetris
{
public:
 
    bool _TEMP_INS;
    int _TEMP_INS_INT;
    bool _MOVABLE_OUT;
    bool _STATIC_OUT;
    int _X_OUT;
    int _Y_OUT;
    int width_prog;
    int height_prog;
    int width;
    int height;
    int tick;
    int scale;
    int _ENTITY_PRESENT;
    int _LINE_ITERATOR;
    bool _INITIATE;
    int _ANIMATION;
    int _TEMP_ALFA;
    int _TEMP_BETA;
    int _TEMP_GAMMA;
    int _TEMP_ZETTA;
    bool _CAN_DRAW;
    bool _CAN_RAND;
    int _TEMP;
 
    Tetris()
    {
    
    width = _WIDTH;
    height = _HEIGHT;
    tick = _TICK;
    scale = _SCALE; 
    width_prog = width * scale;
    height_prog = height * scale;
    _ENTITY_PRESENT = 0;
    _LINE_ITERATOR = 0;
    _INITIATE = true;
    _ANIMATION = 2;
    _TEMP_ALFA = 3;
    _TEMP_BETA = 3;
    _TEMP_GAMMA = 2;
    _TEMP_ZETTA = 4;
    _CAN_DRAW = true;
    _CAN_RAND = true;
    for (_TEMP = 0; _TEMP < 96; ++_TEMP)
    {
        if (_TEMP > 7)
        {
        _X_OUT = (_TEMP / 8) * scale;
        _Y_OUT = _LINE_ITERATOR * scale;
        entities[_TEMP].initialize(_X_OUT, _Y_OUT, _TEMP);
        ++_LINE_ITERATOR;
        }
        else
        {
        _X_OUT = 0;
        _Y_OUT = _LINE_ITERATOR * scale;
        entities[_TEMP].initialize(_X_OUT, _Y_OUT, _TEMP);
        ++_LINE_ITERATOR;
        }
        if (_LINE_ITERATOR = 8)
        _LINE_ITERATOR = 0;
    }
    }
    ~Tetris()
    {}
 
    void SetStatic()
    {
    for (int _ENTITY = 0; _ENTITY < 96; ++_ENTITY)
    {
        _TEMP_INS = entities[_ENTITY].showMovable();
        if (_TEMP_INS = true)
        if (_ENTITY > 7)
        {
            _TEMP_INS = entities[_ENTITY - 8].showStatic();
            if (_TEMP_INS = true)
            entities[_ENTITY].parameters(false, true);
        }
    }
    }
 
    void SetDestroy()
    {
    for (int _ENTITY = 0; _ENTITY < 96; ++_ENTITY)
    {
        _TEMP_INS = entities[_ENTITY].showMovable();
        if (_TEMP_INS = false)
        {
        _TEMP_INS = entities[_ENTITY].showStatic();
        if (_TEMP_INS = false)
        {
            _TEMP_INS = entities[_ENTITY].showDrawned();
            if (_TEMP_INS = true){
            entities[_ENTITY].Destroy();
            }
        }
        }
    }
    }
 
    void SetDraw()
    {
    for (int _ENTITY = 0; _ENTITY < 96; ++_ENTITY)
    {
 
        _TEMP_INS = entities[_ENTITY].showMovable();
        if (_TEMP_INS = true)
        {
        _TEMP_INS = entities[_ENTITY].showDrawned();
        if (_TEMP_INS = false)
        {
            entities[_ENTITY].drawEntity();
        }
        }
        else
        {
        _TEMP_INS = entities[_ENTITY].showStatic();
        if (_TEMP_INS = true)
        {
            _TEMP_INS = entities[_ENTITY].showDrawned();
            if (_TEMP_INS = false)
            entities[_ENTITY].drawEntity();
        }
        }
    }
    }
 
    void newMovable()
    {
    for (int _ENTITY = 0; _ENTITY < 96; ++_ENTITY)
    {
        if (_ENTITY > 7)
        {
        _TEMP_INS = entities[_ENTITY].showStatic();
        if (_TEMP_INS = false)
        {
            entities[_ENTITY - 8].parameters(true, false);
            entities[_ENTITY].parameters(false, false);
        }
        }
    }
    }
 
    void setEntityVar()
    {
    if (_ENTITY_PRESENT = 0)
    {
        _TEMP_ALFA = 3;
        _TEMP_BETA = 3;
        _TEMP_GAMMA = 2;
        _TEMP_ZETTA = 4;
        _CAN_DRAW = true;
        _CAN_RAND = true;
    }
    }
 
    void drawRandomForm()
    {
    if (_CAN_DRAW = true)
    {   
        _MOVABLE_OUT = true;
        _STATIC_OUT = false;
        if (_CAN_RAND = true)
        {
        _TEMP_INS_INT = (rand() % 4);
        _CAN_RAND = false;
        }       
        switch (_TEMP_INS_INT)
        {
        case 0:
 
            if ((_TEMP_ALFA) > 0)
            {
            if ((_TEMP_ALFA) = 1)
            {
                entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
                entities[92].drawEntity();
                entities[91].parameters(_MOVABLE_OUT, _STATIC_OUT);
                entities[91].drawEntity();
                _TEMP_ALFA--;
                _ENTITY_PRESENT++;
                _CAN_DRAW = false;
            }
            if (((_TEMP_ALFA) = 3) || ((_TEMP_ALFA) = 2))
            {
                entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
                entities[92].drawEntity();
                 glRectf(100, 150, 75, 5);
                _ENTITY_PRESENT++;
              
            }
            }
            break;
        case 1:
            if ((_TEMP_BETA) > 0)
            {
            if ((_TEMP_BETA) = 1)
            {
                entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
                entities[92].drawEntity();
                _TEMP_BETA--;
                _ENTITY_PRESENT++;
                _CAN_DRAW = false;
            }
            if ((_TEMP_BETA) = 2)
            {
                entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
                entities[92].drawEntity();
                entities[91].parameters(_MOVABLE_OUT, _STATIC_OUT);
                entities[91].drawEntity();
                _TEMP_BETA--;
                _ENTITY_PRESENT++;
 
            }
            if ((_TEMP_BETA) = 3)
            {
                entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
                entities[92].drawEntity();
                _TEMP_BETA--;
                _ENTITY_PRESENT++;
            }
            }
 
            break;
        case 2:
            if ((_TEMP_GAMMA) > 0)
            {
            if ((_TEMP_GAMMA) = 1)
            {
                entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
                entities[92].drawEntity();
                entities[93].parameters(_MOVABLE_OUT, _STATIC_OUT);
                entities[93].drawEntity();
                _TEMP_GAMMA--;
                _ENTITY_PRESENT++;
                _CAN_DRAW = false;
            }
            if ((_TEMP_GAMMA) = 2)
            {
                entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
                entities[92].drawEntity();
                entities[91].parameters(_MOVABLE_OUT, _STATIC_OUT);
                entities[91].drawEntity();
                _TEMP_GAMMA--;
                _ENTITY_PRESENT++;
            }
            }
            break;
        case 3:
            if ((_TEMP_ZETTA) > 0)
            {
            if (_TEMP_ZETTA = 1)
                _CAN_DRAW = false;
            if (((_TEMP_ZETTA) = 3) || ((_TEMP_ZETTA) = 2) || ((_TEMP_ZETTA) = 1) || ((_TEMP_ZETTA) = 4))
            {
                entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
                entities[92].drawEntity();
                entities[93].parameters(_MOVABLE_OUT, _STATIC_OUT);
                entities[93].drawEntity();
                _TEMP_ZETTA--;
                _ENTITY_PRESENT++;
            }
            }
            break;
        }
    }
    }
};
 
void drawField()
{
    glColor3f(0.5, 1.0, 0.5);
    glBegin(GL_LINES);
    for (int i = 0; i < 160; i += 20)
    {
    glVertex2f(i, 0);
    glVertex2f(i, 240);
    }
    for (int i = 0; i < 240; i += 20)
    {
    glVertex2f(0, i);
    glVertex2f(160, i);
    }
    glEnd();
}
//              glRectf(100, 150, 75, 5);
void drawEntities()
{
    Tetris mainScreen;
    mainScreen.SetStatic();
    mainScreen.SetDestroy();
    mainScreen.SetDraw();
    mainScreen.setEntityVar();
    mainScreen.newMovable();
    mainScreen.drawRandomForm();
}
 
void Keyboard(int _KEY, int _COORD_X, int _COORD_Y)
{
    if (_KEY == _UP_KEY)
    rotation = true;
    if (_KEY == _DOWN_KEY)
    accelerate = true;
}
 
void Display()
{
    glClear(GL_COLOR_BUFFER_BIT);
    drawField();
    drawEntities();
    glEnd();
    glFlush();
}
 
void Timer(int = 0)
{
    Display();
    glutTimerFunc(500, Timer, 0);
}
 
int main(int argc, char** argv)
{
    srand(time(0));
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE
        | GLUT_RGB);
    glutInitWindowSize(160, 240);
    glutCreateWindow("Tetris");
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, 160, 0, 240);
    glutDisplayFunc(Display);
    glutTimerFunc(500, Timer, 0);
    glutSpecialFunc(Keyboard);
    glutMainLoop();
    return 0;
}

#include "tetris.h"
// Обьявление глобальных переменных:
bool rotation;
bool accelerate;
int width = _WIDTH;
int height = _HEIGHT;
int tick = _TICK;
int scale = _SCALE;
int width_prog = width * scale;
int height_prog = height * scale;
 
 
// Класс каждой клетки на поле
 
class entity
{
public:
    int _X1;
    int _X2;
    int _Y1;
    int _Y2;
    int _ENTITY_NUMBER;
    bool _MOVABLE;
    bool _STATIC;
    bool _DRAWED;
 
    //Собственно инициализация
 
    entity()
    {
    _MOVABLE = false;
    _STATIC = false;
    _DRAWED = false;
    }
    //Метод передачи параметров в обьект (двигается, статичен)
    void parameters(bool x, bool z);
 
    //Метод передачи номера обьекту
    void entityNumber(int f);
 
    //Инициализация координат и передача начального номера обьекту
    void initialize(int a, int b, int c);
 
    //Удаление разрисованных клеток которые должны оставаться позади
    void Destroy();
 
    //Рисование обьекта
    void drawEntity();
 
    //Показывает при необходимости статичен ли обьект
    bool showStatic()
    {
    return _STATIC;
    }
 
    //Показывает при необходимости мобилен ли обьект
    bool showMovable()
    {
    return _MOVABLE;
    }
 
    //Показывает при необходимости координату х1
    int showX1()
    {
    return _X1;
    }
    
    //Показывает при необходимости координату х2
    int showX2()
    {
    return _X2;
    }
 
    //Показывает при необходимости координату у1
    int showY1()
    {
    return _Y1;
    }
 
    //Показывает при необходимости координату у2
    int showY2()
    {
    return _Y2;
    }
 
    //Показывает при необходимости разрисован ли обьект
    bool showDrawned()
    {
    return _DRAWED;
    }
}
 
//создание 96 клеток тетриса
entities[96];
 
 
//Сам код тетриса
class Tetris
{
public:
    bool _TEMP_INS;
    int _TEMP_INS_INT;
    bool _MOVABLE_OUT;
    bool _STATIC_OUT;
    int _X_OUT;
    int _Y_OUT;
    int _ENTITY_PRESENT;
    int _LINE_ITERATOR;
    bool _INITIATE;
    int _ANIMATION;
    int _TEMP_ALFA;
    int _TEMP_BETA;
    int _TEMP_GAMMA;
    int _TEMP_ZETTA;
    bool _CAN_DRAW;
    bool _CAN_RAND;
    int _TEMP;
 
    Tetris()
    {
    //количество двигающихся на экране обьектов
    _ENTITY_PRESENT = 0;
 
    _LINE_ITERATOR = 0;
 
    //одноразовый инициализатор
    _INITIATE = true;
 
    _ANIMATION = 2;
 
    //количество обьектов в каждой фигуре
    _TEMP_ALFA = 3;
    _TEMP_BETA = 3;
    _TEMP_GAMMA = 2;
    _TEMP_ZETTA = 4;
 
    //проверка можно ли рисовать новую фигуру
    _CAN_DRAW = true;
 
    //проверка можно ли находить случайную фигуру
    _CAN_RAND = true;
 
    //заполнение координатами обьектов
    for (_TEMP = 0; _TEMP < 96; ++_TEMP)
    {
        if (_TEMP > 7)
        {
        _X_OUT = (_TEMP / 8) * scale;
        _Y_OUT = _LINE_ITERATOR * scale;
        entities[_TEMP].initialize(_X_OUT, _Y_OUT, _TEMP);
        ++_LINE_ITERATOR;
        }
        else
        {
        _X_OUT = 0;
        _Y_OUT = _LINE_ITERATOR * scale;
        entities[_TEMP].initialize(_X_OUT, _Y_OUT, _TEMP);
        ++_LINE_ITERATOR;
        }
        if (_LINE_ITERATOR == 8)
        _LINE_ITERATOR = 0;
    }
    }
 
    ~Tetris()
    {
    }
 
    // Проверка на статичные обьекты
    void SetStatic();
 
    // Удаление с экрана следы движушихся обьектов
    void SetDestroy();
 
    // Разрисовка движушихся обьектов, и статичных
 
    void SetDraw();
 
    //Передача параметра движения обьекту пониже, если конечно он не статичен
 
    void newMovable();
 
    //Обновление параметров фигур т рисовки, если конечно на экране 0 движушихся обьектов 
 
    void setEntityVar();
 
 
    // Рисовка рандомной фигуры на экран
    void drawRandomForm();
 
} mainScreen
//Экран тетриса
;
 
 
// Рисовка линий на экране
void drawField()
{
    glColor3f(0.5, 1.0, 0.5);
    glBegin(GL_LINES);
    for (int i = 0; i < 160; i += 20)
    {
    glVertex2f(i, 0);
    glVertex2f(i, 240);
    }
    for (int i = 0; i < 240; i += 20)
    {
    glVertex2f(0, i);
    glVertex2f(160, i);
    }
    glEnd();
}
//              glRectf(100, 150, 75, 5);
 
 
// Компоновка экрана, функции работы собственно
void drawEntities()
{
    // Сначала рандомную фигуру постепенно рисуем(За три - четыре тика долнжо нарисовать)
    mainScreen.drawRandomForm();
 
    // Рисуем собственно куски фигуры, а так же другие обьекты при необходимости
    mainScreen.SetDraw();
 
    // Удаление остаточных разрисованных обьектов и подготовка их к новому использованию
    mainScreen.SetDestroy();
 
    // Считываем движущиейся обьекты в следующем тике программы, и сразу приписываем им статус движущихся обьектов
    mainScreen.newMovable();
 
    // Проверка на статичность обьекта
    mainScreen.SetStatic();
 
    // Проверка можно ли разрисовывать новую фигуру
    mainScreen.setEntityVar();
}
 
// Это пока не нужно, мне бы сначала с падающими обьектами разобраться =(
/*void Keyboard(int _KEY, int _COORD_X, int _COORD_Y)
{
    if (_KEY == _UP_KEY)
    rotation = true;
    if (_KEY == _DOWN_KEY)
    accelerate = true;
}*/
 
 
// Функция экрана
void Display()
{
    glClear(GL_COLOR_BUFFER_BIT);
    drawField();
    drawEntities();
    glEnd();
    glFlush();
}
 
// Тайиер, тикрейт 500, он же пол секунлы
void Timer(int = 0)
{
    Display();
    glutTimerFunc(500, Timer, 0);
}
 
int main(int argc, char** argv)
{
    srand(time(0));
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(160, 240);
    glutCreateWindow("Tetris");
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(0, 160, 0, 240);
    glutDisplayFunc(Display);
    glutTimerFunc(500, Timer, 0);
    //glutSpecialFunc(Keyboard);
    glutMainLoop();
    return 0;
}
 
void entity::parameters(bool x, bool z)
{
    _MOVABLE = x;
    _STATIC = z;
}
 
void entity::entityNumber(int f)
{
    _ENTITY_NUMBER = f;
}
 
void entity::initialize(int a, int b, int c)
{
    _X1 = a;
    _X2 = _X1 + 20;
    _Y1 = b;
    _Y2 = _Y1 + 20;
    _ENTITY_NUMBER = c;
}
 
void entity::Destroy()
{
    glColor3f(0.0, 0.0, 0.0);
    glRectf(_X1, _Y1, _X2, _Y2);
 
    //Удаляет маркер "разрисован"
    _DRAWED = false;
}
 
void entity::drawEntity()
{
    glColor3f(1.0, 0.7, 0.3);
    glRectf(_X1, _Y1, _X2, _Y2);
 
    //Добавляет маркер "разрисован"
    _DRAWED = true;
}
 
void Tetris::SetStatic()
{
    for (int _ENTITY = 0; _ENTITY < 96; ++_ENTITY)
    {
    _TEMP_INS = entities[_ENTITY].showMovable();
    if (_TEMP_INS == true)
        if (_ENTITY > 15)
        {
        _TEMP_INS = entities[_ENTITY - 8].showStatic();
        if (_TEMP_INS == true)
        {
 
            //Когда один обьект превращается в статичный
            //то автоматически движушихся обьектов на поле уменьшается
            _ENTITY_PRESENT--;
            entities[_ENTITY].parameters(false, true);
        }
        }
    }
}
 
void Tetris::SetDestroy()
{
    for (int _ENTITY = 0; _ENTITY < 96; ++_ENTITY)
    {
    _TEMP_INS = entities[_ENTITY].showMovable();
    if (_TEMP_INS == false)
    {
        _TEMP_INS = entities[_ENTITY].showStatic();
        if (_TEMP_INS == false)
        {
        _TEMP_INS = entities[_ENTITY].showDrawned();
        if (_TEMP_INS == true)
        {
            entities[_ENTITY].Destroy();
        }
        }
    }
    }
}
 
void Tetris::SetDraw()
{
    for (int _ENTITY = 0; _ENTITY < 96; ++_ENTITY)
    {
 
    _TEMP_INS = entities[_ENTITY].showMovable();
    if (_TEMP_INS == true)
    {
        _TEMP_INS = entities[_ENTITY].showDrawned();
        if (_TEMP_INS == false)
        {
        entities[_ENTITY].drawEntity();
        }
    }
    else
    {
        _TEMP_INS = entities[_ENTITY].showStatic();
        if (_TEMP_INS == true)
        {
        _TEMP_INS = entities[_ENTITY].showDrawned();
        if (_TEMP_INS == false)
            entities[_ENTITY].drawEntity();
        }
    }
    }
}
 
void Tetris::newMovable()
{
    for (int _ENTITY = 0; _ENTITY < 96; ++_ENTITY)
    {
    _TEMP_INS = entities[_ENTITY].showMovable();
    {
        if (_ENTITY > 15)
        {
        _TEMP_INS = entities[_ENTITY - 8].showStatic();
        if (_TEMP_INS == false)
        {
            entities[_ENTITY - 8].parameters(true, false);
            entities[_ENTITY].parameters(false, false);
        }
        }
        else
        {
        if (_ENTITY > 7)
        {
            entities[_ENTITY].parameters(false, false);
            entities[_ENTITY - 8].parameters(false, true);
        }
        }
    }
    }
}
 
void Tetris::setEntityVar()
{
    if (_ENTITY_PRESENT == 0)
    {
    _TEMP_ALFA = 3;
    _TEMP_BETA = 3;
    _TEMP_GAMMA = 2;
    _TEMP_ZETTA = 4;
    _CAN_DRAW = true;
    _CAN_RAND = true;
    }
}
 
void Tetris::drawRandomForm()
{
    // Проверка можно ли рисовать
    if (_CAN_DRAW == true)
    {
    // Передача параметра "движущийся"
    _MOVABLE_OUT = true;
 
    // Передача параметра "не статичен"
    _STATIC_OUT = false;
 
    // Проверка можно ли вычислять случайную фигуру
    if (_CAN_RAND == true)
    {
        _TEMP_INS_INT = (rand() % 4);
        _CAN_RAND = false;
    }
 
    // Собственно рисовка фигуры
    switch (_TEMP_INS_INT)
    {
        case 0:
 
        // Проверка цикла рисовки фигуры
        if ((_TEMP_ALFA) > 0)
        {
 
            // Рисовка последней третьей части обьекта
            if ((_TEMP_ALFA) == 1)
            {
            entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
            entities[91].parameters(_MOVABLE_OUT, _STATIC_OUT);
            _TEMP_ALFA--;
 
            // Добавление движущихся обьектов
            _ENTITY_PRESENT++;
            _CAN_DRAW = false;
            }
 
            // Рисовка первой и второй части обьекта (снизу вверх)
            if (((_TEMP_ALFA) == 3) || ((_TEMP_ALFA) == 2))
            {
            entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
 
            // Добавление движущихся обьектов
            _ENTITY_PRESENT++;
            _TEMP_ALFA--;
            }
        }
        break;
        case 1:
        if ((_TEMP_BETA) > 0)
        {
            if ((_TEMP_BETA) == 1)
            {
            entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
            _TEMP_BETA--;
            _ENTITY_PRESENT++;
            _CAN_DRAW = false;
            }
            if ((_TEMP_BETA) == 2)
            {
            entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
            entities[91].parameters(_MOVABLE_OUT, _STATIC_OUT);
            _TEMP_BETA--;
            _ENTITY_PRESENT++;
 
            }
            if ((_TEMP_BETA) == 3)
            {
            entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
            _TEMP_BETA--;
            _ENTITY_PRESENT++;
            }
        }
 
        break;
        case 2:
        if ((_TEMP_GAMMA) > 0)
        {
            if ((_TEMP_GAMMA) == 1)
            {
            entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
            entities[93].parameters(_MOVABLE_OUT, _STATIC_OUT);
            _TEMP_GAMMA--;
            _ENTITY_PRESENT++;
            _CAN_DRAW = false;
            }
            if ((_TEMP_GAMMA) == 2)
            {
            entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
            entities[91].parameters(_MOVABLE_OUT, _STATIC_OUT);
            _TEMP_GAMMA--;
            _ENTITY_PRESENT++;
            }
        }
        break;
        case 3:
        if ((_TEMP_ZETTA) > 0)
        {
            if (_TEMP_ZETTA == 1)
            {
            _TEMP_ZETTA = 0;
            _ENTITY_PRESENT++;
            _CAN_DRAW = false;
            }
            if (((_TEMP_ZETTA) == 3) || ((_TEMP_ZETTA) == 2) || ((_TEMP_ZETTA) == 4))
            {
            entities[92].parameters(_MOVABLE_OUT, _STATIC_OUT);
            entities[93].parameters(_MOVABLE_OUT, _STATIC_OUT);
            _TEMP_ZETTA--;
            _ENTITY_PRESENT++;
            }
        }
        break;
    }
    }
}

void _TETRIS::_TETRIS_SET_POINT() {
    for (int _ENTITY_X = 0; _ENTITY_X < _HEIGHT; ++_ENTITY_X) {
    for (int _ENTITY_Y = 0; _ENTITY_Y < _WIDTH; ++_ENTITY_Y) {
        if (_ENTITIES[(_ENTITY_X * _WIDTH) + _ENTITY_Y]._STATIC == true) {
        ++_STATIC_CHECK;
        if (_STATIC_CHECK == _WIDTH) {
            for (int _ENTITY = (_ENTITY_X * _WIDTH); _ENTITY < (_ENTITY_X* _WIDTH) + _WIDTH; ++_ENTITY) {
            _ENTITIES[_ENTITY]._STATIC = false;
            }
            for (int _ENTITY = (_ENTITY_X * _WIDTH) + _WIDTH; _ENTITY < 200; ++_ENTITY) {
            if (_ENTITIES[_ENTITY]._STATIC == true) {
                _ENTITIES[_ENTITY - _WIDTH]._STATIC = true;
                _ENTITIES[_ENTITY]._STATIC = false;
            }
            }
            _STATIC_CHECK = 0;
        }
        
        }
        _STATIC_CHECK = 0;
    }
 
    }
}

#define _ENTITY_FOR for;
#define _ENTITY_INT int;
#define _ENTITY_LEFT_BRACKET (
#define _ENTITY_RIGHT_BRACKET )
#define _ENTITY_EQUALS =
 
_ENTITY_FOR _ENTITY_LEFT_BRACKET _ENTITY_INT _ENTITY_X _ENTITY_EQUALS 0 ; ...

void _TETRIS::remove_line(size_t line)
{
    assert(line < _HEIGHT);
 
    for (int x = 0; x < _WIDTH; x++)
    {
        for (int y = line; y < _HEIGHT - 1; y++)
            _ENTITIES[y*_WIDTH + x]._STATIC = _ENTITIES[(y + 1)*_WIDTH + x]._STATIC;
        _ENTITIES[(_HEIGHT - 1)*_WIDTH + x]._STATIC = false;
    }
}
 
void _TETRIS::set_point() {
 
    for (int x = 0; x < _HEIGHT; ++x) {
 
        bool full_line = true;
 
        for (int y = 0; y < _WIDTH; ++y) {
            if (!_ENTITIES[x*_WIDTH + y]._STATIC) {
                full_line = false;
                break;
            }
        }
 
        if (full_line)
            remove_line(x);
    }
}