//#include "HardwareSerial.h"
// HardwareSerial SlaveSerial(1);
#include "ansi.h"
ANSI ansi(&Serial);
const int Row = 10;            //初始化行数
const int Col = 15;            //初始化列数
int Pane[Row][Col][4];         //初始化数组Pane[Row][Row][0] = 灯ID;Pane[Row][Row][1] = 灯砖新颜色;Pane[Row][Row][2]灯砖当前颜色;Pane[Row][Row][3] = 蓝色砖块记录
int Pane_Row_Color[Row][2][4]; //记录行颜色 Pane_Row_Color[Row][2][4]; [Row] = 行数 ;[2] = 记录当前颜色和新颜色0=新颜色 1=当前颜色; [4] = 4个颜色0=黑1=红2=绿3=蓝
byte PaneTime = 1000;          //设置运行时间1000m/s
unsigned long PaneTimeBefor;   //记录上次运行的时间
int blueDelay(2300);           //蓝色方块出现时间
unsigned long blueKeyTime;     //蓝色方块时间记录
byte Black = 0;                //定义颜色
byte Red = 1;
byte Green = 2;
byte Blue = 3;
byte RowRunId; //轮转行标记
byte ColRunId; //轮转列标记
// byte Bias; //轮转斜线标记
// byte RunKey = 1;

char RowMare[] =
{ 'A', 'B', 'C', 'D', 'E', 'F', 'G',
  'H', 'I', 'J', 'K', 'L', 'M', 'N',
  'O', 'P', 'Q', 'R', 'S', 'T'
}; // A=第一行;B=第二行;以此类推.
String GetSlaveVal = "";            //收到的字符串
int IntSlaveVal;                    //字符串转换后的整型数据
int Number = 0;                     //得分
void setup()
{
  Serial.begin(115200); //初始化硬串口 TX = 43   RX= 44
  //  SlaveSerial.begin(115200, SERIAL_8N1, 38, 39); // SlaveSerial   接收RX=38  发送TX=39
  PaneTimeBefor = millis(); //读取灯砖当前时间
  blueKeyTime = millis();   //读取蓝色灯砖当前时间
  WriteArray1();            //赋值灯砖ID数组
  PrintArray();             //打印数组排列方式'N你''''''''''''''''''''''''''''''''''''''你
  ColorKey();               //写入颜色编码
  delay(1000);              //等待
}

void loop()
{
  GetSlave();                               //从机回传的传感器数据
  if ((millis() - blueKeyTime) > blueDelay) // blueDelay，执行随机蓝色方格程序
  {
    RandomBluePane();       //调用随机蓝色方格程序
    blueKeyTime = millis(); //保存这次运行的时间
  };
  if ((millis() - PaneTimeBefor) > PaneTime) //指定时间运行
  {
    // level_1(); //第1关
    // level_2(); //第2关
    // level_3();      //第3关
    // level_4();      //第4关
    // level_5(); //第5关
    // level_6(); //第7关
    level_7(); //第6关
    //     BitWrite_Color(); //写入颜色
    //     Compare_Send();   //判断颜色是否改变发送改变颜色的行
    //  Print_BIN();      //调试打印颜色二进制码
    Print_Pane_Color();       //调试打印方块颜色
    PaneTimeBefor = millis(); //记录这次运行的时间
  };
}
//
void RandomBluePane() //随机蓝色方块
{
  for (int i = 0; i < Row; i++) //清空蓝色灯砖
  {
    for (int j = 0; j < Col; j++)
    {
      Pane[i][j][3] = Black;
    }
  }
  for (int i = 0; i < 3; i++) //随机出现4个蓝色方块
  {
    Pane[random(0, Row)][random(0, Col)][3] = Blue;
  };
};

