#include "俄罗斯方块A.h"

#pragma once
#include "resource.h"
#include <time.h>
bool MM=0;
int WhichLineNeedDelete[4]={0,0,0,0};
////////////////////////////////////////////
int Object10[4][4]={0,0,0,0,
                    1,1,1,1,
                    0,0,0,0,
                    0,0,0,0};//一字型
int Object11[4][4]={0,1,0,0,
                    0,1,0,0,
                    0,1,0,0,
                    0,1,0,0};
////////////////////////////////////////////
int Object20[4][4]={0,0,0,0,
                    1,1,0,0,
                    0,1,1,0,
                    0,0,0,0};//Z字型
int Object21[4][4]={0,0,1,0,
                    0,1,1,0,
                    0,1,0,0,
                    0,0,0,0};
/////////////////////////////////////////////
int Object30[4][4]={0,0,0,0,
                    0,0,1,1,
                    0,1,1,0,
                    0,0,0,0};//反Z字型
int Object31[4][4]={0,1,0,0,
                    0,1,1,0,
                    0,0,1,0,
                    0,0,0,0};
/////////////////////////////////////////////
int Object40[4][4]={0,1,0,0,
                    1,1,1,0,
                    0,0,0,0,
                    0,0,0,0};//T字型
int Object41[4][4]={0,1,0,0,
                    0,1,1,0,
                    0,1,0,0,
                    0,0,0,0};
int Object42[4][4]={0,0,0,0,
                    1,1,1,0,
                    0,1,0,0,
                    0,0,0,0};
int Object43[4][4]={0,1,0,0,
                    1,1,0,0,
                    0,1,0,0,
                    0,0,0,0};
/////////////////////////////////////////////
int Object50[4][4]={0,1,0,0,
                    0,1,0,0,
                    0,1,1,0,
                    0,0,0,0};//L字型
int Object51[4][4]={0,0,0,0,
                    1,1,1,0,
                    1,0,0,0,
                    0,0,0,0};
int Object52[4][4]={0,0,0,0,
                    1,1,0,0,
                    0,1,0,0,
                    0,1,0,0};
int Object53[4][4]={0,0,0,0,
                    0,0,1,0,
                    1,1,1,0,
                    0,0,0,0};
///////////////////////////////////////////////
int Object60[4][4]={0,0,1,0,
                    0,0,1,0,
                    0,1,1,0,
                    0,0,0,0};//反L字型
int Object61[4][4]={0,0,0,0,
                    1,0,0,0,
                    1,1,1,0,
                    0,0,0,0};
int Object62[4][4]={0,0,0,0,
                    1,1,0,0,
                    1,0,0,0,
                    1,0,0,0};
int Object63[4][4]={0,0,0,0,
                    1,1,1,0,
                    0,0,1,0,
                    0,0,0,0};
/////////////////////////////////////////////////
int Object70[4][4]={0,0,0,0,
                    1,1,0,0,
                    1,1,0,0,
                    0,0,0,0};//田字型
