{ *********************************************************************** }
{                                                                         }
{ Суперпрограмма автоматизирует деятельность любого секретаря.            }
{ Посвящается всем секретарям, которых я любил, и которых не успел.       }
{                                                                         }
{ *********************************************************************** }

program Sweeper;

uses
  Windows;

const
  cDefault = - 1 ;
  cFoundBomb = - 2 ;
  cRealBomb = - 3 ;
  cError = - 4 ;

  //отступы собственно шашечек
  cVerticalOffset =  55 ;
  cHorizontalOffset =  12 ;
  cBackOffset =  8 ;
  cCellSize =  16 ;

  //не рекомендуется ставить мало. Окно должно прорисовать СЯ, да и вообще...
  cStandardDelay =  300 ;

  //окно и приложение
  cWindowClass = 'Minesweeper';
  cExecutable = 'winmine.exe';

var
  FMainWindow: HWND =  0 ;
  FWindowInfo: TWindowInfo;
  FFieldWidth: Integer =  0 ;
  FFieldHeight: Integer =  0 ;
  FDC: HDC =  0 ;
  FBitmap: HBitmap =  0 ;
  FBitmapDC: HDC =  0 ;
  FField: array of record
    Value: ShortInt;
    VMul: Byte;
    VDiv: Byte;
  end;

procedure ClickSweeper(X, Y: Integer; RightButton: Boolean);
const
  CDownButtons: array[Boolean] of DWORD = (MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_RIGHTDOWN);
  CUpButtons: array[Boolean] of DWORD = (MOUSEEVENTF_LEFTUP, MOUSEEVENTF_RIGHTUP);
var
  LInput: TInput;
begin
  if IsWindow(FMainWindow) then
  begin
    with FWindowInfo.rcClient do
      SetCursorPos(Left + X, Top + Y);
    ZeroMemory(@LInput, SizeOf(LInput));
    LInput.Itype := INPUT_MOUSE;
    LInput.mi.dwFlags := CDownButtons[RightButton];
    SendInput( 1 , LInput, SizeOf(TInput));
    Sleep(cStandardDelay div  10 );
    LInput.mi.dwFlags := CUpButtons[RightButton];
    SendInput( 1 , LInput, SizeOf(TInput));
  end;
end;

procedure ClickSweeperCell(X, Y: Integer; RightButton: Boolean);
begin
  ClickSweeper(cHorizontalOffset + X * cCellSize + (cCellSize div  2 ),
    cVerticalOffset + Y * cCellSize + (cCellSize div  2 ), RightButton);
end;

procedure DoneSweeper;
begin
  if (FDC <>  0 ) and IsWindow(FMainWindow) then
  begin
    ReleaseDC(FMainWindow, FDC);
    FDC :=  0 ;
  end;
  if FBitmapDC <>  0  then
  begin
    DeleteDC(FBitmapDC);
    FBitmapDC :=  0 ;
  end;
  if FBitmap <>  0  then
  begin
    DeleteObject(FBitmap);
    FBitmap :=  0 ;
  end;
end;

procedure InitSweeper;
var
  LStartInfo: TStartupInfo;
  LProcessInfo: TProcessInformation;
begin
  FMainWindow := FindWindow(cWindowClass, nil);
  if FMainWindow =  0  then
  begin
    ZeroMemory(@LStartInfo, SizeOf(LStartInfo));
    LStartInfo.cb := SizeOf(LStartInfo);
    CreateProcess(nil, cExecutable, nil, nil, False,  0 , nil, nil, LStartInfo, LProcessInfo);
    Sleep(cStandardDelay);
    FMainWindow := FindWindow(cWindowClass, nil);
  end;

  Sleep(cStandardDelay);

  FDC := GetDC(FMainWindow);

  GetWindowInfo(FMainWindow, FWindowInfo);

  with FWindowInfo.rcClient do
  begin
    FBitmap := CreateCompatibleBitmap(FDC, Right - Left, Bottom - Top);
    FBitmapDC := CreateCompatibleDC(FDC);
    SelectObject(FBitmapDC, FBitmap);
    FFieldWidth := (Right - Left - cHorizontalOffset - cBackOffset) div cCellSize;
    FFieldHeight := (Bottom - Top - cVerticalOffset - cBackOffset) div cCellSize;
  end;

  SetLength(FField, FFieldWidth * FFieldHeight) ;
  
  SetWindowPos(FMainWindow, HWND_TOPMOST,  0 ,  0 ,  0 ,  0 , SWP_NOMOVE or SWP_NOSIZE);

