home *** CD-ROM | disk | FTP | other *** search
/ Piper's Pit BBS/FTP: ibm 0040 - 0049 / ibm0040-0049 / ibm0040.tar / ibm0040 / BCPPOWL1.ZIP / CHECKERS.ZIP / CHECKERS.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-28  |  12.4 KB  |  432 lines
  1. // ObjectWindows - (C) Copyright 1991 by Borland International
  2.  
  3. #include <static.h>
  4. #include <filedial.h>
  5. #include <inputdia.h>
  6. #include <bwcc.h>
  7.  
  8. #include "checkers.h"
  9. #include "info.h"
  10. #include "board.h"
  11.  
  12. const CAPTIONY = 40;
  13. #undef MAXPATH
  14. #define MAXPATH  160
  15.  
  16. // Must overload TDialog to handle IDYES and IDNO messages
  17. class TEndDialog : public TDialog
  18. {
  19.   public:
  20.    TEndDialog(PTWindowsObject AParent, LPSTR AName)
  21.       : TDialog(AParent, AName)
  22.       { }
  23.       
  24.    virtual void Yes(RTMessage) = [ID_FIRST+IDYES]
  25.    {
  26.       CloseWindow(IDYES);
  27.    }
  28.    virtual void No(RTMessage) = [ID_FIRST+IDNO]
  29.    {
  30.       ShutDownWindow();
  31.    }
  32. };
  33.  
  34. class TCheckers: public TApplication
  35. {
  36.   public:
  37.    TCheckers(LPSTR AName, HANDLE hInstance, HANDLE hPrevInstance,
  38.       LPSTR lpCmdLine, int nCmdShow) : TApplication(AName, hInstance,
  39.       hPrevInstance, lpCmdLine, nCmdShow)
  40.       {
  41.       }
  42.    virtual void InitMainWindow();
  43.    void InitInstance()
  44.    {
  45.       TApplication::InitInstance();
  46.       HAccTable = LoadAccelerators(hInstance, "CheckerCommands");
  47.       BWCCGetVersion();
  48.    }
  49. };
  50.  
  51.  
  52.  
  53. _CLASSDEF(TCheckersWindow)
  54. class TCheckersWindow : public TWindow
  55. {
  56.    PTInfoWindow TInfo;
  57.    PBOARD bd;
  58.    HCURSOR CursorHand, CursorPiece;
  59.    BOOL HoldingPiece;
  60.    SIDE WhoseTurn;
  61.    int MovingPieceType;
  62.    POINT MoveStartPoint, MoveEndPoint;
  63.    RECT MainWndRect;
  64.    BOOL NewGame;
  65.    char *FileName;
  66.    HMENU hMenu;
  67.   public :
  68.    TCheckersWindow(PTWindowsObject AParent, LPSTR ATitle) :
  69.       TWindow(AParent, ATitle)
  70.    {
  71.       TInfo = new TInfoWindow(this, "InfoWindow");
  72.       Attr.Style = WS_OVERLAPPED | WS_SYSMENU | WS_MINIMIZEBOX;
  73.       Attr.X = 5;
  74.       Attr.Y = 5;
  75.       Attr.H = (BORDERSIZE * 2) + (MAXBDSIZE * SQUARE_SIZE) + 6 + CAPTIONY;
  76.       Attr.W = Attr.H + INFOXSIZE - CAPTIONY - 6;
  77.       FileName = new char[MAXPATH];
  78.       bd = NULL;
  79.    }
  80.    ~TCheckersWindow()
  81.    {
  82.       if (bd)
  83.          delete bd;
  84.       delete FileName;
  85.       delete TInfo;
  86.    }
  87.    virtual void SetupWindow()
  88.    {
  89.       TWindow::SetupWindow();
  90.       CursorPiece = LoadCursor( GetApplication()->hInstance, "HandWPiece");
  91.       RedManBmp = LoadBitmap(GetApplication()->hInstance, "RedManBitmap");
  92.       BlackManBmp = LoadBitmap(GetApplication()->hInstance, "BlackManBitmap");
  93.       RedKingBmp = LoadBitmap(GetApplication()->hInstance, "RedKingBitmap");
  94.       BlackKingBmp = LoadBitmap(GetApplication()->hInstance, "BlackKingBitmap");
  95.       GetClientRect(HWindow, &MainWndRect);
  96.       hMenu = GetMenu(HWindow);
  97.       bd = new BOARD;
  98.       bd->SetInfoPtr(TInfo);
  99.       bd->SetupBoard();
  100.       WhoseTurn = Red;
  101.       HoldingPiece = FALSE;
  102.       TInfo->SetTurnText("Red");
  103.       NewGame = TRUE;
  104.    }
  105.    virtual void GetWindowClass(WNDCLASS& WndClass)
  106.    {
  107.       TWindow::GetWindowClass( WndClass );
  108.       CursorHand = LoadCursor( GetApplication()->hInstance, "Hand");
  109.       WndClass.hCursor = CursorHand;
  110.       WndClass.hbrBackground = GetStockObject(LTGRAY_BRUSH);
  111.       WndClass.lpszMenuName = "Checkers";
  112.       WndClass.hIcon = LoadIcon( GetApplication()->hInstance, "CheckersIcon");
  113.    }
  114.    virtual void Paint( HDC PaintDC, PAINTSTRUCT& PaintInfo );
  115.    virtual void WMLButtonDown( TMessage& Message ) = [ WM_FIRST + WM_LBUTTONDOWN ];
  116.    virtual void WMLButtonUp( TMessage& Message ) = [ WM_FIRST + WM_LBUTTONUP ];
  117.    virtual void CMNewGame(RTMessage Msg) = [CM_FIRST + CM_FILENEW];
  118.    virtual void CMRestoreGame(RTMessage Msg) = [CM_FIRST + CM_FILEOPEN];
  119.    virtual void CMSaveGame(RTMessage Msg) = [CM_FIRST + CM_FILESAVE];
  120.    virtual void CMSaveGameAs(RTMessage Msg) = [CM_FIRST + CM_FILESAVEAS];
  121.    virtual void UndoMove(RTMessage Msg) = [CM_FIRST + CM_UNDO];
  122.    virtual void RedoUndo(RTMessage Msg) = [CM_FIRST + CM_REDO];
  123.    virtual void SetSearchDepth(RTMessage Msg) = [CM_FIRST + CM_SEARCHDEPTH];
  124.    virtual void ToggleAutoPlay(RTMessage Msg) = [CM_FIRST + CM_AUTO];
  125.    virtual void ToggleIteration(RTMessage Msg) = [CM_FIRST + CM_ITERATE];
  126.    virtual void ToggleKillerTable(RTMessage Msg) = [CM_FIRST + CM_KILLER];
  127.    virtual void ComputersMove(RTMessage) = [CM_FIRST + CM_MOVE];
  128.    virtual void About(RTMessage Msg) = [CM_FIRST + CM_ABOUT];
  129.    virtual void Logging(RTMessage) = [CM_FIRST + CM_LOG];
  130.    virtual void Exit(RTMessage) = [CM_FIRST + CM_EXIT]
  131.       {
  132.       CloseWindow();
  133.       }
  134.    void SaveGameAs();
  135.    virtual BOOL CanClose()
  136.    {
  137.       if (WhoseTurn == Black)
  138.          return FALSE;
  139.       return TRUE;
  140.    }
  141. };
  142.  
  143. //->TWindow member functions<----------------------------------------
  144.  
  145. void TCheckers::InitMainWindow()
  146. {
  147.    MainWindow = new TCheckersWindow(NULL, "OWL Checkers");
  148. }
  149.  
  150.  
  151. //->TCheckersWindow member functions<--------------------------------
  152.  
  153. void TCheckersWindow::WMLButtonDown( TMessage& )
  154. {
  155.    POINT Point;
  156.    if (WhoseTurn == Black)
  157.       return;
  158.    GetCursorPos( &Point );
  159.    ScreenToClient(HWindow, &Point);
  160.  
  161.    MoveStartPoint = bd->GetValidSquare(Point, WhoseTurn);
  162.    if (MoveStartPoint.x)
  163.       {
  164.       MovingPieceType = bd->GetPieceType(MoveStartPoint);
  165.       HDC hDC = GetDC(HWindow);
  166.       SetClassWord( HWindow, GCW_HCURSOR, CursorPiece);
  167.       SetCursor(CursorPiece);
  168.       bd->ClearSquare(hDC, MoveStartPoint);
  169.       HoldingPiece = TRUE;
  170.       ReleaseDC(HWindow, hDC);
  171.       }
  172. }
  173.  
  174. void TCheckersWindow::WMLButtonUp( TMessage& )
  175. {
  176.    POINT Point;
  177.  
  178.    if (!HoldingPiece || WhoseTurn == Black)
  179.       return;
  180.  
  181.    GetCursorPos(&Point);
  182.    ScreenToClient(HWindow, &Point);
  183.    TInfo->SetMessageText("");
  184.    MoveEndPoint = bd->GetEmptySquare(Point);
  185.    HDC hDC = GetDC(HWindow);
  186.    SetClassWord( HWindow, GCW_HCURSOR, CursorHand);
  187.    SetCursor(CursorHand);
  188.    if (MoveEndPoint.x && bd->UserMove(MoveStartPoint, MoveEndPoint))
  189.       {
  190.       bd->RedrawBoard(hDC);
  191.       EnableMenuItem( hMenu, CM_UNDO, MF_BYCOMMAND | MF_ENABLED );
  192.       EnableMenuItem( hMenu, CM_REDO, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
  193.       if (!bd->AnotherJump())
  194.          {
  195.          if (bd->NoMoreBlack())
  196.             {
  197.          if (GetApplication()->ExecDialog(new TEndDialog(this, "UserWonDlg"))
  198.             == IDYES)
  199.                {
  200.                PostMessage(HWindow, WM_COMMAND, CM_FILENEW, 0L);
  201.                ReleaseDC(HWindow, hDC);
  202.                return;
  203.                }
  204.             else
  205.                {
  206.                PostMessage(HWindow, WM_COMMAND, CM_EXIT, 0L);
  207.                ReleaseDC(HWindow, hDC);
  208.                return;
  209.                }
  210.             }
  211.          PostMessage(HWindow, WM_COMMAND, CM_MOVE, 0L);
  212.          }
  213.       else
  214.          TInfo->SetMessageText("Another jump required");
  215.       }
  216.    else
  217.       {
  218.       TInfo->SetMessageText("Not a legal move!");
  219.       bd->DrawPiece(hDC, MovingPieceType, MoveStartPoint);
  220.       }
  221.    HoldingPiece = FALSE;
  222.    ReleaseDC(HWindow, hDC);
  223. }
  224.  
  225.  
  226.  
  227. void TCheckersWindow::Paint(HDC PaintDC, PAINTSTRUCT&)
  228. {
  229.    DrawFrame(PaintDC, MainWndRect);
  230.    bd->DrawCheckersFrame(PaintDC);
  231.    if (WhoseTurn == Black)  // computer is thinking
  232.       bd->DrawLastBoard(PaintDC);
  233.    else
  234.       bd->DrawBoard(PaintDC);
  235.    bd->DrawAlphaNum(PaintDC);
  236. }
  237.  
  238. void TCheckersWindow::ComputersMove(RTMessage)
  239. {
  240.    bd->EndUsersTime();
  241.    TInfo->SetMessageText("Thinking...");
  242.    HCURSOR hCurTemp;
  243.    SetClassWord(HWindow, GCW_HCURSOR,
  244.    hCurTemp = LoadCursor(0, IDC_WAIT));
  245.    SetCursor(hCurTemp);
  246.    WhoseTurn = Black;
  247.    TInfo->SetTurnText("Black");
  248.    EnableMenuItem(hMenu, 0, MF_BYPOSITION | MF_DISABLED | MF_GRAYED);
  249.    EnableMenuItem(hMenu, 1, MF_BYPOSITION | MF_DISABLED | MF_GRAYED);
  250.    EnableMenuItem(hMenu, 3, MF_BYPOSITION | MF_DISABLED | MF_GRAYED);
  251.    ModifyMenu( hMenu, CM_MOVE, MF_BYCOMMAND | MF_ENABLED |
  252.            MF_STRING, CM_STOP, "&Stop");
  253.    DrawMenuBar(HWindow);
  254.    bd->ComputersTurn();
  255.    HDC hDC = GetDC(HWindow);
  256.    bd->RedrawBoard(hDC);
  257.    ReleaseDC(HWindow, hDC);
  258.    WhoseTurn = Red;
  259.    TInfo->SetTurnText("Red");
  260.    SetClassWord( HWindow, GCW_HCURSOR, CursorHand);
  261.    POINT CursorPoint;
  262.    GetCursorPos(&CursorPoint);
  263.    ScreenToClient(HWindow, &CursorPoint);
  264. #pragma warn -stv
  265.    if (PtInRect(&MainWndRect, CursorPoint))
  266.       SetCursor( CursorHand );
  267. #pragma warn +stv
  268.    ModifyMenu( hMenu, CM_STOP, MF_BYCOMMAND | MF_ENABLED |
  269.            MF_STRING, CM_MOVE, "&Pass");
  270.    EnableMenuItem(hMenu, 0, MF_BYPOSITION | MF_ENABLED);
  271.    EnableMenuItem(hMenu, 1, MF_BYPOSITION | MF_ENABLED);
  272.    EnableMenuItem(hMenu, 3, MF_BYPOSITION | MF_ENABLED);
  273.    DrawMenuBar(HWindow);
  274.  
  275.    if (bd->NoMoreRed())
  276.       {
  277.    if (GetApplication()->ExecDialog(new TEndDialog(this, "GameWonDlg"))
  278.       == IDYES)
  279.           {
  280.           PostMessage(HWindow, WM_COMMAND, CM_FILENEW, 0L);
  281.           return;
  282.           }
  283.        else
  284.           {
  285.           PostMessage(HWindow, WM_COMMAND, CM_EXIT, 0L);
  286.           return;
  287.           }
  288.        }
  289.    TInfo->SetMessageText("");
  290.    bd->StartUsersTime();
  291. }
  292.  
  293. void TCheckersWindow::CMNewGame(RTMessage)
  294. {
  295.    TInfo->Reset();
  296.    bd->SetupBoard();
  297.    EnableMenuItem(hMenu, CM_UNDO, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
  298.    EnableMenuItem(hMenu, CM_REDO, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
  299.    HoldingPiece = FALSE;
  300.    TInfo->SetTurnText("Red");
  301.    WhoseTurn = Red;
  302.    NewGame = TRUE;
  303.    HDC hDC = GetDC(HWindow);
  304.    bd->DrawBoard(hDC);
  305.    ReleaseDC(HWindow, hDC);
  306. }
  307.  
  308. void TCheckersWindow::CMRestoreGame(RTMessage)
  309. {
  310.    if (GetApplication()->ExecDialog(new TFileDialog(this,
  311.       SD_FILEOPEN, strcpy(FileName, "*.CHK"))) == IDOK)
  312.       {
  313.       bd->LoadGame(FileName);
  314.       NewGame = FALSE;
  315.       EnableMenuItem(hMenu, CM_REDO, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
  316.       EnableMenuItem(hMenu, CM_UNDO, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
  317.       HDC hDC = GetDC(HWindow);
  318.       bd->DrawBoard(hDC);
  319.       ReleaseDC(HWindow, hDC);
  320.       }
  321. }
  322.  
  323. void TCheckersWindow::SaveGameAs()
  324. {
  325.    if (GetApplication()->ExecDialog(new TFileDialog(this,
  326.       SD_FILESAVE, strcpy(FileName, "*.CHK")))
  327.          == IDOK)
  328.       {
  329.       bd->SaveGame(FileName);
  330.       NewGame = FALSE;
  331.       }
  332. }
  333.  
  334. void TCheckersWindow::CMSaveGame(RTMessage)
  335. {
  336.    if (NewGame == TRUE)
  337.       SaveGameAs();
  338.    else
  339.       bd->SaveGame(FileName);
  340. }
  341.  
  342. void TCheckersWindow::CMSaveGameAs(RTMessage)
  343. {
  344.    SaveGameAs();
  345. }
  346.  
  347. void TCheckersWindow::UndoMove(RTMessage)
  348. {
  349.    EnableMenuItem(hMenu, CM_REDO, MF_BYCOMMAND | MF_ENABLED);
  350.    if (bd->UndoMove())
  351.       EnableMenuItem(hMenu, CM_UNDO, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
  352.    HDC hDC = GetDC(HWindow);
  353.    bd->RedrawBoard(hDC);
  354.    ReleaseDC(HWindow, hDC);
  355. }  
  356.  
  357. void TCheckersWindow::RedoUndo(RTMessage)
  358. {
  359.    EnableMenuItem(hMenu, CM_UNDO, MF_BYCOMMAND | MF_ENABLED);
  360.    if (bd->RedoMove())
  361.       EnableMenuItem(hMenu, CM_REDO, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
  362.    HDC hDC = GetDC(HWindow);
  363.    bd->RedrawBoard(hDC);
  364.    ReleaseDC(HWindow, hDC);
  365. }
  366.  
  367. void TCheckersWindow::SetSearchDepth(RTMessage)
  368. {
  369.  
  370.    char *SearchDepthText;
  371.  
  372.    SearchDepthText = new char[48];
  373.    strcpy(SearchDepthText, "3");
  374.    if (GetApplication()->ExecDialog(new TInputDialog(this, "Set Search Depth", "Enter new search depth:",
  375.       SearchDepthText, 47)) == IDOK)
  376.       {
  377.       int NewSearchDepth = atoi(SearchDepthText);
  378.       bd->SetSearchDepth(NewSearchDepth);
  379.       }
  380.    delete SearchDepthText;
  381. }
  382.  
  383. void TCheckersWindow::ToggleAutoPlay(RTMessage)
  384. {
  385.    // Left as an exersize
  386. }
  387.  
  388. void TCheckersWindow::ToggleIteration(RTMessage)
  389. {
  390.    if (GetMenuState(hMenu, CM_ITERATE, MF_BYCOMMAND) & MF_CHECKED)
  391.       CheckMenuItem(hMenu, CM_ITERATE, MF_UNCHECKED);
  392.    else
  393.       CheckMenuItem(hMenu, CM_ITERATE, MF_CHECKED);
  394.    bd->ToggleIter();
  395.    TInfo->IterReset();
  396. }
  397.  
  398.  
  399. void TCheckersWindow::ToggleKillerTable(RTMessage)
  400. {
  401.    if (GetMenuState(hMenu, CM_KILLER, MF_BYCOMMAND) & MF_CHECKED)
  402.       CheckMenuItem(hMenu, CM_KILLER, MF_UNCHECKED);
  403.    else
  404.       CheckMenuItem(hMenu, CM_KILLER, MF_CHECKED);
  405.    bd->ToggleKiller();
  406.    TInfo->IterReset();
  407. }
  408.  
  409. void TCheckersWindow::Logging(RTMessage)
  410. {
  411.    if (GetMenuState(hMenu, CM_LOG, MF_BYCOMMAND) & MF_CHECKED)
  412.       CheckMenuItem(hMenu, CM_LOG, MF_UNCHECKED);
  413.    else
  414.       CheckMenuItem(hMenu, CM_LOG, MF_CHECKED);
  415.    bd->ToggleLogging();
  416. }
  417.  
  418. void TCheckersWindow::About(RTMessage)
  419. {
  420.    GetApplication()->ExecDialog(new TDialog(this, "About"));
  421. }
  422.  
  423.  
  424. int PASCAL WinMain(HANDLE hInstance, HANDLE hPrevInstance, LPSTR lpCmdLine,
  425.    int nCmdShow)
  426. {
  427.    TCheckers CheckersApp("CheckersApp", hInstance, hPrevInstance, lpCmdLine,
  428.       nCmdShow);
  429.    CheckersApp.Run();
  430.    return CheckersApp.Status;
  431. }
  432.