//////////////////////////////////////////////////
class RUS
{
private:
    int OBJECT[4][4];
    int NEXT_DEFORMATION;//下一个的形状
    int x[4],y[4];//用于记录OBJECT在MAP中的坐标
    int HEIGHT;
    int WIDETH;
    int NOW_DEFORMATION;//当前形状
    int CHANGE;//子类型(形状)
    int DeletLinePosition_Y;//记录消掉行的Y坐标
    int DeleteHeight;
public:
    int SCORE;//分数，在初始化地图时初始化SCORE
    int NUM;//记录需要消掉的行数
    int MAP[12][22];//12列22行
    int NEXTOBJECT[4][4];
    void Initialize_MAP();
    void Initialize_OBJECT();//将Object中的数据传递到OBJECT中
    void RUS::GETObjectPosition(int *XX,int *YY,int OBject[4][4]);//将子形状坐标化
    void InitializeXY();//将OBJECT坐标化
    void DrawDeformation();//画出下一个OBJECT的形状
    void VerticalMove(bool);//使红色方块的坐标向下移动
    void RightMove(bool);//使红色方块的坐标向右移动
    void LeftMove(bool);//使红色方块的坐标向左移动
    void DeleteLine();//得分后删除填满的行
    void JudgeGetScore();//判断能否得分
    bool Deformation();//变形函数
    bool JudgeBottom();//判断红的方块是否到底
    bool JudgeRight();//判断红色方块是否到最右端
    bool JudgeLeft();//判断红色方块是否到达最左端
    bool GameOver;//判断游戏是否结束
    int GetHeight();//取得OBJECT的最大高度
    int GetWideth();//取得OBJECT的最大宽度
    void CheckDownWhite();//坐标化覆盖红色方块的方块的坐标（根据OBJECT的坐标）
    void DrawGameOver();//画出GameOver
    int *GetX();//取得OBJECT的横坐标
    int *GetY();//取得OBJECT的纵坐标
    struct WPOINT//用于覆盖的方块
    {
        int x;
        int y;
    }wPoint[4],rPoint[4],lPoint[4],TempPoint[4];
};// wPoint覆盖向下移动的方块
  // rPoint覆盖向右移动的方块
  // lPoint覆盖向左移动的方块
  // TemPoint覆盖变形前的方块