end;

function GameFinished: Boolean;
var
  I: Integer;
  LDefaultCount: Integer;
begin
  LDefaultCount :=  0 ;
  Result := False;
  for I :=  0  to FFieldHeight * FFieldWidth  -  1  do
  begin
    Inc(LDefaultCount, Ord(FField[I].Value = cDefault));
    Result := FField[I].Value = cRealBomb;
    if Result then
      Break;
  end;
  Result := Result or (LDefaultCount =  0 );
end;

function SweeperValue(X, Y: Integer): Integer;
begin
  if (X <  0 ) or (Y <  0 ) or (X >= FFieldWidth) or (Y >= FFieldHeight) then
    Result := cError
  else
    Result := FField[X + Y * FFieldWidth].Value;
end;

procedure SkipSweeperGreetings;
var
  LInput: TInput;
  I: Integer;
begin
  ZeroMemory(@LInput, SizeOf(LInput));
  LInput.Itype := INPUT_KEYBOARD;
  for I :=  1  to  2  do
  begin
    LInput.ki.wVk := VK_ESCAPE;
    LInput.ki.dwFlags :=  0 ;
    SendInput( 1 , LInput, SizeOf(TInput));
    LInput.ki.dwFlags := KEYEVENTF_KEYUP;
    SendInput( 1 , LInput, SizeOf(TInput));
  end;
end;

procedure ShotSweeper;
var
  I, J: Integer;
begin
  Sleep(cStandardDelay);

  with FWindowInfo.rcClient do
    BitBlt(FBitmapDC,  0 ,  0 , Right - Left, Bottom - Top, FDC,  0 ,  0 , SRCCOPY);

  //парсинг поля. Кто знает, какого цвета семерка и восьмерка - пусть возьмет с полки пирожок.
  for J :=  0  to FFieldHeight -  1  do
    for I :=  0  to FFieldWidth -  1  do
      with FField[I + J * FFieldWidth] do
    begin
      VMul :=  0 ;
      VDiv :=  1 ;
      case GetPixel(FBitmapDC, cHorizontalOffset + cCellSize * I + (cCellSize div  2 ),
        cVerticalOffset + cCellSize * J + (cCellSize div  2 )) of
          $00C0C0C0:
            case GetPixel(FBitmapDC, cHorizontalOffset + cCellSize * I +  1 ,
              cVerticalOffset + cCellSize * J +  1 ) of
               $00C0C0C0:
                 Value :=  0 ;
               else
                 Value := cDefault;
            end;
          $00FF0000:
            Value :=  1 ;
          $ 00008000 :
            Value :=  2 ;
          $000000FF:
            if GetPixel(FBitmapDC, cHorizontalOffset + cCellSize * I +  13 ,
              cVerticalOffset + cCellSize * J +  13 ) = $000000FF then
                Value := cRealBomb
            else
              Value :=  3 ;
          $ 00800000 :
            Value :=  4 ;
          $ 00000080 :
            Value :=  5 ;
          $00FFFF00:
            Value :=  6 ;
          $ 00000000 :
            if GetPixel(FBitmapDC, cHorizontalOffset + cCellSize * I +  8 ,
              cVerticalOffset + cCellSize * J +  3 ) = $000000FF then
                Value := cFoundBomb
            else if GetPixel(FBitmapDC, cHorizontalOffset + cCellSize * I +  3 ,
              cVerticalOffset + cCellSize * J +  8 ) = $ 00000000  then
                Value := cRealBomb
            else
              Value := cDefault
          else
            Value :=  0 ;
      end;
    end;
end;

