//+------------------------------------------------------------------+
//|                                                      Cudrado.mqh |
//|                                  Copyright 2025, Niquel Mendoza. |
//|                     https://www.mql5.com/es/users/nique_372/news |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Niquel Mendoza."
#property link      "https://www.mql5.com/es/users/nique_372/news"
#property strict

#include "Base.mqh"

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CTetrisFiguraCuadrado : public CTetrisFigura
 {
protected:

  //---
  void               Draw() override;
  void               CleanPixles() override;

public:
  //CTetrisFiguraCuadrado(void);
  //~CTetrisFiguraCuadrado(void);

  //--- Tipo
  inline ENUM_TETRIS_FIGURA_TYPE Type() const override { return TETRIS_FIGURA_CUADRADO; }

  //--- Rotacion
  // Rotacion custom
  void               Rotate(ENUM_TETRIS_FIGURA_POSITION pos) override;

  //--- Colision
  bool               Colisiona(ENUM_TETRIS_DIR direcicon_preferida, int x, int y) override { return true; }

  //--- Obtencino de pixeles
  // Obtiene todos los pixeles ocupados
  void               GetOcupatePixels(int& pixels_pos[]) override;
  // Obtine ela 1era linea de los ocupados por direccion
  void               GetOcupatePixels(ENUM_TETRIS_DIR direcicon, int& pixels_pos[]) override;

  // Obtine ela 1era linea de los ocupados por y_direccion
  // Se especifica el y1 al que se movera la figura
  void               GetOcupatePixels(int y1, EMUM_TETRIS_DIR_SENT_Y y_direccion, int& pixels_pos[]) override;

  // Obtinee la 1era linea de los opcuados por xdireccion
  // Se espifica el x1 al que se movera la figura
  void               GetOcupatePixels(int x1, EMUM_TETRIS_DIR_SENT_X x_direccion, int& pixels_pos[]) override;


  //---
  int                CalculateMinPixelsInYAbajo(int y, int& out_x) const override;
  int                CalculateMinPixelsInYAbajo(int& out_x) const;
 };