/***********第一关程序***********/
void level_1()
{
  static byte RunKey;           //静态变量轮转斜线标记[X+]
  for (int i = 0; i < Row; i++) //清空颜色
  {
    for (int j = 0; j < Col; j++)
    {
      Pane[i][j][1] = Black;
    }
  }

  for (int j = 0; j < Col; j++) //红色轮转
  {
    Pane[RowRunId][j][1] = Red;
  }
  RowRunId += RunKey;
  if (RowRunId == Row - 1) //达到最远返回第一行
  {
    RunKey = -1;
  }
  if (RowRunId == 0) //达到最远返回第一行
  {
    RunKey = 1;
  }

  for (int i = 0; i < Row; i++) //随机蓝色方块
  {
    for (int j = 0; j < Col; j++)
    {
      if (Pane[i][j][3] == Blue)
      {
        Pane[i][j][1] = Blue;
      };
    }
  };

  for (int i = 3; i < 7; i++) //绿色固定区域Y轴大小位置
  {
    for (int j = 3; j < 7; j++) //绿色固定区域X轴大小位置
    {
      Pane[i][j][1] = Green;
    }
  }
}
/***********第二关程序***********/
void level_2()
{
  static byte Bias; //轮转斜线标记[X+]
  static byte RunKey = 1;
  for (int i = 0; i < Row; i++) //清空颜色
  {
    for (int j = 0; j < Col; j++)
    {
      Pane[i][j][1] = Black;
    }
  }
  {
    for (int i = 0; i <= Bias; i++)
    {
      if (i < Row && (Bias - i) < Col)
      {
        Pane[i][Bias - i][1] = Red;
      }
    }
  }
  Bias += RunKey;
  if (Bias == (Col + Row) - 2) //达到最远返回第一行
  {
    RunKey = -1;
  }
  if (Bias == 0) //达到最远返回第一行
  {
    RunKey = 1;
  }
}
/***********第三关程序***********/
void level_3()
{
  static byte SpaceVal = 4; //第三关的网格大小
  static byte RunKey = 1;
  for (int i = 0; i < Row; i++) //清空颜色
  {
    for (int j = 0; j < Col; j++)
    {
      Pane[i][j][1] = Black;
    }
  }

  for (int j = 0; j < Col; j++) //红色X轴轮转
  {
    int i = 0;
    for (int i = 0; RowRunId + i < Row; i += SpaceVal)
    { //判断i是否小于等于零
      Pane[RowRunId + i][j][1] = Red;
    }
  }
  RowRunId += RunKey;
  if (RowRunId == SpaceVal) //达到最远返回第一行
  {
    RowRunId = 0;
  }

  for (int i = 0; i < Row; i++) //红色Y轴轮转
  {
    for (int j = 0; ColRunId + j < Col; j += SpaceVal)
    { //判断i是否小于等于零
      Pane[i][ColRunId + j][1] = Red;
    }
  }
  ColRunId += RunKey;
  if (ColRunId == SpaceVal) //达到最远返回第一行
  {
    ColRunId = 0;
  }
}
/***********第四关程序***********/
void level_4()
{
  static byte RunKey = 1;
  for (int i = 0; i < Row; i++) //全部红色
  {
    for (int j = 0; j < Col; j++)
    {
      Pane[i][j][1] = Red;
    }
  }
  for (int j = 0; j < Col; j += 2)
  {
    Pane[2][j][1] = Blue;
    Pane[Row - 3][j][1] = Blue;
  }
  for (int i = (Row / 2); i > (Row / 2 - 2); i--) //绿色区域
  {
    for (int j = 0; j < Col; j++)
    {
      Pane[i][j][1] = Green;
    }
  }
}
/***********第五关程序***********/
void level_5()
{
  static byte RunKey = 1;
  static byte RedSpace_Long = 6;
  static byte RedSpace_Wide = 2;
  static byte RunId = 0;
  static int Upper_left[] = {0 + RedSpace_Wide - 1, 1}; //左上往下Row[0]>Row[Row-1]
  static int Lower_left[] = {0 + RedSpace_Wide - 1, 0}; //左下往右Col[0]>Col[Col-1]
  static int Lower_right[] = {Row - RedSpace_Wide, 0};  //右下往上
  static int Upper_right[] = {Col - RedSpace_Wide, 0};  //右上往左
  for (int i = 0; i < Row; i++)                         //清空颜色
  {
    for (int j = 0; j < Col; j++)
    {
      Pane[i][j][1] = Black;
    }
  }
  //左上开始//左上开始//左上开始//左上开始
  if (Upper_left[1] == 1) //左上开始
  {
    for (int i = 0; i < RedSpace_Long; i++)
    {
      for (int j = 0; j < RedSpace_Wide; j++) //红色轮转
      {
        if ((Upper_left[0] - i) >= 0 && (Upper_left[0] - i) < Row)
        {
          Pane[Upper_left[0] - i][j][1] = Red;
        }
      }
    }
    if (Upper_left[0] <= Row + RedSpace_Long) //达到最远返回第一行
    {
      Serial.print(Upper_left[0]);
      Upper_left[0] += RunKey;
    }
    if (Upper_left[0] >= Row) //达到最远返回第一行
    {
      Serial.print("RUN-1");
      Lower_left[1] = 1; //左下开始
    }
    if (Upper_left[0] >= (Row + RedSpace_Long - RedSpace_Wide))
    {
      Upper_left[1] = 0;
      Upper_left[0] = RedSpace_Wide - 1;
    }
  }
  //左下开始//左下开始//左下开始//左下开始
  if (Lower_left[1] == 1) //左下开始
  {
    for (int i = Row - 1; i >= (Row - RedSpace_Wide); i--)
    {
      for (int j = 0; j < RedSpace_Long; j++)
      {
        if ((Lower_left[0] - j) >= 0 && (Lower_left[0] - j) < Col)
        {
          Pane[i][Lower_left[0] - j][1] = Red;
        }
      }
    }
    if (Lower_left[0] <= (Col + RedSpace_Long)) //达到最远返回第一行
    {
      Lower_left[0] += RunKey;
      Serial.print(Lower_left[0]);
    }
    if (Lower_left[0] >= Col) //达到最远返回第一行
    {
      Serial.print("RUN-2");
      Lower_right[1] = 1; //右下开始
    }
    if (Lower_left[0] >= (Col + RedSpace_Long - RedSpace_Wide))
    {
      Lower_left[1] = 0;
      Lower_left[0] = RedSpace_Wide - 1;
    }
  }
  //右下开始//右下开始//右下开始//右下开始
  if (Lower_right[1] == 1) //右下开始
  {

    for (int i = 0; i < RedSpace_Long; i++)
    {
      for (int j = Col - 1; j >= (Col - RedSpace_Wide); j--)
      {
        if ((Lower_right[0] + i) >= 0 && (Lower_right[0] + i) <= Row)
        {
          Serial.print(Lower_right[0]);
          Pane[Lower_right[0] + i][j][1] = Red;
        }
      }
    }
    if (Lower_right[0] <= (Row + RedSpace_Long)) //达到最远返回第一行
    {
      Lower_right[0] -= RunKey;
    }
    if (Lower_right[0] < 0) //达到最远返回第一行
    {
      Serial.print("RUN-3");
      Upper_right[1] = 1; //右上开始
    }
    if (Lower_right[0] <= (0 - RedSpace_Long + RedSpace_Wide - 1))
    {
      Lower_right[1] = 0;
      Lower_right[0] = Row - RedSpace_Wide;
    }
  }
  //右上开始//右上开始//右上开始//右上开始//右上开始//右上开始
  if (Upper_right[1] == 1) //右上开始
  {

    for (int i = 0; i < RedSpace_Wide; i++)
    {
      for (int j = 0; j < RedSpace_Long; j++)
      {
        if ((Upper_right[0] + j) >= 0 && (Upper_right[0] + j) < Col)
        {
          Pane[i][Upper_right[0] + j][1] = Red;
        }
      }
    }
    if (Upper_right[0] <= (Col + RedSpace_Long)) //达到最远返回第一行
    {
      Upper_right[0] -= RunKey;
      Serial.print(Upper_right[0]);
    }
    if (Upper_right[0] <= 0) //达到最远返回第一行
    {
      Serial.print("RUN-0");
      Upper_left[1] = 1; //左上开始
    }
    if (Upper_right[0] <= (0 - RedSpace_Long + RedSpace_Wide))
    {
      Upper_right[1] = 0;
      Upper_right[0] = Col - RedSpace_Wide;
    }
  }
}
/***********第六关程序***********/
void level_6()
{
  static int Uppe = 0;
  static int Lower = Row - 1;
  static int Left = 0;
  static int Right = Col - 1;
  static int RunId = 1;
  for (int i = 0; i < Row; i++) //清空颜色
  {
    for (int j = 0; j < Col; j++)
    {
      Pane[i][j][1] = Black;
    }
  }
  ////////////////////////////////////////////
  for (int j = 0; j < Col; j++) //上往下
  {
    Pane[Uppe][j][1] = Red;
  }
  Uppe += RunId;
  if (Uppe >= Row - 1)
  {
    Uppe = 0;
  }
  ////////////////////////////////////////////
  for (int j = 0; j < Col; j++) //下往上
  {
    Pane[Lower][j][1] = Red;
  }
  Lower -= RunId;
  if (Lower <= 0)
  {
    Lower = Row - 1;
  }

  ////////////////////////////////////////////
  for (int i = 0; i < Row; i++) //左往右
  {
    Pane[i][Left][1] = Red;
  }
  Left += RunId;
  if (Left >= Col - 1)
  {
    Left = 0;
  }
  ////////////////////////////////////////////
  for (int i = 0; i < Row; i++) //右往左
  {
    Pane[i][Right][1] = Red;
  }
  Right -= RunId;
  if (Right <= 0)
  {
    Right = Col - 1;
  }
}
/***********第七关程序***********/
void level_7()
{
  static int Uppe[] = {0, 0};
  static int Lower[] = {Row - 1, 0};
  static int Left[] = {0, 0};
  static int Right[] = {Col - 1, 0};
  static int RunId = 1;
  for (int i = 0; i < Row; i++) //清空颜色
  {
    for (int j = 0; j < Col; j++)
    {
      Pane[i][j][1] = Black;
    }
  }
  ////////////////////////////////////////////
  for (int j = 0 + Uppe[1]; j < Col - Uppe[1]; j++) //上往下
  {
    Pane[Uppe[0]][j][1] = Red;
  }
  Uppe[1]++;
  Uppe[0] += RunId;
  if (Uppe[0] >= Row/2)
  {
    Uppe[0] = 0;
    Uppe[1] = 0;

  }
  ////////////////////////////////////////////
  for (int j = 0 +Lower[1]; j < Col-Lower[1]; j++) //下往上
  {

    Pane[Lower[0]][j][1] = Red;
  }
  Lower[0] -= RunId;
  Lower[1]++;
  if (Lower[0] < Row/2)
  {
    Lower[0] = Row - 1;
    Lower[1] = 0;
    }

  ////////////////////////////////////////////
  for (int i = 0+Left[1]; i < Row-Left[1]; i++) //左往右
  {
    Pane[i][Left[0]][1] = Red;
  }
  Left[0] += RunId;
  Left[1]++;
  if (Left[0] >=  Col/2)
  {
    Left[1] = 0;
    Left[0] = 0;
  }
  ////////////////////////////////////////////
  for (int i = 0+Right[1]; i < Row-Right[1]; i++) //右往左
  {
    Pane[i][Right[0]][1] = Red;
  }
  Right[1]++;
  Right[0] -= RunId;
  if (Right[0] <= Col/2)
  {
    Right[0] = Col - 1;
    Right[1] = 0;
  }
}