procedure StartSweeperGame;
begin
  // клик в смайл, он же "чмок в розовый".
  ClickSweeper((FWindowInfo.rcClient.Right - FWindowInfo.rcClient.Left) div  2 ,
    cVerticalOffset div  2 , False);
end;

procedure SweeperMove(out X, Y: Integer; out RightButton: Boolean);
var
  I, J: Integer;
  LCurMul, LCurDiv: Integer;
  LVar: Double;

  function UpdateVariety(dX, dY : Integer): Boolean;
  begin
    if SweeperValue(dX, dY) = cDefault then
    begin
      X := dX;
      Y := dY;
      if LCurMul =  0  then
      begin
        //стопудово пустая клетка
        RightButton := False;
        Result := True;
      end
      else if LCurMul >= LCurDiv then
      begin
        //стопудово бомба
        RightButton := True;
        Result := True;
      end
      else
        with FField[dX + dY * FFieldWidth] do
        begin
          //запишем вероятности - пригодится воды напиться.
          VMul := VMul * LCurDiv + LCurMul * VDiv;
          VDiv := VDiv * LCurDiv;
          Result := False;
        end
    end
    else
      Result := False;
  end;

begin
  for J :=  0  to FFieldHeight -  1  do
    for I :=  0  to FFieldWidth -  1  do
      if SweeperValue(I, J) >  0  then
      begin
        LCurMul := SweeperValue(I, J) -
          Ord(SweeperValue(I -  1 , J -  1 ) = cFoundBomb) -
          Ord(SweeperValue(I -  1 , J) = cFoundBomb) -
          Ord(SweeperValue(I -  1 , J +  1 ) = cFoundBomb) -
          Ord(SweeperValue(I, J -  1 ) = cFoundBomb) -
          Ord(SweeperValue(I, J +  1 ) = cFoundBomb) -
          Ord(SweeperValue(I +  1 , J -  1 ) = cFoundBomb) -
          Ord(SweeperValue(I +  1 , J) = cFoundBomb) -
          Ord(SweeperValue(I +  1 , J +  1 ) = cFoundBomb);

        LCurDiv :=
          Ord(SweeperValue(I -  1 , J -  1 ) = cDefault) +
          Ord(SweeperValue(I -  1 , J) = cDefault) +
          Ord(SweeperValue(I -  1 , J +  1 ) = cDefault) +
          Ord(SweeperValue(I, J -  1 ) = cDefault) +
          Ord(SweeperValue(I, J +  1 ) = cDefault) +
          Ord(SweeperValue(I +  1 , J -  1 ) = cDefault) +
          Ord(SweeperValue(I +  1 , J) = cDefault) +
          Ord(SweeperValue(I +  1 , J +  1 ) = cDefault);

        if UpdateVariety(I -  1 , J -  1 ) or
          UpdateVariety(I -  1 , J) or
          UpdateVariety(I -  1 , J +  1 ) or
          UpdateVariety(I, J -  1 ) or
          UpdateVariety(I, J +  1 ) or
          UpdateVariety(I +  1 , J -  1 ) or
          UpdateVariety(I +  1 , J) or
          UpdateVariety(I +  1 , J +  1 ) then
            // всё точно!
            Exit;
      end;

  //точно ничего не ясно. Значить, берем с минимальной вероятностью. Метод тыка.
  LVar := MaxInt;
  RightButton := False;

  for I :=  0  to FFieldWidth * FFieldHeight -  1  do
    with FField[I] do
      if (Value = cDefault) and (VDiv <>  0 ) and (VMul / VDiv < LVar) then
        begin
          X := I mod FFieldWidth;
          Y := I div FFieldWidth;
          LVar := VMul / VDiv;
        end;
end;

var
  X, Y: Integer;
  R: Boolean;
begin
  InitSweeper;
  try
    repeat
      ShotSweeper;
      if GameFinished then
      begin
        Sleep(cStandardDelay);
        SkipSweeperGreetings;
        Sleep(cStandardDelay);
        StartSweeperGame;
      end
      else
      begin
        SweeperMove(X, Y, R);
        ClickSweeperCell(X, Y, R);
      end;
    until not IsWindow(FMainWindow);
  finally
    DoneSweeper;
  end;
end.