void RUS::Initialize_MAP()
{
    int i,j;
    for(i=0;i<22;i++)
        for(j=0;j<12;j++)
            MAP[j][i]=0;
    for(i=0;i<22;i++)
    {
        MAP[0][i]=1;
        MAP[11][i]=1;
    }
    for(j=0;j<12;j++)
    {
        MAP[j][0]=0;
        MAP[j][21]=1;
    }
    MAP[0][0]=1;
    MAP[11][0]=1;
    SCORE=0;//初始化分数
    NUM=0;
}
void RUS:: Initialize_OBJECT()
{
    srand(time(NULL));
    static int DEFORMATION=((rand() % 7) +1)*10;//形状编号
    NOW_DEFORMATION=DEFORMATION;
    switch(DEFORMATION)
    {
    case 10:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    OBJECT[i][j]=Object10[i][j];
        break;
    case 20:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    OBJECT[i][j]=Object20[i][j];
        break;
    case 30:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    OBJECT[i][j]=Object30[i][j];
        break;
    case 40:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    OBJECT[i][j]=Object40[i][j];
        break;
    case 50:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    OBJECT[i][j]=Object50[i][j];
        break;
    case 60:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    OBJECT[i][j]=Object60[i][j];
        break;
    case 70:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    OBJECT[i][j]=Object70[i][j];
        break;    
    default: break;
    }
    DEFORMATION=((rand() % 7) +1)*10;
    NEXT_DEFORMATION=DEFORMATION;
    CHANGE=1;
    DrawDeformation();

}
void RUS::InitializeXY()//初始化OBJECT的坐标
{
    int I=0;int X=5,Y=-1;
    bool Judge=false;
    for(int i=0;i<4;i++)
    {
        for(int j=0;j<4;j++)
            if(OBJECT[i][j])
            {
                Judge=true;
                x[I]=j+X;
                y[I]=i+Y;
                I++;
            }

    }
}
void RUS::VerticalMove(bool Judge)
{
    
    if(Judge)
    {
        for(int i=0;i<4;i++)
            {
                y[i]++;//红色方块向下移动
                wPoint[i].y++;//白色方块向下移动
                rPoint[i].y++;
                lPoint[i].y++;
        }
    }
    else
    {
        for(int i=0,j=0;i<4&&j<4;i++,j++)
            MAP[x[i]][y[j]]=1;
//////////////////////////////////////////////
        GameOver=false;
    for(int i=1;i<11;i++)  //判断游戏是否结束
        if(MAP[i][1]==1)
            GameOver=true;
///////////////////////////////////////////////
        JudgeGetScore();//判断是否得分，如果得分消掉得分行
        Initialize_OBJECT();//当方块到达底部时初始化OBJECT。
        InitializeXY();//初始化OBJECT坐标。
        CheckDownWhite();
        MM=true;
    }
}
void RUS::RightMove(bool Judge)
{
    if(Judge)
    {
        for(int i=0;i<4;i++)
        {x[i]=x[i]+1;rPoint[i].x++;wPoint[i].x++;lPoint[i].x++;}
    }
}
void RUS::LeftMove(bool Judge)
{
    if(Judge)
    {
        for(int i=0;i<4;i++)
        {x[i]=x[i]-1;lPoint[i].x--;wPoint[i].x--;rPoint[i].x--;}
    }
}
void RUS:: CheckDownWhite()//用来确定在哪里绘制白色方块  
{
    int m=0;bool Same=false;    
    WIDETH=1;HEIGHT=1;
    bool JudgeRepeat[4]={1,1,1,1};//用来判断方块的位置是否重复
    for(int i=0;i<4;i++)
    {
        for(int j=i+1;j<4;j++)
            if(x[i]==x[j])
            {
                    JudgeRepeat[j]=false;
                    if(!JudgeRepeat[i])
                    {
                            Same=true;
                            break;
                    }
                        
                    
                if(y[i]<y[j])
                {

                        wPoint[m].x=x[i];
                        wPoint[m].y=y[i]-1;
                        m++;
                        Same=true;
                }
                else
                {
                    wPoint[m].x=x[i];
                    wPoint[m].y=y[j]-1;
                    m++;
                    Same=true;
                }
            }
        if(!Same&&JudgeRepeat[i])
        {
                wPoint[m].x=x[i];
                wPoint[m].y=y[i]-1;
                m++;
        }
        Same=false;
    }
    WIDETH=m;//宽度
    m=0;Same=false;//确定向右移动时白色方块的位置
    for(int i=0;i<4;i++)
        JudgeRepeat[i]=true;
    for(int i=0;i<4;i++)
    {
        for(int j=i+1;j<4;j++)
            if(y[i]==y[j])
            {
                    JudgeRepeat[j]=false;
                    if(!JudgeRepeat[i])
                    {
                            Same=true;
                            break;
                    }
                        
                    
                if(x[i]<x[j])
                {

                        rPoint[m].y=y[i];
                        rPoint[m].x=x[i]-1;
                        m++;
                        Same=true;
                }
                else
                {
                    rPoint[m].y=y[i];
                    rPoint[m].x=x[j]-1;
                    m++;
                    Same=true;
                }
            }
        if(!Same&&JudgeRepeat[i])
        {
                rPoint[m].y=y[i];
                rPoint[m].x=x[i]-1;
                m++;
        }
        Same=false;
    }
    HEIGHT=m;//高度
    
    

    
    m=0;Same=false;//确定向左移动时白色方块的位置
    for(int i=0;i<4;i++)
        JudgeRepeat[i]=true;
    for(int i=0;i<4;i++)
    {
        for(int j=i+1;j<4;j++)
            if(y[i]==y[j])
            {
                    JudgeRepeat[j]=false;
                    if(!JudgeRepeat[i])
                    {
                            Same=true;
                            break;
                    }
                        
                    
                if(x[i]>x[j])
                {

                        lPoint[m].y=y[i];
                        lPoint[m].x=x[i]+1;
                        m++;
                        Same=true;
                }
                else
                {
                    lPoint[m].y=y[i];
                    lPoint[m].x=x[j]+1;
                    m++;
                    Same=true;
                }
            }
        if(!Same&&JudgeRepeat[i])
        {
                lPoint[m].y=y[i];
                lPoint[m].x=x[i]+1;
                m++;
        }
        Same=false;
    }

}
int * RUS:: GetX()
{
    return x;
}
int * RUS:: GetY()
{
    return y;
}
int RUS::GetWideth()
{
    return WIDETH;
}
int RUS::GetHeight()
{
    return HEIGHT;
}
bool RUS::JudgeBottom()
{
    bool Judge=true;
    for(int i=0,j=0;j<4;i++,j++)
        if(MAP[x[i]][y[j]+1]==1)
            Judge=false;
    return Judge;
}
bool RUS::JudgeRight()
{
    bool Judge=false;
    for(int i=0;i<4;i++)
        if(MAP[x[i]+1][y[i]]==1)
            Judge=true;
    return Judge;
}
bool RUS::JudgeLeft()
{
    bool Judge=false;
    for(int i=0;i<4;i++)
        if(MAP[x[i]-1][y[i]]==1)
            Judge=true;
    return Judge;
}
void RUS::GETObjectPosition(int *XX,int *YY,int OBject[4][4])
{
    int I=0;int X=x[0],Y=y[0];
    bool Judge=false;
    for(int i=0;i<4;i++)
    {
        for(int j=0;j<4;j++)
            if(OBject[i][j])
            {
                Judge=true;
                XX[I]=j+X;
                YY[I]=i+Y;
                I++;
            }

    }
}

