unboundmodedemointminerfield.cpp

DevExpress ExpressQuantumGrid Suite v5.9 Full Source

#include "UnboundModeDemoIntMinerField.h"

void __fastcall TIntMinerField::SetSchemeColors(void)
{
  FOpenCellBkColor = SchemeColors[(int)FColorScheme][0];
  FClosedCellBkColor = SchemeColors[(int)FColorScheme][1];
  FFrameColor = SchemeColors[(int)FColorScheme][2];
  FRectangleColor = SchemeColors[(int)FColorScheme][3];
}
//---------------------------------------------------------------------------

TCellStateRec __fastcall TIntMinerField::GetCellState(int ACol, int ARow)
{
  return (*(PCellStateRec)(int)((TcxGridTableView*)Views[0])->
    ViewInfo->RecordsViewInfo->Items[ARow]->GetCellViewInfoByItem(
    ((TcxGridTableView*)Views[0])->Items[ACol])->Value );
}
//---------------------------------------------------------------------------

void __fastcall TIntMinerField::AddPressedCell(int ACol, int ARow)
{
  FPressedCells.Length++;
  FPressedCells[FPressedCells.Length - 1].x = ACol;
  FPressedCells[FPressedCells.Length - 1].y = ARow;
}
//---------------------------------------------------------------------------

bool __fastcall TIntMinerField::CheckFieldBounds(int AXPos, int AYPos)
{
   bool Result = false;
   if((AXPos >=0) && (AYPos >=0) && (AXPos < FColCount) &&
     (AYPos < FRowCount)) Result = true;
   return (Result);
}
//---------------------------------------------------------------------------

void __fastcall TIntMinerField::InitNewGame(void)
{
  FRedCells.Length = 0;

  FColCount = FGameDifficulty.Width;
  FRowCount = FGameDifficulty.Height;
  BeginUpdate();
  try {

    Width = FColCount * FCellWidth + 2;
    Height = FRowCount * FCellWidth + 2;
    Top = psBorder + biBoardHeight - psOuterFrameWidth;
    Left = psBorder;

    int par = ((TForm*)Owner)->ClientRect.Right - ((TForm*)Owner)->ClientRect.Left;
    par = ((TForm*)Owner)->Width - par - psOuterFrameWidth;
    ((TForm*)Owner)->Width = 2 * psBorder + Width + par;

    par = ((TForm*)Owner)->ClientRect.Bottom - ((TForm*)Owner)->ClientRect.Top;
    par = ((TForm*)Owner)->Height - par;
    ((TForm*)Owner)->Height = par +  2 * (psBorder - psOuterFrameWidth) + biBoardHeight + Height;
    ((TControlAccess*)Owner)->Resize();

    if (!Enabled) Enabled = true;
    TcxGridColumn* GridColumn;
    for(int i = ((TcxGridTableView*)Views[0])->ColumnCount - 1; i == FColCount; i--)
      delete ((TcxGridTableView*)Views[0])->Columns[i];
    for(int i=0; i < FGameDifficulty.Width; i++) {
      if (i >= ((TcxGridTableView*)Views[0])->ColumnCount) {
        GridColumn = ((TcxGridTableView*)Views[0])->CreateColumn();
        GridColumn->MinWidth = FCellWidth;
        GridColumn->Width = FCellWidth;
      }
    }
  }
  __finally {
    EndUpdate();
  }
}
//---------------------------------------------------------------------------

void __fastcall TIntMinerField::UnpressAndInvalidate(void)
{
  TCells CellsToInvalidate;
  CellsToInvalidate.Length = FPressedCells.Length;
  for(int i=0; i < FPressedCells.Length; i++)
    CellsToInvalidate[i] = FPressedCells[i];
  FPressedCells.Length = 0;
  for(int i=0; i < CellsToInvalidate.Length; i++)
    InvalidateCell(CellsToInvalidate[i].x, CellsToInvalidate[i].y);
}
//---------------------------------------------------------------------------

void __fastcall TIntMinerField::InvalidateCells(const TCells AChangedCells, const TCells ARedCells)
{
  for(int i=0; i < AChangedCells.Length; i++)
    InvalidateCell(AChangedCells[i].x, AChangedCells[i].y);
  for(int i=0; i < ARedCells.Length; i++)
    InvalidateCell(ARedCells[i].x, ARedCells[i].y);
}
//---------------------------------------------------------------------------

void __fastcall TIntMinerField::UpdateMinerFieldState(const TCells ARedCells)
{
  FRedCells.Length = ARedCells.Length;
  for(int i=0; i < ARedCells.Length; i++)
    FRedCells[i] = ARedCells[i];
}
//---------------------------------------------------------------------------

void AlignTextInCell(TCanvas* ACanvas, TRect Rect, String AStr, TAlignment Alignment = taCenter)
{
  int Y = 3;
  int X = 1;
  switch(Alignment) {
   case taCenter: X = ((Rect.Right - Rect.Left) - ACanvas->TextWidth(AStr)) >> 1; break;
   case taLeftJustify: X = 1; break;
   case taRightJustify:  X = ((Rect.Right - Rect.Left) - ACanvas->TextWidth(AStr)) -1; break;
  }
  ACanvas->TextOut(Rect.Left + X, Rect.Top + Y, AStr);
}
//---------------------------------------------------------------------------