/*写入颜色数据*/
void BitWrite_Color()
{
  for (int i = 0; i < Col; i++) //清空颜色
  {
    for (int j = 0; j < 4; j++)
    {
      Pane_Row_Color[i][0][j] = 0;
    }
  }
  for (int i = 0; i < Col; i++)
  {
    for (int j = Row + 1; j >= 2; j--) //写入颜色亮灭状态,从22位Bit开始写入写到第2位停下.共写入20个数据
    {
      switch (Pane[i][j - 2][1])
      {
        case 1: //写入红色
          bitWrite(Pane_Row_Color[i][0][0], j, 0);
          bitWrite(Pane_Row_Color[i][0][1], j, 1);
          bitWrite(Pane_Row_Color[i][0][2], j, 0);
          bitWrite(Pane_Row_Color[i][0][3], j, 0);
          break;
        case 2: //写入绿色
          bitWrite(Pane_Row_Color[i][0][0], j, 0);
          bitWrite(Pane_Row_Color[i][0][1], j, 0);
          bitWrite(Pane_Row_Color[i][0][2], j, 1);
          bitWrite(Pane_Row_Color[i][0][3], j, 0);
          break;
        case 3: //写入蓝色
          bitWrite(Pane_Row_Color[i][0][0], j, 0);
          bitWrite(Pane_Row_Color[i][0][1], j, 0);
          bitWrite(Pane_Row_Color[i][0][2], j, 0);
          bitWrite(Pane_Row_Color[i][0][3], j, 1);
          break;
        default: //写入黑色
          bitWrite(Pane_Row_Color[i][0][0], j, 1);
          bitWrite(Pane_Row_Color[i][0][1], j, 0);
          bitWrite(Pane_Row_Color[i][0][2], j, 0);
          bitWrite(Pane_Row_Color[i][0][3], j, 0);
          break;
      };
    };
  };
  for (int i = 0; i < Row; i++) //写入颜色编码
  {
    bitWrite(Pane_Row_Color[i][0][0], 0, 0); //黑色编码00
    bitWrite(Pane_Row_Color[i][0][0], 1, 0);
    bitWrite(Pane_Row_Color[i][0][1], 0, 1); //红色编码01
    bitWrite(Pane_Row_Color[i][0][1], 1, 0);
    bitWrite(Pane_Row_Color[i][0][2], 0, 0); //绿色编码10
    bitWrite(Pane_Row_Color[i][0][2], 1, 1);
    bitWrite(Pane_Row_Color[i][0][3], 0, 1); //蓝色编码11
    bitWrite(Pane_Row_Color[i][0][3], 1, 1);
  }
}