bool RUS::Deformation()//变形函数
{
    int XX[4],YY[4];
    bool JUdge=false;
    switch(NOW_DEFORMATION)
    {
    case 10:
/////////////////////////////////////////////////////////////////////////////////        
        switch(CHANGE)
        {
        case 0:    
            GETObjectPosition(XX,YY,Object10);
            for(int i=0;i<4;i++)
                if(MAP[XX[i]-1][YY[i]+2])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]-1;
                y[i]=YY[i]+2;
            }
                
                CheckDownWhite();                                      //一字型
                CHANGE=1;

                JUdge=true;
            
            return JUdge;

        case 1:    
            GETObjectPosition(XX,YY,Object11);
            for(int i=0;i<4;i++)
                if(MAP[XX[i]][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i];
                y[i]=YY[i];
            }
            CheckDownWhite();
            CHANGE=0;
            JUdge=true;
            return JUdge;
        }            
        break;
///////////////////////////////////////////////////////////////////////
    case 20:
        switch(CHANGE)
        {
        case 0:            
            GETObjectPosition(XX,YY,Object20);
            for(int i=0;i<4;i++)
                if(MAP[XX[i]-1][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]-1;//控制变形后方块出现的位置
                y[i]=YY[i];
            }
                
                CheckDownWhite();
                CHANGE=1;

                JUdge=true;
            
            return JUdge;

    case 1:
                    GETObjectPosition(XX,YY,Object21);       //Z字型
            for(int i=0;i<4;i++)
                if(MAP[XX[i]-1][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]-1;
                y[i]=YY[i];
            }
                
                CheckDownWhite();
                CHANGE=0;

                JUdge=true;
            
            return JUdge;

            break;
        }
////////////////////////////////////////////////////////////////////////////
    case 30:
        switch(CHANGE)
        {
        case 0:    
            GETObjectPosition(XX,YY,Object30);
            for(int i=0;i<4;i++)
                if(MAP[XX[i]-1][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]-1;
                y[i]=YY[i];
            }
                
                CheckDownWhite();                                      
                CHANGE=1;

                JUdge=true;
            
            return JUdge;

        case 1:    
            GETObjectPosition(XX,YY,Object31);                             //反Z字型
            for(int i=0;i<4;i++)
                if(MAP[XX[i]-2][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]-2;
                y[i]=YY[i];
            }
                CheckDownWhite();                                      
                CHANGE=0;
                JUdge=true;
            return JUdge;                        
        }
        break;
////////////////////////////////////////////////////////////////////////////////
    case 40:
        switch(CHANGE)
        {
        case 0:    
            GETObjectPosition(XX,YY,Object40);
            for(int i=0;i<4;i++)
                if(MAP[XX[i]-1][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]-1;
                y[i]=YY[i];
            }
                
                CheckDownWhite();                                      
                CHANGE=1;

                JUdge=true;
            
            return JUdge;

        case 1:    
            GETObjectPosition(XX,YY,Object41);                             //T字型
            for(int i=0;i<4;i++)
                if(MAP[XX[i]-1][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]-1;
                y[i]=YY[i];
            }
                CheckDownWhite();                                      
                CHANGE=2;
                JUdge=true;
            return JUdge;
        case 2:    
            GETObjectPosition(XX,YY,Object42);
            for(int i=0;i<4;i++)
                if(MAP[XX[i]-1][YY[i]])//A处
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]-1;//该处-1，A处必须减一
                y[i]=YY[i];
            }
                
                CheckDownWhite();                                      
                CHANGE=3;

                JUdge=true;
            
            return JUdge;
        case 3:    
            GETObjectPosition(XX,YY,Object43);
            for(int i=0;i<4;i++)
                if(MAP[XX[i]][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i];
                y[i]=YY[i];
            }
                
                CheckDownWhite();                                      
                CHANGE=0;

                JUdge=true;
            
            return JUdge;

        }
        break;
