开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 棋牌游戏 > 查看源码
Game.cpp
资源名称：毕业论文--五子棋.zip　[点击查看]
上传用户：fjjkzlh
上传日期：2010-04-06
资源大小：469k
文件大小：11k
源码类别：

棋牌游戏

开发平台：

Visual C++

Game.cpp：源码内容
  1. #include "StdAfx.h"
  2. #include "Table.h"
  3. #include "Game.h"
  4. #include "Messages.h"
  5. #include "Resource.h"
  7. //////////////////////////////////////////////////////////////////////////
  8. // CGame类的实现部分
  9. //////////////////////////////////////////////////////////////////////////
  10. CGame::~CGame()
  11. {
  12. }
  13. void CGame::Win( const STEP& stepSend )
  14. {
  15. }
  16. //////////////////////////////////////////////////////////////////////////
  17. // COneGame类的实现部分
  18. //////////////////////////////////////////////////////////////////////////
  19. COneGame::~COneGame()
  20. {
  21. }
  22. void COneGame::Init()
  23. {
  24.     // 设置网络连接状态
  25.     m_pTable->m_bConnected = FALSE;
  26.     // 设置敌人姓名
  27.     m_pTable->GetParent()->SetDlgItemText( IDC_ST_ENEMY, _T("计算机") );
  28.     // 计算获胜组合情况
  29.     int i, j, k, nCount = 0;
  30.     for ( i = 0; i < 15; i++ )
  31.     {
  32.         for ( j = 0; j < 15; j++ )
  33.         {
  34.             for ( k = 0; k < 572; k++ )
  35.             {
  36.                 m_Player[i][j][k] = false;
  37.                 m_Computer[i][j][k] = false;
  38.             }
  39.         }
  40.     }
  41.     for ( i = 0; i < 2; i++ )
  42.     {
  43.         for ( j = 0; j < 572; j++ )
  44.         {
  45.             m_Win[i][j] = 0;
  46.         }
  47.     }
  48.     for ( i = 0; i < 15; i++ )
  49.     {
  50.         for ( j = 0; j < 11; j++ )
  51.         {
  52.             for ( k = 0; k < 5; k++ )
  53.             {
  54.                 m_Player[j + k][i][nCount] = true;
  55.                 m_Computer[j + k][i][nCount] = true;
  56.             }
  57.             nCount++;
  58.         }
  59.     }
  60.     for ( i = 0; i < 15; i++ )
  61.     {
  62.         for ( j = 0; j < 11; j++ )
  63.         {
  64.             for ( k = 0; k < 5; k++ )
  65.             {
  66.                 m_Player[i][j + k][nCount] = true;
  67.                 m_Computer[i][j + k][nCount] = true;
  68.             }
  69.             nCount++;
  70.         }
  71.     }
  72.     for ( i = 0; i < 11; i++ )
  73.     {
  74.         for ( j = 0; j < 11; j++ )
  75.         {
  76.             for ( k = 0; k < 5; k++ )
  77.             {
  78.                 m_Player[j + k][i + k][nCount] = true;
  79.                 m_Computer[j + k][i + k][nCount] = true;
  80.             }
  81.             nCount++;
  82.         }
  83.     }
  84.     for ( i = 0; i < 11; i++ )
  85.     {
  86.         for ( j = 14; j >= 4; j-- )
  87.         {
  88.             for ( k = 0; k < 5; k++ )
  89.             {
  90.                 m_Player[j - k][i + k][nCount] = true;
  91.                 m_Computer[j - k][i + k][nCount] = true;
  92.             }
  93.             nCount++;
  94.         }
  95.     }
  96.     if ( 1 == m_pTable->GetColor() )
  97.     {
  98.         // 如果玩家后走，则手动控制电脑占据天元
  99.         m_pTable->SetData( 7, 7, 0 );
  100.         PlaySound( MAKEINTRESOURCE( IDR_WAVE_PUT ), NULL, SND_RESOURCE | SND_SYNC );
  101.         m_bStart = false;
  102.         for ( i = 0; i < 572; i++ )
  103.         {
  104.             // 保存先前数据，做悔棋之用
  105.             m_nOldWin[0][i] = m_Win[0][i];
  106.             m_nOldWin[1][i] = m_Win[1][i];
  107.             m_bOldPlayer[i] = m_Player[7][7][i];
  108.         }
  109.         for ( i = 0; i < 572; i++ )
  110.         {
  111.             // 修改计算机下子后，棋盘的变化状况
  112.             if ( m_Computer[7][7][i] && m_Win[1][i] != -1 )
  113.             {
  114.                 m_Win[1][i]++;
  115.             }
  116.             if ( m_Player[7][7][i] )
  117.             {
  118.                 m_Player[7][7][i] = false;
  119.                 m_Win[0][i] = -1;
  120.             }
  121.         }
  122.     }
  123.     else
  124.     {
  125.         m_bStart = true;
  126.     }
  127. }
  128. void COneGame::SendStep( const STEP& stepPut )
  129. {
  130.     int bestx, besty, i, j, pi, pj, ptemp, ctemp, pscore = 10, cscore = -10000;
  131.     int ctempTable[15][15], ptempTable[15][15];
  132.     int m, n, temp1[20], temp2[20]; // 暂存第一步搜索的信息
  134.     m_pTable->GetParent()->GetDlgItem( IDC_BTN_BACK )->EnableWindow( FALSE );
  135.     // 保存先前数据，做悔棋之用
  136.     for ( i = 0; i < 572; i++)
  137.     {
  138.         m_nOldWin[0][i] = m_Win[0][i];
  139.         m_nOldWin[1][i] = m_Win[1][i];
  140.         m_bOldPlayer[i] = m_Player[stepPut.x][stepPut.y][i];
  141.         m_bOldComputer[i] = m_Computer[stepPut.x][stepPut.y][i];
  142.     }
  143.     // 修改玩家下子后棋盘状态的变化
  144.     for ( i = 0; i < 572; i++ )
  145.     {
  146.         // 修改状态变化
  147.         if ( m_Player[stepPut.x][stepPut.y][i] && m_Win[0][i] != -1 )
  148.             m_Win[0][i]++;
  149.         if ( m_Computer[stepPut.x][stepPut.y][i] )
  150.         {
  151.             m_Computer[stepPut.x][stepPut.y][i] = false;
  152.             m_Win[1][i] = -1;
  153.         }
  154.     }
  155.     if ( m_bStart )
  156.     {
  157.         // 手动确定第一步：天元或(8, 8)
  158.         if ( -1 == m_pTable->m_data[7][7] )
  159.         {
  160.             bestx = 7;
  161.             besty = 7;
  162.         }
  163.         else
  164.         {
  165.             bestx = 8;
  166.             besty = 8;
  167.         }
  168.         m_bStart = false;
  169.     }
  170.     else
  171.     {
  172.         STEP step;
  173.         // 寻找最佳位置
  174.         GetTable( ctempTable, m_pTable->m_data );
  175.         while ( SearchBlank( i, j, ctempTable ) )
  176.         {
  177.             n = 0;
  178.             pscore = 10;
  179.             GetTable( ptempTable, m_pTable->m_data );
  180.             ctempTable[i][j] = 2; // 标记已被查找
  181.             step.color = 1 - m_pTable->GetColor();
  182.             step.x = i;
  183.             step.y = j;
  184.             // 给这个空位打分
  185.             ctemp = GiveScore( step );
  186.             for ( m = 0; m < 572; m++ )
  187.             {
  188.                 // 暂时更改玩家信息
  189.                 if ( m_Player[i][j][m] )
  190.                 {
  191.                     temp1[n] = m;
  192.                     m_Player[i][j][m] = false;
  193.                     temp2[n] = m_Win[0][m];
  194.                     m_Win[0][m] = -1;
  195.                     n++;
  196.                 }
  197.             }
  198.             ptempTable[i][j] = 0;
  199.             
  200.             pi = i;
  201.             pj = j;
  202.             while ( SearchBlank( i, j, ptempTable ) )
  203.             {
  204.                 
  205.                 ptempTable[i][j] = 2; // 标记已被查找
  206.                 step.color = m_pTable->GetColor();
  207.                 step.x = i;
  208.                 step.y = j;
  209.                 ptemp = GiveScore( step );
  210.                 if ( pscore > ptemp ) // 此时为玩家下子，运用极小极大法时应选取最小值
  211.                     pscore = ptemp;
  212.             }
  213.             for ( m = 0; m < n; m++ )
  214.             {
  215.                 // 恢复玩家信息
  216.                 m_Player[pi][pj][temp1[m]] = true;
  217.                 m_Win[0][temp1[m]] = temp2[m];
  218.             }
  219.             if ( ctemp + pscore > cscore ) // 此时为计算机下子，运用极小极大法时应选取最最大值
  220.             {
  221.                 cscore = ctemp + pscore;
  222.                 bestx = pi;
  223.                 besty = pj;
  224.             }
  225.         }
  226.     }
  227.     m_step.color = 1 - m_pTable->GetColor();
  228.     m_step.x = bestx;
  229.     m_step.y = besty;
  230.     for ( i = 0; i < 572; i++ )
  231.     {
  232.         // 修改计算机下子后，棋盘的变化状况
  233.         if ( m_Computer[bestx][besty][i] && m_Win[1][i] != -1 )
  234.             m_Win[1][i]++;
  235.         if ( m_Player[bestx][besty][i] )
  236.         {
  237.             m_Player[bestx][besty][i] = false;
  238.             m_Win[0][i] = -1;
  239.         }
  240.     }
  241.     m_pTable->GetParent()->GetDlgItem( IDC_BTN_BACK )->EnableWindow();
  242.     // 由于是单人游戏，所以直接接收数据
  243.     m_pTable->Receive();
  244. }
  245. void COneGame::ReceiveMsg( MSGSTRUCT *pMsg )
  246. {
  247.     pMsg->color = m_step.color;
  248.     pMsg->x = m_step.x;
  249.     pMsg->y = m_step.y;
  250.     pMsg->uMsg = MSG_PUTSTEP;
  251. }
  252. void COneGame::Back()
  253. {
  254.     int i;
  255.     // 单人游戏直接允许悔棋
  256.     STEP step;
  257.     // 悔第一步（电脑落子）
  258.     step = *( m_StepList.begin() );
  259.     m_StepList.pop_front();
  260.     m_pTable->m_data[step.x][step.y] = -1;
  261.     // 恢复原有胜负布局
  262.     for ( i = 0; i < 572; i++ )
  263.     {
  264.         m_Win[0][i] = m_nOldWin[0][i];
  265.         m_Win[1][i] = m_nOldWin[1][i];
  266.         m_Player[step.x][step.y][i] = m_bOldPlayer[i];
  267.     }
  268.     // 悔第二步（玩家落子）
  269.     step = *( m_StepList.begin() );
  270.     m_StepList.pop_front();
  271.     m_pTable->m_data[step.x][step.y] = -1;
  272.     // 恢复原有胜负布局
  273.     for ( i = 0; i < 572; i++ )
  274.     {
  275.         m_Computer[step.x][step.y][i] = m_bOldComputer[i];
  276.     }
  277.     m_pTable->Invalidate();
  278.     // 考虑到程序的负荷，这时候就不允许悔棋了
  279.     AfxGetMainWnd()->GetDlgItem( IDC_BTN_BACK )->EnableWindow( FALSE );
  280. }
  281. int COneGame::GiveScore( const STEP& stepPut )
  282. {
  283.     int i, nScore = 0;
  284.     for ( i = 0; i < 572; i++ )
  285.     {
  286.         if ( m_pTable->GetColor() == stepPut.color )
  287.         {
  288.             // 玩家下
  289.             if ( m_Player[stepPut.x][stepPut.y][i] )
  290.             {
  291.                 switch ( m_Win[0][i] )
  292.                 {
  293.                 case 1:
  294.                     nScore -= 5;
  295.                     break;
  296.                 case 2:
  297.                     nScore -= 50;
  298.                     break;
  299.                 case 3:
  300.                     nScore -= 500;
  301.                     break;
  302.                 case 4:
  303.                     nScore -= 5000;
  304.                     break;
  305.                 default:
  306.                     break;
  307.                 }
  308.             }
  309.         }
  310.         else
  311.         {
  312.             // 计算机下
  313.             if ( m_Computer[stepPut.x][stepPut.y][i] )
  314.             {
  315.                 switch ( m_Win[1][i] )
  316.                 {
  317.                 case 1:
  318.                     nScore += 5;
  319.                     break;
  320.                 case 2:
  321.                     nScore += 50;
  322.                     break;
  323.                 case 3:
  324.                     nScore += 100;
  325.                     break;
  326.                 case 4:
  327.                     nScore += 10000;
  328.                     break;
  329.                 default:
  330.                     break;
  331.                 }
  332.             }
  333.         }
  334.     }
  335.     return nScore;
  336. }
  337. void COneGame::GetTable( int tempTable[][15], int nowTable[][15] )
  338. {
  339.     int i, j;
  340.     for ( i = 0; i < 15; i++ )
  341.     {
  342.         for ( j = 0; j < 15; j++ )
  343.         {
  344.             tempTable[i][j] = nowTable[i][j];
  345.         }
  346.     }
  347. }
  348. bool COneGame::SearchBlank( int &i, int &j, int nowTable[][15] )
  349. {
  350.     int x, y;
  351.     for ( x = 0; x < 15; x++ )
  352.     {
  353.         for ( y = 0; y < 15; y++ )
  354.         {
  355.             if ( nowTable[x][y] == -1 && nowTable[x][y] != 2 )
  356.             {
  357.                 i = x;
  358.                 j = y;
  359.                 return true;
  360.             }
  361.         }
  362.     }
  363.     return false;
  364. }
  365. //////////////////////////////////////////////////////////////////////////
  366. // CTwoGame类的实现部分
  367. //////////////////////////////////////////////////////////////////////////
  368. CTwoGame::~CTwoGame()
  369. {
  370. }
  371. //////////////////////////////////////////////////////////////////////////
  372. void CTwoGame::Init()
  373. {
  374. }
  375. void CTwoGame::Win( const STEP& stepSend )
  376. {
  377.     SendStep( stepSend );
  378. }
  379. void CTwoGame::SendStep( const STEP& stepPut )
  380. {
  381.     MSGSTRUCT msg;
  382.     msg.uMsg = MSG_PUTSTEP;
  383.     msg.color = stepPut.color;
  384.     msg.x = stepPut.x;
  385.     msg.y = stepPut.y;
  387.     m_pTable->m_conn.Send( (LPCVOID)&msg, sizeof( MSGSTRUCT ) );
  388. }
  389. void CTwoGame::ReceiveMsg( MSGSTRUCT *pMsg )
  390. {
  391.     int nRet = m_pTable->m_conn.Receive( pMsg, sizeof( MSGSTRUCT ) );
  392.     if ( SOCKET_ERROR == nRet )
  393.     {
  394.         AfxGetMainWnd()->MessageBox( _T("接收数据时发生错误，请检查您的网络连接。"), _T("错误"), MB_ICONSTOP );
  395.     }
  396. }
  397. void CTwoGame::Back()
  398. {
  399.     CDialog *pDlg = (CDialog *)AfxGetMainWnd();
  400.     // 使按钮失效
  401.     pDlg->GetDlgItem( IDC_BTN_BACK )->EnableWindow( FALSE );
  402.     pDlg->GetDlgItem( IDC_BTN_HQ )->EnableWindow( FALSE );
  403.     pDlg->GetDlgItem( IDC_BTN_LOST )->EnableWindow( FALSE );
  404.     // 设置等待标志
  405.     m_pTable->SetWait( TRUE );
  407.     MSGSTRUCT msg;
  408.     msg.uMsg = MSG_BACK;
  410.     m_pTable->m_conn.Send( (LPCVOID)&msg, sizeof( MSGSTRUCT ) );
  411. }