void Compare_Send() //比较有改变颜色的行的发送
{
  for (int i = 0; i < Row; i++) //历遍每一行
  {
    for (int j = 0; j < 4; j++) //历遍颜色 跳过黑色0所以J从1开始
    {
      if (Pane_Row_Color[i][0][j] == Pane_Row_Color[i][1][j]) //比较新颜色和当前的是否一样
      {
        Pane_Row_Color[i][1][j] = Pane_Row_Color[i][0][j]; //把新颜色存在当前颜色变量里
      }
      else
      {
        Serial.print(RowMare[i]);                          //发送行标
        Serial.print(Pane_Row_Color[i][0][j]);             //发送颜色数据
        Serial.print(",");                                 // 发送终止符
        Pane_Row_Color[i][1][j] = Pane_Row_Color[i][0][j]; //把新颜色存在当前颜色变量里
      }
    }
  }
  Serial.println();
  // Serial.println("---------------------------");
}
void GetSlave() //从机回传的传感器数据
{
  while (Serial.available())
  {
    GetSlaveVal = GetSlaveVal + char(Serial.read());
    delay(2);
  }
  if (GetSlaveVal.length() > 0)
  {
    IntSlaveVal = GetSlaveVal.toInt();
    Trigger(); //判断触发
    // Serial.print(IntSlaveVal);
    GetSlaveVal = ""; //数据清零
  }
}
void Trigger() //触发灯砖反馈
{

  for (int i = 0; i < Row; i++)
  {
    for (int j = 0; j < Col; j++)
    {
      if (Pane[i][j][0] == IntSlaveVal)
      {
        if (Pane[i][j][1] == Red)
        {
          // Serial.print("red");
          TriggerRed();
          break;
        }
        else if (Pane[i][j][1] == Blue)
        {
          // Serial.print("blue");
          TriggerBlue(i, j);
          break;
        }
      }
    }
  }
}
void TriggerRed() //触发红色灯灯砖
{
  for (int i = 0; i < Row; i++) //清空颜色
  {
    for (int j = 0; j < Col; j++)
    {
      Pane[i][j][1] = Red;
    }
  }
  //  BitWrite_Color();//写入颜色数据
  //  Compare_Send();//比较有改变颜色的行的发送
  Print_Pane_Color(); //调试打印方块颜色码
  delay(500);
  for (int i = 0; i < Row; i++) //清空颜色
  {
    for (int j = 0; j < Col; j++)
    {
      Pane[i][j][1] = Black;
    }
  }
  //   BitWrite_Color();//写入颜色数据
  //   Compare_Send();//比较有改变颜色的行的发送
  Print_Pane_Color(); //调试打印方块颜色码
  delay(500);
}