//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CTetrisFiguraCuadrado::CalculateMinPixelsInYAbajo(int y, int& out_x) const
 {
  out_x = m_x1; // Da lo mismo para cuadrado
  return y + fabs(m_y2 - m_y1);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int  CTetrisFiguraCuadrado::CalculateMinPixelsInYAbajo(int& out_x) const
 {
  out_x = m_x1;
  return m_y2; //Y2 el minimo
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CTetrisFiguraCuadrado::GetOcupatePixels(int x1, EMUM_TETRIS_DIR_SENT_X x_direccion, int &pixels_pos[])
 {
  switch(x_direccion)
   {
    case  TETRIS_DIR_X_IZQUIERDA:
     {
      //---
      const int size_y = fabs(m_y2 - m_y1) + 1;
      ArrayResize(pixels_pos, size_y);

      //---
      int y = m_y1;
      for(int k = 0; k < size_y; k++)
       {
        const int pos = y * m_width + x1;
        pixels_pos[k] = pos;
        y++;
       }
      break;
     }
    case  TETRIS_DIR_X_DERECHA:
     {
      //---
      const int size_y = fabs(m_y2 - m_y1) + 1;
      ArrayResize(pixels_pos, size_y);
      const int x2 = x1 + DistX();

      //---
      int y = m_y1;
      for(int k = 0; k < size_y; k++)
       {
        const int pos = y * m_width + x2;
        pixels_pos[k] = pos;
        y++;
       }
      break;
     }
    default:
      break;
   }
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CTetrisFiguraCuadrado::GetOcupatePixels(int y1, EMUM_TETRIS_DIR_SENT_Y y_direccion, int &pixels_pos[])
 {
  switch(y_direccion)
   {
    case  TETRIS_DIR_Y_ARRIBA:
     {
      //---
      const int size_x = fabs(m_x2 - m_x1) + 1;
      ArrayResize(pixels_pos, size_x);
      //---
      int x = m_x1;
      for(int k = 0; k < size_x; k++)
       {
        const int pos = y1 * m_width + x;
        pixels_pos[k] = pos;
        x++;
       }
      break;
     }
    case  TETRIS_DIR_Y_ABAJO:
     {
      //---
      const int size_x = fabs(m_x2 - m_x1) + 1;
      ArrayResize(pixels_pos, size_x);
      const int y2 = y1 + DistY();
      //---
      int x = m_x1;
      for(int k = 0; k < size_x; k++)
       {
        const int pos = y2 * m_width + x;
        pixels_pos[k] = pos;
        x++;
       }
      break;
     }
    default:
      break;
   }
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CTetrisFiguraCuadrado::GetOcupatePixels(ENUM_TETRIS_DIR direcicon, int &pixels_pos[])
 {
  switch(direcicon)
   {
    case  TETRIS_DIR_ARRIBA:
     {
      //---
      const int size_x = fabs(m_x2 - m_x1) + 1;
      ArrayResize(pixels_pos, size_x);
      //---
      int x = m_x1;
      for(int k = 0; k < size_x; k++)
       {
        const int pos = m_y1 * m_width + x;
        pixels_pos[k] = pos;
        x++;
       }
      break;
     }
    case  TETRIS_DIR_ABAJO:
     {
      //---
      const int size_x = fabs(m_x2 - m_x1) + 1;
      ArrayResize(pixels_pos, size_x);
      //---
      int x = m_x1;
      for(int k = 0; k < size_x; k++)
       {
        const int pos = m_y2 * m_width + x;
        pixels_pos[k] = pos;
        x++;
       }
      break;
     }
    case  TETRIS_DIR_DERECHA:
     {
      //---
      const int size_y = fabs(m_y2 - m_y1) + 1;
      ArrayResize(pixels_pos, size_y);
      //---
      int y = m_y1;
      for(int k = 0; k < size_y; k++)
       {
        const int pos = y * m_width + m_x2;
        pixels_pos[k] = pos;
        y++;
       }
      break;
     }
    case  TETRIS_DIR_IZQUIERDA:
     {
      //---
      const int size_y = fabs(m_y2 - m_y1) + 1;
      ArrayResize(pixels_pos, size_y);
      //---
      int y = m_y1;
      for(int k = 0; k < size_y; k++)
       {
        const int pos = y * m_width + m_x2;
        pixels_pos[k] = pos;
        y++;
       }
      break;
     }
    default:
      break;
   }
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CTetrisFiguraCuadrado::GetOcupatePixels(int &pixels_pos[])
 {
  const int size_y = fabs(m_y2 - m_y1) + 1;
  const int size_x = fabs(m_x2 - m_x1) + 1;
  const int size = (size_y * size_x);
  ArrayResize(pixels_pos, size);
// Print(size);

//---
  int y = m_y1, x = m_x1;
  for(int i = 0; i < size_y; i++)
   {
    //Print("Fila: ", i);
    x = m_x1;
    for(int k = 0; k < size_x; k++)
     {
      const int pos = y * m_width + x;
      // Print("y: ", y, " | x: ", x, " | IdxReal: ", pos);
      pixels_pos[(i * size_x + k)] = pos;
      x++;
     }

    //---
    y++;
   }
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CTetrisFiguraCuadrado::Draw(void)
 {
  m_canvas.FillRectangle(m_x1, m_y1, m_x2, m_y2, m_color);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CTetrisFiguraCuadrado::CleanPixles()
 {
  m_canvas.FillRectangle(m_x1, m_y1, m_x2, m_y2, m_clr_clean);
 }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CTetrisFiguraCuadrado::Rotate(ENUM_TETRIS_FIGURA_POSITION pos)
 {
  m_position = pos;
// No hacemos nada
 }

/*
  TESTRIS_COLISION_NORTE = 0,
  TESTRIS_COLISION_ESTE = 1,
  TESTRIS_COLISION_OESTE = 2,
  TESTRIS_COLISION_SUR = 3
*/



//+------------------------------------------------------------------+