void __fastcall TIntMinerField::DrawOpenedCell(TCanvas* ACanvas, TRect ARect, TCellStateRec ACellState)
{
  ACanvas->Brush->Color = FOpenCellBkColor;
  ACanvas->FillRect(ARect);
  ACanvas->Pen->Style = psSolid;
  ACanvas->Pen->Color = FRectangleColor;
  ARect.Left--; ARect.Top--;
  ACanvas->Rectangle(ARect.Left, ARect.Top, ARect.Right, ARect.Bottom);
  ARect.Right--; ARect.Bottom--;
  ACanvas->Font->Style = TFontStyles() << fsBold;
  if(ACellState.SurroundNumber >= 1)
    ACanvas->Font->Color = FSurroundColors[ACellState.SurroundNumber-1];
  Brush->Style = bsClear;
  if(ACellState.SurroundNumber != 0)
    AlignTextInCell(ACanvas, ARect, IntToStr(ACellState.SurroundNumber));
}

void __fastcall TIntMinerField::DrawClosedCell(TCanvas* ACanvas, TRect ARect, TCellStateRec ACellState, int ACol, int ARow)
{
  if(FGameStatus == gsLost) {
    if(IsExistsInArray(FRedCells, ACol, ARow)) {
      // red bomb on an empty background
      ACanvas->Brush->Color = FOpenCellBkColor;
      ACanvas->FillRect(ARect);

      ACanvas->Brush->Style = bsSolid;
      ACanvas->Brush->Color = clRed;
      ARect.Right--;
      ARect.Bottom--;
      ACanvas->FillRect(ARect);
      ACanvas->Brush->Style = bsClear;
      ARect.Left++; ARect.Top++;
      ARect.Right++; ARect.Bottom--;
      FImages->Draw(ACanvas, ARect.Left, ARect.Top, imRedBomb, true);
      return;
    }
    if(ACellState.SurroundNumber == -1) {
      ACanvas->Brush->Color = FOpenCellBkColor;
      ACanvas->FillRect(ARect);
      ACanvas->Pen->Style = psSolid;
      ACanvas->Pen->Color = FRectangleColor;
      ARect.Left--; ARect.Top--;
      ACanvas->Rectangle(ARect.Left, ARect.Top, ARect.Right, ARect.Bottom);
      ARect.Left = ARect.Left + 2;
      ARect.Top = ARect.Top + 2;
      ACanvas->Brush->Style = bsClear;
      FImages->Draw(ACanvas, ARect.Left, ARect.Top, imBomb, true);  // bomb image
    }
    else
      Frame3D(ACanvas, ARect, FFrameColor, FOpenCellBkColor, 1); // unpressed
  }
  else
  if((FGameStatus == gsNew) || (FGameStatus == gsRun)) {
    if(IsExistsInArray(FPressedCells, ACol, ARow))
      Frame3D(ACanvas, ARect, FOpenCellBkColor, FFrameColor, 1); // pressed
    else 
      Frame3D(ACanvas, ARect, FFrameColor, FOpenCellBkColor, 1); // unpressed
  }
  if(FGameStatus == gsWon) {
     Frame3D(ACanvas, ARect, FFrameColor, FOpenCellBkColor, 1); // unpressed
     if(ACellState.SurroundNumber == -1)
       FImages->Draw(ACanvas, ARect.Left, ARect.Top, imBombMark, true);  // bomb flag
  }
}

void __fastcall TIntMinerField::DrawBombMarkedCell(TCanvas* ACanvas, TRect ARect, TCellStateRec ACellState)
{
  if(FGameStatus == gsLost) {
    if(ACellState.SurroundNumber == -1) {
      Frame3D(ACanvas, ARect, FFrameColor, FOpenCellBkColor, 1); // unpressed
      FImages->Draw(ACanvas, ARect.Left, ARect.Top, imBombMark, true);  // bomb flag
    }
    else {
      // striked out bomb on an empty background
      ACanvas->Brush->Color = FOpenCellBkColor;
      ACanvas->FillRect(ARect);
      ACanvas->Pen->Style = psSolid;
      ACanvas->Pen->Color = FRectangleColor;
      ARect.Left--; ARect.Top--;
      ACanvas->Rectangle(ARect.Left, ARect.Top, ARect.Right, ARect.Bottom);
      ARect.Left = ARect.Left + 2; ARect.Top = ARect.Top + 2;
      ACanvas->Brush->Style = bsClear;
      FImages->Draw(ACanvas, ARect.Left, ARect.Top, imStruckOutBomb, true);
    }
  } else
  if((FGameStatus == gsRun) || (FGameStatus == gsWon) || (FGameStatus == gsNew)) {
    Frame3D(ACanvas, ARect, FFrameColor, FOpenCellBkColor, 1); // unpressed
    FImages->Draw(ACanvas, ARect.Left, ARect.Top, imBombMark, true);  // bomb flag
  }
}