//////////////////////////////////////////////////////////////////////////////////
    case 50:
        switch(CHANGE)
        {
        case 0:    
            GETObjectPosition(XX,YY,Object50);
            for(int i=0;i<4;i++)
                if(MAP[XX[i]-2][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]-2;
                y[i]=YY[i];
            }
                
                CheckDownWhite();                                      
                CHANGE=1;

                JUdge=true;
            
            return JUdge;

        case 1:    
            GETObjectPosition(XX,YY,Object51);                             //L字型
            for(int i=0;i<4;i++)
                if(MAP[XX[i]-1][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]-1;
                y[i]=YY[i];
            }
                CheckDownWhite();                                      
                CHANGE=2;
                JUdge=true;
            return JUdge;
        case 2:    
            GETObjectPosition(XX,YY,Object52);
            for(int i=0;i<4;i++)
                if(MAP[XX[i]+1][YY[i]])//A处
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]+1;//该处-1，A处必须减一
                y[i]=YY[i];
            }
                
                CheckDownWhite();                                      
                CHANGE=3;

                JUdge=true;
            
            return JUdge;
        case 3:    
            GETObjectPosition(XX,YY,Object53);
            for(int i=0;i<4;i++)
                if(MAP[XX[i]-1][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]-1;
                y[i]=YY[i];
            }
                
                CheckDownWhite();                                      
                CHANGE=0;

                JUdge=true;
            
            return JUdge;

        }
        break;
//////////////////////////////////////////////////////////////////////////////////
    case 60:
        switch(CHANGE)
        {
        case 0:    
            GETObjectPosition(XX,YY,Object60);
            for(int i=0;i<4;i++)
                if(MAP[XX[i]-1][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]-1;
                y[i]=YY[i];
            }
                
                CheckDownWhite();                                      
                CHANGE=1;

                JUdge=true;
            
            return JUdge;

        case 1:    
            GETObjectPosition(XX,YY,Object61);                             //反L字型
            for(int i=0;i<4;i++)
                if(MAP[XX[i]-1][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i]-1;
                y[i]=YY[i];
            }
                CheckDownWhite();                                      
                CHANGE=2;
                JUdge=true;
            return JUdge;
        case 2:    
            GETObjectPosition(XX,YY,Object62);
            for(int i=0;i<4;i++)
                if(MAP[XX[i]][YY[i]])//A处
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i];//该处-1，A处必须减一
                y[i]=YY[i];
            }
                
                CheckDownWhite();                                      
                CHANGE=3;

                JUdge=true;
            
            return JUdge;
        case 3:    
            GETObjectPosition(XX,YY,Object63);
            for(int i=0;i<4;i++)
                if(MAP[XX[i]][YY[i]])
                    return 0;
            for(int i=0;i<4;i++)
            {
                TempPoint[i].x=x[i];
                TempPoint[i].y=y[i];
                x[i]=XX[i];
                y[i]=YY[i];
            }
                CheckDownWhite();                                      
                CHANGE=0;
                JUdge=true;
            return JUdge;
        }
        break;