void TriggerBlue(int r, int c) //触发蓝色色灯灯砖
{
  Pane[r][c][3] = Black;
  //  BitWrite_Color();//写入颜色数据
  //  Compare_Send();//比较有改变颜色的行的发送
  Serial.print("Pane:");
  Serial.print(Pane[r][c][0]);
  Serial.println(" = Off");
  Number = Number + 1;
  Serial.print("Number = ");
  Serial.print(Number);
}
void Print_BIN() //调试打印颜色二进制码
{
  for (int i = 0; i < Row; i++)
  {
    Serial.println();
    Serial.print("color ");
    Serial.print(i);
    Serial.print(" = ");
    Serial.println(Pane_Row_Color[0][0][i], BIN);
  }

  Serial.println("------------------------------------------");
}
void Print_Pane_Color() //调试打印方块颜色码
{
  ansi.cursorBack(10);
  Serial.println();
  for (int i = 0; i < Row; i++)
  {
    for (int j = 0; j < Col; j++)
    {
      if (Pane[i][j][1] == 1)
      {
        ansi.background(ANSI::red);
        Serial.print(Pane[i][j][1]);
        Serial.print(" ");
      }
      if (Pane[i][j][1] == 2)
      {
        ansi.background(ANSI::green);
        Serial.print(Pane[i][j][1]);
        Serial.print(" ");
      }
      if (Pane[i][j][1] == 3)
      {
        ansi.background(ANSI::blue);
        Serial.print(Pane[i][j][1]);
        Serial.print(" ");
      }
      if (Pane[i][j][1] == 0)
      {
        ansi.background(ANSI::black);
        Serial.print(Pane[i][j][1]);
        Serial.print(" ");
      }
      ansi.normal();
    }
    Serial.println();
    // ansi.cursorBack(1);
  }
  // Serial.println("------------------------------------------");
}
void ColorKey() //初始化写入颜色编码
{
  for (int i = 0; i < Row; i++) //清空颜色
  {
    for (int j = 0; j < 4; j++)
    {
      Pane_Row_Color[i][1][j] = 0;
    }
  }
  for (int i = 0; i < Row; i++) //写入颜色编码
  {
    bitWrite(Pane_Row_Color[i][1][0], 0, 0); //黑色编码00
    bitWrite(Pane_Row_Color[i][1][0], 1, 0);
    bitWrite(Pane_Row_Color[i][1][1], 0, 1); //红色编码01
    bitWrite(Pane_Row_Color[i][1][1], 1, 0);
    bitWrite(Pane_Row_Color[i][1][2], 0, 0); //绿色编码10
    bitWrite(Pane_Row_Color[i][1][2], 1, 1);
    bitWrite(Pane_Row_Color[i][1][3], 0, 1); //蓝色编码11
    bitWrite(Pane_Row_Color[i][1][3], 1, 1);
  }
}
void WriteArray1() //初始化赋值灯砖ID数组  1,2,3
{
  int k = 0;
  for (int i = 0; i < Row; i++)
  {
    for (int j = 0; j < Col; j++)
    {
      Pane[i][j][0] = k;
      k++;
    };
  };
}
void WriteArray2() //初始化赋值灯砖ID数组  0,3,6
{
  int k = 0;
  for (int i = 0; i < Row; i++)
  {
    for (int j = 0; j < Col; j++)
    {
      Pane[j][i][0] = k;
      k++;
    };
  };
}
void WriteArray3() //初始化赋值灯砖ID数组  6,7,8
{
  int k = 0;
  for (int i = Col - 1; i >= 0; i--)
  {
    for (int j = 0; j < Row; j++)
    {
      Pane[i][j][0] = k;
      k++;
    };
  };
}
void WriteArray4() //初始化赋值灯砖ID数组  8,7,6
{
  int k = 0;
  for (int i = Col - 1; i >= 0; i--)
  {
    for (int j = Col - 1; j >= 0; j--)
    {
      Pane[i][j][0] = k;
      k++;
    };
  };
}
void WriteArray5() //初始化赋值灯砖ID数组  2,1,0
{
  int k = 0;
  for (int i = 0; i < Row; i++)
  {
    for (int j = Col - 1; j >= 0; j--)
    {
      Pane[i][j][0] = k;
      k++;
    };
  };
}
void PrintArray()
{
  Serial.println();
  for (int i = 0; i < Row; i++)
  {
    for (int j = 0; j < Col; j++)
    {
      Serial.print(Pane[i][j][0]);
      Serial.print(",");
    };
    Serial.println();
  };
}