void __fastcall TIntMinerField::DrawQuestionMarkedCell(TCanvas* ACanvas, TRect ARect, TCellStateRec ACellState, int ACol, int ARow)
{
  if(FGameStatus == gsWon) {
    if(ACellState.SurroundNumber == -1) {
      Frame3D(ACanvas, ARect, FFrameColor, FOpenCellBkColor, 1); // unpressed
      FImages->Draw(ACanvas, ARect.Left, ARect.Top, imBombMark, true);  // bomb flag
    }
  } else
  if(FGameStatus == gsLost) {
    if(ACellState.SurroundNumber == -1) {
      ACanvas->Brush->Color = FClosedCellBkColor;
      ACanvas->FillRect(ARect);
      ACanvas->Pen->Style = psSolid;
      ACanvas->Pen->Color = FOpenCellBkColor;
      ARect.Left--; ARect.Top--;
      ACanvas->Rectangle(ARect.Left, ARect.Top, ARect.Right, ARect.Bottom);
      ARect.Left = ARect.Left + 2; ARect.Top = ARect.Top + 2;
      ACanvas->Brush->Style = bsClear;
      FImages->Draw(ACanvas, ARect.Left, ARect.Top, imBomb, true); // bomb on an empty background
   } else {
     Frame3D(ACanvas, ARect, FFrameColor, FOpenCellBkColor, 1); // unpressesd
     FImages->Draw(ACanvas, ARect.Left, ARect.Top, imQuestionMark, true);      // question mark
   }
   } else
   if((FGameStatus == gsNew) || (FGameStatus == gsRun)) {
     if(!IsExistsInArray(FPressedCells, ACol, ARow))
       Frame3D(ACanvas, ARect, FFrameColor, FOpenCellBkColor, 1); // unpresses
     else
       Frame3D(ACanvas, ARect, FOpenCellBkColor, FFrameColor, 1); // pressed
     FImages->Draw(ACanvas, ARect.Left, ARect.Top, imQuestionMark, true);      // question mark
   }
}

void __fastcall TIntMinerField::DrawCell(const TCellStateRec ACellState, int ACol, int ARow, const TRect &ARect, Graphics::TCanvas* ACanvas)
{
  String CellStr;
  ACanvas->Brush->Style = bsSolid;
  ACanvas->Brush->Color = FClosedCellBkColor;
  ACanvas->FillRect(ARect);
  switch (ACellState.CellState) {
    case csOpened: DrawOpenedCell(ACanvas, ARect, ACellState); break;
    case csClosed: DrawClosedCell(ACanvas, ARect, ACellState, ACol, ARow); break;
    case csBombMarked: DrawBombMarkedCell(ACanvas, ARect, ACellState); break;
    case csQuestionMarked: DrawQuestionMarkedCell(ACanvas, ARect, ACellState, ACol, ARow); break;
  };
}
//---------------------------------------------------------------------------

void __fastcall TIntMinerField::InvalidateCell(int ACol, int ARow)
{
  TRect InvalidRect = ((TcxGridTableView*)Views[0])->ViewInfo->RecordsViewInfo->Items[ARow]->GetCellViewInfoByItem(((TcxGridTableView*)Views[0])->Items[ACol])->Bounds;
  Views[0]->Painter->Invalidate(InvalidRect);
}
//---------------------------------------------------------------------------

void __fastcall TIntMinerField::MouseDownHandler(System::TObject* Sender, Controls::TMouseButton Button, Classes::TShiftState Shift, int X, int Y)
{
  int ACol, ARow;

  SetCaptureControl(Views[0]->Site);
  MouseToCell(X, Y, ACol, ARow);
  if((ACol == - 1) || (ARow == -1))
    return;

  if((Shift == (TShiftState() << ssLeft << ssRight)) || (Shift == (TShiftState() << ssLeft << ssRight))
    || (Shift == (TShiftState() << ssMiddle)) || (Shift == (TShiftState() << ssLeft << ssMiddle))
    || (Shift == (TShiftState() << ssRight << ssMiddle))) {
    FireImageChanged(imAstonisment);
    FSurprised = true;
    for(int i=-1; i <=1; i++)
      for(int j=-1; j <=1; j++)
          if(CheckFieldBounds(ACol+i, ARow+j) && (
            (CellState[ACol+i][ARow+j].CellState == csClosed)
            || (CellState[ACol+i][ARow+j].CellState == csQuestionMarked))) {
            AddPressedCell(ACol+i, ARow+j);
            InvalidateCell(ACol+i, ARow+j);
          };
    return;
  };

  if(Button == mbLeft) {
    FireImageChanged(imAstonisment);
    FSurprised = true;
    if((CellState[ACol][ARow].CellState == csClosed)
        || (CellState[ACol][ARow].CellState == csQuestionMarked)) {
        AddPressedCell(ACol, ARow);
        InvalidateCell(ACol, ARow);
      };
    return;
  };

  if(Button == mbRight) {
    if(CellState[ACol][ARow].CellState == csOpened) return;