//////////////////////////////////////////////////////////////////////////////////
    default: return 0;
    }
}
void RUS:: DrawDeformation()
{
            for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    NEXTOBJECT[i][j]=0;
    switch(NEXT_DEFORMATION)
    {
    case 10:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    NEXTOBJECT[i][j]=Object10[i][j];
        break;
    case 20:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    NEXTOBJECT[i][j]=Object20[i][j];
        break;
    case 30:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    NEXTOBJECT[i][j]=Object30[i][j];
        break;
    case 40:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    NEXTOBJECT[i][j]=Object40[i][j];
        break;
    case 50:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    NEXTOBJECT[i][j]=Object50[i][j];
        break;
    case 60:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    NEXTOBJECT[i][j]=Object60[i][j];
        break;
    case 70:
        for(int i=0;i<4;i++)
                for(int j=0;j<4;j++)
                    NEXTOBJECT[i][j]=Object70[i][j];
        break;    
    default: break;
    }
}
void RUS:: JudgeGetScore()
{
    bool Judge=true;
    for(int i=1;i<21;i++)
    {
        Judge=true;
        for(int j=1;j<11;j++)
            if(!MAP[j][i])
                Judge=false;
        if(Judge)
        {
            WhichLineNeedDelete[NUM]=i;
            DeletLinePosition_Y=i;
            NUM++;
            SCORE=SCORE+10;
            DeleteLine();
        }
    }
}
void RUS:: DeleteLine()
{
    for(int i=1;i<11;i++)
        for(int j=0;j<DeletLinePosition_Y-1;j++)
        {
            MAP[i][DeletLinePosition_Y-j]=MAP[i][DeletLinePosition_Y-j-1];
            MAP[i][DeletLinePosition_Y-j-1]=0;
        }
}
void RUS::DrawGameOver()
{
    Initialize_MAP();
    MAP[10][2]=1;//画GAME OVER
    MAP[10][5]=1;
    MAP[10][6]=1;
    MAP[10][9]=1;
    MAP[10][11]=1;
    MAP[10][13]=1;
    MAP[10][16]=1;
    MAP[10][19]=1;
    MAP[10][20]=1;
    MAP[9][1]=1;
    MAP[9][3]=1;
    MAP[9][7]=1;
    MAP[9][9]=1;
    MAP[9][11]=1;
    MAP[9][13]=1;
    MAP[9][15]=1;
    MAP[9][17]=1;
    MAP[9][18]=1;
    MAP[8][1]=1;
    MAP[8][3]=1;
    MAP[8][7]=1;
    MAP[8][9]=1;
    MAP[8][11]=1;
    MAP[8][13]=1;
    MAP[8][15]=1;
    MAP[8][17]=1;
    MAP[7][2]=1;
    MAP[7][5]=1;
    MAP[7][6]=1;
    MAP[7][9]=1;
    MAP[7][10]=1;
    MAP[7][11]=1;
    MAP[7][12]=1;
    MAP[7][13]=1;
    MAP[7][15]=1;
    MAP[7][16]=1;
    MAP[7][17]=1;
    MAP[7][18]=1;
    MAP[7][19]=1;
    MAP[7][20]=1;
    MAP[5][3]=1;
    MAP[5][10]=1;
    MAP[5][13]=1;
    MAP[5][14]=1;
    MAP[5][16]=1;
    MAP[5][18]=1;
    MAP[5][20]=1;
    MAP[4][1]=1;
    MAP[4][3]=1;
    MAP[4][4]=1;
    MAP[4][5]=1;
    MAP[4][6]=1;
    MAP[4][8]=1;
    MAP[4][9]=1;
    MAP[4][12]=1;
    MAP[4][16]=1;
    MAP[4][18]=1;
    MAP[4][20]=1;

    MAP[3][1]=1;
    MAP[3][3]=1;
    MAP[3][5]=1;
    MAP[3][7]=1;
    MAP[3][9]=1;
    MAP[3][12]=1;
    MAP[3][13]=1;
    MAP[3][14]=1;
    MAP[3][16]=1;
    MAP[3][18]=1;
    MAP[3][20]=1;
    MAP[2][1]=1;
    MAP[2][5]=1;
    MAP[2][8]=1;
    MAP[2][9]=1;
    MAP[2][12]=1;
    MAP[2][16]=1;
    MAP[2][18]=1;
    MAP[2][20]=1;
    MAP[1][2]=1;
    MAP[1][3]=1;
    MAP[1][4]=1;
    MAP[1][10]=1;
    MAP[1][13]=1;
    MAP[1][14]=1;
    MAP[1][16]=1;
    MAP[1][17]=1;
    MAP[1][18]=1;
    MAP[1][19]=1;
    MAP[1][20]=1;
}