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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
GAMEPROC.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：50k
源码类别：

Windows编程

开发平台：

Visual C++

GAMEPROC.C：源码内容
  1. /*==========================================================================
  2.  *
  3.  *  Copyright (C) 1995-1997 Microsoft Corporation. All Rights Reserved.
  4.  *
  5.  *  File:       gameproc.c
  6.  *  Content:    Game processing code
  7.  *
  8.  *
  9.  ***************************************************************************/
  10. #include "gameproc.h"
  11. #include "util.h"
  12. #include "gfx.h"
  13. #include "comm.h"
  14. #include "input.h"
  15. #include "lobby.h"
  16. #include "wizard.h"
  17. #include "dsound.h"
  18. #include "sfx.h"
  19. #include "stdio.h"
  21. /*
  22.  * Externals
  23.  */
  24. extern DWORD gdwKeys;
  25. extern LPDIRECTDRAWSURFACE glpShip0;
  26. extern LPDIRECTDRAWSURFACE glpShip1;
  27. extern LPDIRECTDRAWSURFACE glpShip2;
  28. extern LPDIRECTDRAWSURFACE glpShip3;
  29. extern BOOL gbShowFrameCount;
  30. extern LPDIRECTDRAWSURFACE glpNum;
  31. extern BOOL gbIsHost;
  32. extern BOOL gbIsActive;
  33. extern LPDPSESSIONDESC2 glpdpSD;
  34. extern HWND ghWndMain;
  35. extern HINSTANCE ghinst;
  36. extern BOOL                     gbReliable;
  38. /*
  39.  * Globals
  40.  */
  41. FRAG gFrags[64]; // ship framents
  42. BLOCKS gBlocks; // field layout
  43. LPVOID             glpvReceiveBuffer = NULL; // buffer to store received messages
  44. DWORD            gdwReceiveBufferSize = 0; // size of buffer
  45. DPID gOurID; // our player id
  46. BOOL gbHaveHostInit; // do we need to do host initializaton
  47. int gnProgramState; // current state of the game
  48. DWORD gdwFrameCount; // used for fps calc
  49. DWORD gdwFramesLast; // ..
  50. DWORD gdwFrameTime; // ..
  51. BOOL                            gbUpdate;                   // TRUE if player data needs to be updated
  52. BOOL                            gbNoField;                  // display blocks ?
  53. BOOL                            gbSessionLost;              // did we get disconnected ?
  54. HOSTMSG                         gHostMsg;                   // message buffer
  55. BLOCKHITMSG                     gBlockHitMsg;               // ..
  56. SHIPHITMSG                      gShipHitMsg;                // ..
  57. ADDBLOCKMSG                     gAddBlockMsg;               // ..
  58. CONTROLMSG                      gControlMsg;                // .. 
  59. SYNCMSG                         gSyncMsg;                   // ..
  60. TCHAR                           gDebugBuff[MAX_ERRORMSG];   // buffer for debug output
  62. /*
  63.  * Statics
  64.  */
  66. static double      gDirx[40] =
  67. {
  68.     0.000000,
  69.     0.156434,
  70.     0.309017,
  71.     0.453991,
  72.     0.587785,
  73.     0.707107,
  74.     0.809017,
  75.     0.891007,
  76.     0.951057,
  77.     0.987688,
  78.     1.000000,
  79.     0.987688,
  80.     0.951057,
  81.     0.891007,
  82.     0.809017,
  83.     0.707107,
  84.     0.587785,
  85.     0.453990,
  86.     0.309017,
  87.     0.156434,
  88.     0.000000,
  89.     -0.156435,
  90.     -0.309017,
  91.     -0.453991,
  92.     -0.587785,
  93.     -0.707107,
  94.     -0.809017,
  95.     -0.891007,
  96.     -0.951057,
  97.     -0.987688,
  98.     -1.000000,
  99.     -0.987688,
  100.     -0.951056,
  101.     -0.891006,
  102.     -0.809017,
  103.     -0.707107,
  104.     -0.587785,
  105.     -0.453990,
  106.     -0.309017,
  107.     -0.156434
  108. };
  110. static double      gDiry[40] =
  111. {
  112.     -1.000000,
  113.     -0.987688,
  114.     -0.951057,
  115.     -0.891007,
  116.     -0.809017,
  117.     -0.707107,
  118.     -0.587785,
  119.     -0.453990,
  120.     -0.309017,
  121.     -0.156434,
  122.     0.000000,
  123.     0.156434,
  124.     0.309017,
  125.     0.453991,
  126.     0.587785,
  127.     0.707107,
  128.     0.809017,
  129.     0.891007,
  130.     0.951057,
  131.     0.987688,
  132.     1.000000,
  133.     0.987688,
  134.     0.951057,
  135.     0.891006,
  136.     0.809017,
  137.     0.707107,
  138.     0.587785,
  139.     0.453990,
  140.     0.309017,
  141.     0.156434,
  142.     0.000000,
  143.     -0.156435,
  144.     -0.309017,
  145.     -0.453991,
  146.     -0.587785,
  147.     -0.707107,
  148.     -0.809017,
  149.     -0.891007,
  150.     -0.951057,
  151.     -0.987688
  152. };
  154. /*
  155.  * InitMessageBuffers
  156.  *
  157.  * Sets up buffes used for sending different types of messages
  158.  */
  159. void InitMessageBuffers(void)
  160. {
  161.     gHostMsg.byType        = MSG_HOST;
  162.     gBlockHitMsg.byType    = MSG_BLOCKHIT;
  163.     gShipHitMsg.byType     = MSG_SHIPHIT;    
  164.     gAddBlockMsg.byType    = MSG_ADDBLOCK;
  165.     gControlMsg.byType     = MSG_CONTROL; 
  166.     gSyncMsg.byType        = MSG_SYNC;
  167. }
  169. /*
  170.  * LaunchGame
  171.  *
  172.  * Sets up the game layout and launches
  173.  */
  174. void LaunchGame(void)
  175. {
  176. HRESULT hr;
  178. // initialize global message buffers
  179.     InitMessageBuffers();
  181. // update window title
  182. UpdateTitle();
  184. // get current session description (glpdpSD is initialized in here)
  185.     hr = DPlayGetSessionDesc();
  186.     if (FAILED(hr) || (!glpdpSD))
  187. {
  188.         ShowError(IDS_DPLAY_ERROR_GSD);
  189.         goto ABORT;
  190. }
  192. // initialize random number seed
  193. srand((int)GetTickCount());
  195. // clear front buffer before changing palette
  196. EraseScreen();
  197. FlipScreen();
  199.         // Begin collecting input
  200.         ReacquireInputDevices();
  202.     // initialize us
  203.    hr = InitOurShip();
  204.     if (FAILED(hr))
  205.     {
  206.         goto ABORT;
  207.     }
  209.     // get the field layout
  210. if( gbIsHost )
  211. {
  212.         // initialize field (done only by host)
  213.         if (!gbNoField)
  214.             InitField();
  216.         // we have host initialization
  217. gbHaveHostInit = TRUE;
  219.         // start updating screen
  220.         gbIsActive = TRUE;
  221. }
  222. else
  223. {
  224.         // get it from host, if we are joining
  225. gbHaveHostInit = FALSE;
  226. }
  228.     // success
  229.     return;
  231. ABORT:
  232.     // something went wrong, terminate game
  233.     ExitGame();
  234. }
  236. /*
  237.  * ExitGame
  238.  *
  239.  * Game termination code
  240.  */
  241. void ExitGame(void)
  242. {
  243.     // shut down app
  244. PostMessage( ghWndMain, WM_CLOSE, 0, 0 );
  245. }
  247. /*
  248.  * InitOurShip
  249.  *
  250.  * Initializes our ship's initial attributes
  251.  */
  252. HRESULT InitOurShip(void)
  253. {
  254.     int i;
  255.     SHIP ship;
  256.     HRESULT hr;
  258. // wipe out everything
  259. ZeroMemory(&ship, sizeof(ship));
  261. // initialize sound buffers, tell function that it's OUR ship
  262.     // so that it can use the global sound buffers instead of duplicating
  263.     // from them and wasting resources.
  264. InitPlayerLocalSoundData(&ship, TRUE);
  266. // calculate ship type based on the number of players in the game
  267.     // we cycle through four ships (Y,R,G,B) for now.
  269. ship.byType = (BYTE) ((glpdpSD->dwCurrentPlayers-1) % NUM_SHIP_TYPES);
  270.     ship.dPosX  = randInt(0,MAX_SHIP_X);
  271.     ship.dPosY  = randInt(0,MAX_SHIP_Y);
  272.     ship.cFrame = randInt(0, MAX_SHIP_FRAME);
  273. ship.bEnable = TRUE;
  275.     // set our local data
  276. hr = DPlaySetPlayerData(gOurID, &ship, sizeof(ship), DPSET_LOCAL);
  277.     if (FAILED(hr))
  278.     {
  279.         ShowError(IDS_DPLAY_ERROR_SPLD);
  280.         goto FAIL;
  281.     }
  283.     // no ship fragments
  284.     for(i=0; i<64; i++)
  285.         gFrags[i].valid = FALSE;
  287.     // success
  288.     return DP_OK;
  290. FAIL:
  291.     // failed
  292.     return hr;
  293. }
  295. /*
  296.  *FUNCTION:   InitPlayerLocalSoundData
  297.  *
  298.  *
  299.  *NOTES:      Takes a ship and initializes ONLY its soundbuffers and sound flags.
  300.  *            It leaves everything else alone.  Good for when going to
  301.  *            full-screen mode, when we need to get rid of the sound buffers
  302.  *            for a bit, but don't want to change the data.
  303.  */
  304. void InitPlayerLocalSoundData(LPSHIP lpShip, BOOL bOurShip)
  305. {
  306. int i;
  307.     if (gbSoundInitialized)
  308.     {
  309.         for (i=0; i<MAX_SOUNDS; i++)
  310.         {
  311.             if (FALSE == WaveGetBuffers(gSoundEffect[i],&lpShip->lpDirectSoundBuffer[i], &lpShip->lpDirectSound3DBuffer[i], bOurShip))
  312.             {//if it didn't work, get rid of all the other sound buffers
  313.              //the current ones have already been set NULL by the failed function.
  314.                 ShowError(IDS_DSOUND_DUPBUF);
  315.                 for (--i; i>=0; i--)
  316.                 {
  317.                     // if it's our ship then we don't want to release the regular
  318.                     // (non-3D) buffer because it's just a copy of a pointer to
  319.                     // the corresponding GLOBAL sound buffer.
  320.                     IDirectSoundBuffer_Release(lpShip->lpDirectSound3DBuffer[i]);
  321.                     if (!bOurShip)
  322.                     {
  323.                         IDirectSoundBuffer_Release(lpShip->lpDirectSoundBuffer  [i]);
  324.                     }
  325.                     lpShip->lpDirectSoundBuffer  [i] = NULL;
  326.                     lpShip->lpDirectSound3DBuffer[i] = NULL;
  327.                 }
  328.                 return;
  329.             }
  330.         }
  332.         lpShip->bFiring        = FALSE;
  333.         lpShip->bBounced       = FALSE;
  334.         lpShip->bDeath         = FALSE;
  335.         lpShip->bBlockHit      = FALSE;
  336.         lpShip->bEngineRunning = FALSE;
  337.         lpShip->bMoving        = FALSE;
  338.     }
  339.     else
  340.     {
  341.     //if sound initialization has already failed in InitSfx(), then we want the ships'
  342.     //sound buffers to be NULL so that we don't try to release them later.
  343.         for (i=0; i<MAX_SOUNDS; i++)
  344.         {
  345.             lpShip->lpDirectSoundBuffer  [i] = NULL;
  346.             lpShip->lpDirectSound3DBuffer[i] = NULL;
  347.         }
  348.     }
  349. };
  351. /*
  352.  *FUNCTION:   SetPlayerLocalSoundDataCB (CALLBACK)
  353.  *
  354.  *PURPOSE:    Initializes and registers a player's local SOUND data ONLY.
  355.  */
  356. BOOL WINAPI SetPlayerLocalSoundDataCB(DPID dpId, DWORD dwPlayerType, LPCDPNAME lpName, 
  357.                       DWORD dwFlags, LPVOID lpContext)
  358. {
  359. SHIP ship;
  360.     DWORD dwSize = sizeof(ship);
  361.     HRESULT hr;
  362.     BOOL bOurShip;
  364.     DPlayGetPlayerData(dpId, &ship, &dwSize, DPGET_LOCAL); 
  366. // no player data yet
  367. if (0 == dwSize)
  368. return TRUE;
  370.     //we need to know if it's our ship because we use the global sound buffers
  371.     //while all the other ships have to DUPLICATE their sound buffers from
  372.     //those global buffers.   
  373.     bOurShip = (dpId == gOurID);
  374.     InitPlayerLocalSoundData(&ship, bOurShip);
  376. hr = DPlaySetPlayerData(dpId, &ship, dwSize, DPSET_LOCAL);
  377.     return (DP_OK == hr);
  378. };
  380. /*
  381.  *FUNCTION:   InitLocalSoundData
  382.  *
  383.  *PURPOSE:    Initializes and registers all players' sound data ONLY
  384.  */
  385. HRESULT InitLocalSoundData(void)
  386. {
  387.     HRESULT hr;
  388. hr = DPlayEnumPlayers(&(glpdpSD->guidInstance), SetPlayerLocalSoundDataCB, NULL, 0);
  389.     return hr;
  390. }
  392. /*
  393.  *FUNCTION:   ReleaseLocalSoundData
  394.  *
  395.  *NOTES:      Releases a single ship's local sound buffers.
  396.  */
  397. void ReleasePlayerLocalSoundData(LPSHIP lpShip)
  398. {
  399. int i;
  401.     if (gbSoundInitialized)
  402.     {
  403.         for (i=0; i<MAX_SOUNDS; i++)
  404.         {
  405.             if (lpShip->lpDirectSoundBuffer[i] != NULL)
  406.             {
  407.                 IDirectSoundBuffer_Stop     (lpShip->lpDirectSoundBuffer[i]);
  408.                 //only release if it's not just a pointer copy from the global.
  409.                 if (lpShip->lpDirectSoundBuffer[i] != gSoundEffect[i]->lpDirectSoundBuffer)
  410.                 {
  411.                     //This ship's buffer is not identical to its global, we can release it.
  412.                     IDirectSoundBuffer_Release  (lpShip->lpDirectSoundBuffer[i]);
  413.                 }
  414.                 lpShip->lpDirectSoundBuffer[i] = NULL;
  415.             }
  417.             if (lpShip->lpDirectSound3DBuffer[i] != NULL)
  418.             {
  419.                 IDirectSound3DBuffer_Release(lpShip->lpDirectSound3DBuffer[i]);
  420.                 lpShip->lpDirectSound3DBuffer[i] = NULL;
  421.             }
  422.         }
  423.     }
  424. };
  426. /*
  427.  *FUNCTION:   ReleasePlayerLocalData  (CALLBACK)
  428.  *
  429.  *PURPOSE:    Retrieves and releases a player's local data from dplay.
  430.  */
  431. BOOL WINAPI ReleasePlayerLocalDataCB(DPID dpId, DWORD dwPlayerType, LPCDPNAME lpName,
  432.                  DWORD dwFlags, LPVOID lpContext)
  433. {
  434. SHIP ship;
  435.     DWORD dwSize = sizeof(SHIP);    
  436.     HRESULT hr;
  438.     hr = DPlayGetPlayerData(dpId, &ship, &dwSize, DPGET_LOCAL);
  439.     if (FAILED(hr))
  440.     {
  441.         wsprintf(gDebugBuff, TEXT("Get Player local data failed for id %dn"), dpId);
  442.         DEBUG_OUT(gDebugBuff);
  443.         goto FAIL;
  444.     }
  446. // no player data yet
  447. if (0 == dwSize)
  448. return TRUE;
  450.     ReleasePlayerLocalSoundData(&ship);
  452.     hr = DPlaySetPlayerData(dpId, &ship,  dwSize, DPSET_LOCAL);
  453.     if (FAILED(hr))
  454.     {
  455.         wsprintf(gDebugBuff, TEXT("Set Player local data failed for id %dn"), dpId);
  456.         DEBUG_OUT(gDebugBuff);
  457.         goto FAIL;
  458.     }
  460.     // success
  461. return TRUE;
  462. FAIL:
  463.     // we failed
  464.     return FALSE;
  465. }
  467. /*
  468.  *FUNCTION:   ReleaseLocalData
  469.  *
  470.  *PURPOSE:    Releases local data of ALL players.
  471.  */
  472. void ReleaseLocalData(void)
  473. {
  474.      HRESULT hr;
  476.      if (gnProgramState == PS_ACTIVE)
  477.      {
  478.          hr = DPlayEnumPlayers(&(glpdpSD->guidInstance), ReleasePlayerLocalDataCB, NULL, 0);
  479.          if (FAILED(hr))
  480.          {
  481.              ShowError(IDS_DPLAY_ERROR_EP);
  482.          }
  483.      }
  484. };
  486. /*
  487.  * ProcessUserInput
  488.  *
  489.  * Processes any input from the user and updates our ship state
  490.  */
  491. void ProcessUserInput(LPSHIP lpShip)
  492. {
  493.     static dwOldKeys = 0;
  495.     gbUpdate = FALSE;
  497.     // DSOUND: check if the engine was turned off
  498.     if (!(gdwKeys    & (KEY_DOWN | KEY_UP)) && 
  499. (dwOldKeys & (KEY_DOWN | KEY_UP)))
  500.     {
  501.         gdwKeys |= KEY_ENGINEOFF;
  503.         gControlMsg.byState = (BYTE) gdwKeys;
  504.         // let everyone know that we just turned our engine off
  505.         SendGameMessage((LPGENERICMSG) &gControlMsg, DPID_ALLPLAYERS);
  506.     }
  508.     // update our ship state
  509.     UpdateState(lpShip, gdwKeys);
  511.     // remember current keys for next frame
  512.     dwOldKeys = gdwKeys;
  513. }
  515. /*
  516.  * UpdateState
  517.  *
  518.  * Updates the current state of our ship, given user input
  519.  */
  520. void UpdateState(LPSHIP lpShip, DWORD dwControls)
  521. {
  522.     lpShip->dwKeys = dwControls;
  524.     if( dwControls & KEY_LEFT )
  525.     {
  526.         gbUpdate = TRUE;
  527.         lpShip->cFrame -= 1;
  528. if( lpShip->cFrame < 0 )
  529. lpShip->cFrame += MAX_SHIP_FRAME;
  530.     }
  531.     if( dwControls & KEY_RIGHT )
  532.     {
  533.         gbUpdate = TRUE;
  534.         lpShip->cFrame += 1;
  535. if( lpShip->cFrame >= MAX_SHIP_FRAME )
  536. lpShip->cFrame -= MAX_SHIP_FRAME;
  537.     }
  538.     if( dwControls & KEY_UP )
  539.     {
  540.         gbUpdate = TRUE;
  541.         lpShip->dVelX += gDirx[lpShip->cFrame] * 10.0 / 1000.0;
  542.         lpShip->dVelY += gDiry[lpShip->cFrame] * 10.0 / 1000.0;
  543.     }
  544.     if( dwControls & KEY_DOWN )
  545.     {
  546.         gbUpdate = TRUE;
  547.         lpShip->dVelX -= gDirx[lpShip->cFrame] * 10.0 / 1000.0;
  548.         lpShip->dVelY -= gDiry[lpShip->cFrame] * 10.0 / 1000.0;
  549.     }
  550.     if( dwControls & KEY_STOP )
  551.     {
  552.         gbUpdate = TRUE;
  553.         lpShip->dVelX = 0.0;
  554.         lpShip->dVelY = 0.0;
  555.     }
  556.     if( !lpShip->bBulletEnable && lpShip->bEnable )
  557.     {
  558. if( dwControls & KEY_FIRE )
  559. {
  560.             gbUpdate = TRUE;
  561. // launch a new bullet
  562. lpShip->dBulletPosX = (WORD) (gDirx[lpShip->cFrame]*6.0 + 16.0 + lpShip->dPosX);
  563. lpShip->dBulletPosY = (WORD) (gDiry[lpShip->cFrame]*6.0 + 16.0 + lpShip->dPosY);
  564. lpShip->dBulletVelX = gDirx[lpShip->cFrame]*500.0/1000.0;
  565. lpShip->dBulletVelY = gDiry[lpShip->cFrame]*500.0/1000.0;
  566. lpShip->bBulletEnable = TRUE;
  567. lpShip->dwBulletFrame = 0;
  568. }
  569.     }
  570. }
  572. /*
  573.  * SendSync
  574.  *
  575.  * Sends a sync message with the rendevous position. We are using a synchronization technique in
  576.  * which every player informs everyone else where the player is going to be at the end of the 
  577.  * next sync interval. Based on this rendezvous position, everyone tries to move their corresponding
  578.  * ghosts to the rendezvous position by the end of the interval.
  579.  */
  580. void SendSync(LPSHIP lpShip)
  581. {
  582. gSyncMsg.byShipType = lpShip->byType;
  583.     gSyncMsg.cFrame = lpShip->cFrame;
  584.     gSyncMsg.dPosX  = lpShip->dPosX + lpShip->dVelX*1000;
  585.     gSyncMsg.dPosY  = lpShip->dPosY + lpShip->dVelY*1000;
  587.     SendGameMessage((LPGENERICMSG) &gSyncMsg, DPID_ALLPLAYERS);
  588. }
  590. /*
  591.  * UpdateDisplayStatus
  592.  *
  593.  * Updates the disable timeout. Enables the ship if disable timeout has elapsed.
  594.  */
  595. void UpdateDisplayStatus(LPSHIP lpShip)
  596. {
  597.     DWORD dwTickDiff;
  598.     DWORD dwTickCount;
  600.     // current time
  601.     dwTickCount = timeGetTime();
  603.     // time elapsed since last update
  604.     dwTickDiff =  dwTickCount - lpShip->dwLastTick;
  606.     // timestamp
  607.     lpShip->dwLastTick = dwTickCount;
  609.     // update time-out
  610.     lpShip->iCountDown -= dwTickDiff;
  612.     // time-out ?
  613. if( lpShip->iCountDown < 0 )
  614. {
  615.         // get new position and enable our lpShip
  616.     lpShip->dPosX = randInt(0,MAX_SHIP_X);
  617.     lpShip->dPosY = randInt(0,MAX_SHIP_Y);
  618.     lpShip->cFrame = randInt(0, MAX_SHIP_FRAME);
  619. lpShip->bEnable = TRUE;
  620. }
  621. }
  623. /*
  624.  * UpdatePosition
  625.  *
  626.  * Updates our ship's position
  627.  */
  628. void UpdatePosition(DPID dpId, LPSHIP lpShip )
  629. {
  630.     int     x,y;
  631.     BYTE    oldxCell, oldyCell, newxCell, newyCell, mask, col, row;
  632.     double  thisTick, totalTick, xtick, ytick;
  633.     DWORD   dwTickCount;
  634.     DWORD   dwTickDiff;
  636.     if( !lpShip->bEnable )
  637.         return;
  639.     // how long has it been since we last updated
  640.     dwTickCount = timeGetTime();
  641.     dwTickDiff = dwTickCount - lpShip->dwLastTick;
  643.     // current timestamp
  644.     lpShip->dwLastTick = dwTickCount;
  646. oldxCell = (int)(lpShip->dPosX+16.0) >> 4;
  647. oldyCell = (int)(lpShip->dPosY+16.0) >> 4;
  649.     // compute new position
  650.     lpShip->dPosX += lpShip->dVelX * dwTickDiff;
  651.     lpShip->dPosY += lpShip->dVelY * dwTickDiff;
  653. newxCell = (int)(lpShip->dPosX+16.0) >> 4;
  654. newyCell = (int)(lpShip->dPosY+16.0) >> 4;
  655. if(oldxCell != newxCell)
  656. {
  657.         // we allow ghosts to pass through the blocks
  658. if( (dpId == gOurID) && IsHit( newxCell, newyCell ) )
  659. {
  660. if( lpShip->dVelX > 0.0 )
  661. lpShip->dPosX = (oldxCell << 4) + 15 - 16;
  662. else
  663. lpShip->dPosX = (oldxCell << 4) - 16;
  664. lpShip->dVelX = -lpShip->dVelX*0.9;
  665. newxCell = oldxCell;
  666.             lpShip->bBounced = TRUE;
  667. }
  668. }
  669. if(oldyCell != newyCell)
  670. {
  671.         // we allow ghosts to pass through the blocks
  672. if( (dpId == gOurID) && IsHit( newxCell, newyCell ) )
  673. {
  674. if( lpShip->dVelY > 0.0 )
  675. lpShip->dPosY = (oldyCell << 4) + 15 - 16;
  676. else
  677. lpShip->dPosY = (oldyCell << 4) - 16;
  679.             lpShip->dVelY = -lpShip->dVelY*0.9;
  680.             lpShip->bBounced = TRUE;
  681.     }
  682. }
  684.     if( lpShip->dPosX > MAX_SHIP_X )
  685.     {
  686.         lpShip->dPosX = MAX_SHIP_X;
  687.         lpShip->dVelX = -lpShip->dVelX*0.9;
  688.         lpShip->bBounced = TRUE;
  689.     }
  690.     else if ( lpShip->dPosX < 0 )
  691.     {
  692.         lpShip->dPosX =0;
  693.         lpShip->dVelX = -lpShip->dVelX*0.9;
  694.         lpShip->bBounced = TRUE;
  695.     }
  696.     if( lpShip->dPosY > MAX_SHIP_Y )
  697.     {
  698.         lpShip->dPosY = MAX_SHIP_Y;
  699.         lpShip->dVelY = -lpShip->dVelY*0.9;
  700.         lpShip->bBounced = TRUE;
  701.     }
  702.     else if ( lpShip->dPosY < 0 )
  703.     {
  704.         lpShip->dPosY =0;
  705.         lpShip->dVelY = -lpShip->dVelY*0.9;
  706.         lpShip->bBounced = TRUE;
  707.     }    
  709.     if ((dpId == gOurID) && lpShip->bBounced)
  710.     {
  711.         SendSync(lpShip);
  712.     }
  714.     if( !lpShip->bBulletEnable )
  715.         return;
  717.     // update the active bullet
  718.     lpShip->dwBulletFrame += dwTickDiff;
  719.     if( lpShip->dwBulletFrame >= MAX_BULLET_FRAME )
  720.     {
  721.         lpShip->bFiring = FALSE;
  722.         lpShip->bBulletEnable = FALSE;
  723. return;
  724.     }
  727.     if( lpShip->dBulletVelX != 0.0 )
  728. xtick = 8.0/lpShip->dBulletVelX;
  729.     else
  730.         xtick = 999999.0;
  732.     if( lpShip->dBulletVelY != 0.0 )
  733. ytick = 8.0/lpShip->dBulletVelY;
  734.     else
  735.         ytick = 999999.0;
  737.     if( xtick < 0.0 )
  738.         xtick = -xtick;
  739.     if( ytick < 0.0 )
  740.         ytick = -ytick;
  742.     if( xtick < ytick )
  743.         thisTick = xtick;
  744.     else
  745.         thisTick = ytick;
  747.     if( thisTick > dwTickDiff )
  748.         thisTick = dwTickDiff;
  749.         
  750.     for( totalTick = 0.0; totalTick < dwTickDiff; )
  751.     {
  752.         totalTick += thisTick;
  754.         lpShip->dBulletPosX += lpShip->dBulletVelX * thisTick;
  755.         lpShip->dBulletPosY += lpShip->dBulletVelY * thisTick;
  757.         if( lpShip->dBulletPosX > MAX_BULLET_X )
  758.         {
  759.             lpShip->dBulletPosX = MAX_BULLET_X;
  760.             lpShip->dBulletVelX = -lpShip->dBulletVelX*0.9;
  761.         }
  762.         else if ( lpShip->dBulletPosX < 0 )
  763.         {
  764.             lpShip->dBulletPosX =0;
  765.             lpShip->dBulletVelX = -lpShip->dBulletVelX*0.9;
  766.         }
  767.         if( lpShip->dBulletPosY > MAX_BULLET_Y )
  768.         {
  769.             lpShip->dBulletPosY = MAX_BULLET_Y;
  770.             lpShip->dBulletVelY = -lpShip->dBulletVelY*0.9;
  771.         }
  772.         else if ( lpShip->dBulletPosY < 0 )
  773.         {
  774.             lpShip->dBulletPosY =0;
  775.             lpShip->dBulletVelY = -lpShip->dBulletVelY*0.9;
  776.         }
  777.     
  778.         // check to see if it hit anything
  779.         x = (int)(lpShip->dBulletPosX + 0.5) + 1;
  780.         y = (int)(lpShip->dBulletPosY + 0.5) + 1;
  782.         row = y >> 4;
  783.         col = x >> 4;
  784.         mask = 1 << (col & 0x7);
  785.         col = col >> 3;
  786.         if( gBlocks.bits[row][col] & mask )
  787.         {
  788. // dwScored a block hit
  789.             gBlockHitMsg.byRow = row;
  790.             gBlockHitMsg.byCol = col;
  791.             gBlockHitMsg.byMask = mask;
  792. SendGameMessage((LPGENERICMSG) &gBlockHitMsg, DPID_ALLPLAYERS);
  794. gBlocks.bits[row][col] &= ~mask;
  795. lpShip->dwScore += 10;
  796. lpShip->bBulletEnable = FALSE;
  797.             lpShip->bBlockHit = TRUE;
  798.             lpShip->bFiring   = FALSE;
  799.         }
  800.     }
  801. }
  804. /*
  805.  * IsHit
  806.  *
  807.  * Tells if there is a block at (x,y) location
  808.  */
  809. BOOL IsHit( int x, int y )
  810. {
  811.     int col, mask;
  812.     
  813.     // outside screen boundaries?
  814.     if( (x < 0) || (y < 0) || (x >= 40) || (y >= 30) )
  815.         return TRUE;
  817.     // look at the block bits
  818.     mask = 1 << (x & 0x7);
  819.     col = x >> 3;
  820.     if( gBlocks.bits[y][col] & mask )
  821.         return TRUE;
  822.     else
  823.         return FALSE;
  824. }
  826. /*
  827.  * InitField
  828.  *
  829.  * Initializes block positions on the field
  830.  */
  831. void InitField(void)
  832. {
  833.     int i, x, y;
  834.     
  835.     // clear all gBlocks
  836.     for(x=0; x<5; x++)
  837.         for(y=0; y<30; y++)
  838.     gBlocks.bits[y][x] = 0;
  840.     // set random gBlocks
  841.     for(i=0; i<400; i++)
  842.     {
  843.         x = randInt(0, 40);
  844. y = randInt(0, 30);
  845. if( !setBlock(x, y) ) i--;
  846.     }
  847. }
  849. /*
  850.  * AddBlock
  851.  *
  852.  * Adds a block to the field
  853.  */
  854. void AddBlock(void)
  855. {
  856. int x,y;
  858.     // maybe add a block?
  859. if(gbIsHost && gbIsActive && ( randInt( 0, 100 ) > 98 ))
  860. {
  861. x = randInt( 0, 40);
  862. y = randInt( 0, 30);
  863. if( setBlock( x, y) )
  864. {
  865.             gAddBlockMsg.byX    = (BYTE) x;
  866.             gAddBlockMsg.byY    = (BYTE) y;
  867. SendGameMessage((LPGENERICMSG) &gAddBlockMsg, DPID_ALLPLAYERS);
  868. }
  869. }
  870. }
  872. /*
  873.  * setBlock
  874.  *
  875.  * Turns on a block
  876.  */
  877. BOOL setBlock( int x, int y )
  878. {
  879.     BYTE  mask, col;
  881.     mask = 1 << (x & 0x7);
  882.     col = x >> 3;
  883.     
  884.     // is Block already set?
  885.     if( gBlocks.bits[y][col] & mask )
  886.         return FALSE;
  888.     // set the block and return success
  889.     gBlocks.bits[y][col] |= mask;
  890.     return TRUE;
  891. }
  893. /*
  894.  * AddFrag
  895.  *
  896.  * Turns on a fragment
  897.  */
  898. void AddFrag(LPSHIP lpShip, int offX, int offY)
  899. {
  900.     int i;
  901.     for(i=0; i<64; i++) // find available fragment
  902.     {
  903.         if( !gFrags[i].valid )
  904.     break;
  905.     }
  906.     if( i == 64 )
  907.         return;
  909.     
  910.     gFrags[i].dPosX = offX + lpShip->dPosX;
  911.     gFrags[i].dPosY = offY + lpShip->dPosY;
  912.     switch( lpShip->byType )
  913.     {
  914.     case 0: gFrags[i].surf = glpShip0;    break;
  915.     case 1: gFrags[i].surf = glpShip1;    break;
  916.     case 2: gFrags[i].surf = glpShip2;    break;
  917.     case 3: gFrags[i].surf = glpShip3;    break;
  918. default: DEBUG_OUT(TEXT("Unknown ship typen")); return;
  919.     }
  920.     gFrags[i].src.top = 32 * ( (int)lpShip->cFrame / 10 ) + offX;
  921.     gFrags[i].src.left = 32 * ( (int)lpShip->cFrame % 10 ) + offY;
  922.     gFrags[i].src.right = gFrags[i].src.left + 8;
  923.     gFrags[i].src.bottom = gFrags[i].src.top + 8;
  924.     gFrags[i].dVelX = ((double)offX - 12.0)/24.0;
  925.     gFrags[i].dVelY = ((double)offY - 12.0)/24.0;
  926.     gFrags[i].valid = TRUE;
  927. }
  929. /*
  930.  * UpdateFragment
  931.  *
  932.  * Updates the position of a fragment
  933.  */
  934. void UpdateFragment(int i)
  935. {
  936.     DWORD   dwTickCount;
  937.     static DWORD   dwTickDiff;
  938.     static DWORD dwLastTick;
  940.     if( i == 0)
  941.     {
  942.         dwTickCount = timeGetTime();
  943.         dwTickDiff = dwTickCount - dwLastTick;
  944.         dwLastTick = dwTickCount;
  945.     }
  946.     
  947.     if( !gFrags[i].valid )
  948.         return;
  950.     gFrags[i].dPosX += (int) (gFrags[i].dVelX * dwTickDiff);
  951.     gFrags[i].dPosY += (int) (gFrags[i].dVelY * dwTickDiff);
  952.     if( (gFrags[i].dPosX < 0.0) || (gFrags[i].dPosX >= 632.0) ||
  953.         (gFrags[i].dPosY < 0.0) || (gFrags[i].dPosY >= 472.0) )
  954.     {
  955.         gFrags[i].valid = FALSE;
  956.     }
  957. }
  959. /*
  960.  * DestroyShip
  961.  *
  962.  * Renders a bunch of fragments to show that the ship is destroyed
  963.  */
  964. void DestroyShip( LPSHIP lpShip )
  965. {
  966. // Set flag for explosion sound
  967. lpShip->bDeath  = TRUE;
  969.     // add ship fragments
  970.     AddFrag(lpShip, 0, 0);
  971.     AddFrag(lpShip, 8, 0);
  972.     AddFrag(lpShip, 16, 0);
  973.     AddFrag(lpShip, 24, 0);
  974.     AddFrag(lpShip, 0, 8);
  975.     AddFrag(lpShip, 8, 8);
  976.     AddFrag(lpShip, 16, 8);
  977.     AddFrag(lpShip, 24, 8);
  978.     AddFrag(lpShip, 0, 16);
  979.     AddFrag(lpShip, 8, 16);
  980.     AddFrag(lpShip, 16, 16);
  981.     AddFrag(lpShip, 24, 16);
  982.     AddFrag(lpShip, 0, 24);
  983.     AddFrag(lpShip, 8, 24);
  984.     AddFrag(lpShip, 16, 24);
  985.     AddFrag(lpShip, 24, 24);
  987.     // Play explosion sound
  988.     ProcessSoundFlags(lpShip);
  989. }
  991. /*
  992.  * UpdateFrame
  993.  *
  994.  * Refreshes the screen
  995.  */
  996. BOOL UpdateFrame( void )
  997. {
  998.     int i;
  999.     DWORD dwTickCount;
  1000.     SHIP  ship;
  1001.     DWORD dwSize;
  1002.     HRESULT hr;
  1003.     static dwSyncLastTick = 0;
  1004.     static dwUpdateLastTick = 0;
  1005.     
  1006.     switch( gnProgramState )
  1007.     {
  1008.     case PS_ACTIVE:
  1009.         // DINPUT: use DirectInput to read game-play keys
  1010.     DI_ReadKeys();
  1012.         // get our local data
  1013.         dwSize = sizeof(ship);
  1014.         hr = DPlayGetPlayerData(gOurID, &ship, &dwSize, DPGET_LOCAL);
  1015.         if (FAILED(hr))
  1016.         {
  1017.             wsprintf(gDebugBuff, TEXT("Get Player local data failed for id %dn"), gOurID);
  1018.             DEBUG_OUT(gDebugBuff);
  1019.             goto FAIL;
  1020.         }
  1022.         if (!ship.bEnable)
  1023.         {
  1024.             // update disable timeout and display status
  1025.             UpdateDisplayStatus(&ship);
  1026.         }
  1027.         else
  1028.         {
  1029.             // process any change in game controls 
  1030.             ProcessUserInput(&ship);
  1032.             dwTickCount = timeGetTime();
  1034.             // synchronize if it's time
  1035.             if (gbIsActive && ((dwTickCount - dwSyncLastTick) > SYNC_INTERVAL))
  1036.             {
  1037.                 SendSync(&ship);
  1038.                 dwSyncLastTick = dwTickCount;
  1039.             }
  1041.             // if our player changed any keys, let everyone know
  1042.             if (gbUpdate)
  1043.             {
  1044.                 // control the number of packets we send
  1045.                 if ((dwTickCount - dwUpdateLastTick) > UPDATE_INTERVAL)
  1046.                 {
  1047.              // let others know
  1048.                     gControlMsg.byState = (BYTE) gdwKeys;
  1049.                     SendGameMessage((LPGENERICMSG) &gControlMsg, DPID_ALLPLAYERS);
  1050.                     dwUpdateLastTick = dwTickCount;
  1051.                 }
  1052.             }
  1053.         }
  1055.     // save ship data as RenderPlayerCB reads stored data
  1056.     hr = DPlaySetPlayerData(gOurID, &ship, sizeof(ship), DPSET_LOCAL);
  1057.         if (FAILED(hr))
  1058.         {
  1059.             ShowError(IDS_DPLAY_ERROR_SPLD);
  1060.             goto FAIL;
  1061.         }   
  1063. // update fragments
  1064. for(i=0; i<64; i++)
  1065. UpdateFragment(i);
  1067.      // add a block
  1068.         if (!gbNoField)
  1069.          AddBlock();
  1071.         // render everything
  1072.         if (!DrawScreen())
  1073.         {
  1074.             goto FAIL;
  1075.         }
  1076.         break;
  1078.     case PS_REST:
  1079. if( gbHaveHostInit )
  1080. {
  1081. SetGamePalette();
  1082. gnProgramState = PS_ACTIVE;
  1083. }
  1084. break;
  1085.     }
  1087.     // success
  1088.     return TRUE;
  1090. FAIL:
  1091.     // failed
  1092.     return FALSE;
  1093. }
  1095. /*
  1096.  *FUNCTION:   ProcessSoundFlags
  1097.  *
  1098.  *PARAMETERS:
  1099.  *    lpShip: Points to a ship structure (originally retrieved from
  1100.  *            GetPlayerData) in RenderPlayer.
  1101.  *
  1102.  *NOTES:      All y-coordinates must be made negative, because the
  1103.  *            3D Sound API's use an opposite coordinate system than
  1104.  *            the screen.
  1105.  */
  1106. void ProcessSoundFlags(LPSHIP lpShip)
  1107. {
  1108.     int i;
  1109.     BOOL bStart[MAX_SOUNDS]; //flags, used so we can 
  1110.     BOOL bStop [MAX_SOUNDS];
  1112.     if (!gbSoundInitialized)
  1113. {
  1114. // clear bounce flag so we don't send a message every time through the loop
  1115.         lpShip->bBounced = FALSE;
  1116.         return;
  1117. }
  1119.     //if one is NULL, so are the other ones and we aren't initialized yet.
  1120.     for (i=0; i<MAX_SOUNDS; i++)
  1121.     {
  1122.         if (lpShip->lpDirectSoundBuffer[i]==NULL)
  1123.             return;
  1124.     }
  1126.     //set all our temporary flags to FALSE.
  1127.     for (i=0; i<MAX_SOUNDS; i++)
  1128.     {
  1129.         bStart[i] = FALSE;
  1130.         bStop[i]  = FALSE;
  1131.     }
  1133.     if (lpShip->dwKeys & KEY_ENGINEOFF)
  1134.         {
  1135.         bStop[SENGINE] = TRUE;
  1136.         lpShip->bEngineRunning = FALSE;
  1137.         }
  1139.     if (lpShip->dwKeys & (KEY_UP | KEY_DOWN))
  1140.         {
  1141.         if (!lpShip->bEngineRunning) //turn on engine
  1142.             {
  1143.             bStart[SENGINE] = TRUE;
  1144.             if (!lpShip->bMoving)   //"fire-up-engine" sound
  1145.                 {
  1146.                 bStart[SSTART] = TRUE;
  1147.                 IDirectSound3DBuffer_SetPosition(lpShip->lpDirectSound3DBuffer[SSTART],
  1148.                                                   P2M(lpShip->dPosX - 320),
  1149.                                                  -P2M(lpShip->dPosY - 240),
  1150.                                                  D3DVAL(0),
  1151.                                                  DS3D_DEFERRED);
  1152.                 bStart[SSTART] = TRUE;
  1153.                 lpShip->bMoving = TRUE;
  1154.                 }
  1155.             lpShip->bEngineRunning = TRUE;
  1156.             }
  1157.         }
  1159.     if (lpShip->bMoving)
  1160.         {
  1161.         IDirectSound3DBuffer_SetPosition(lpShip->lpDirectSound3DBuffer[SENGINE],
  1162.                                          P2M(lpShip->dPosX - 320),
  1163.                                         -P2M(lpShip->dPosY - 240),
  1164.                                         D3DVAL(0),
  1165.                                         DS3D_DEFERRED);
  1166.         IDirectSound3DBuffer_SetVelocity(lpShip->lpDirectSound3DBuffer[SENGINE],
  1167.                                          D3DVAL(lpShip->dVelX * 10), //exagerater vel
  1168.                                          -D3DVAL(lpShip->dVelY * 10),
  1169.                                          D3DVAL(0),
  1170.                                          DS3D_DEFERRED);
  1171.         }
  1173.     if (lpShip->dwKeys & KEY_STOP)
  1174.         {
  1175.         if (lpShip->bMoving)
  1176.             {
  1177.             IDirectSound3DBuffer_SetPosition(lpShip->lpDirectSound3DBuffer[SSTOP],
  1178.                                               P2M(lpShip->dPosX - 320),
  1179.                                              -P2M(lpShip->dPosY - 240),
  1180.                                              D3DVAL(0),
  1181.                                              DS3D_DEFERRED);
  1182.             bStart[SSTOP]   = TRUE;
  1183.             bStop[SENGINE]  = TRUE;
  1184.             lpShip->bEngineRunning  = FALSE;
  1185.             lpShip->bMoving         = FALSE;
  1186.             }
  1187.         }
  1189.     if (lpShip->dwKeys & KEY_FIRE)
  1190.         {
  1191.         if (!lpShip->bFiring)
  1192.             {
  1193.             IDirectSound3DBuffer_SetPosition(lpShip->lpDirectSound3DBuffer[BFIRE],
  1194.                                               P2M(lpShip->dPosX - 320),
  1195.                                              -P2M(lpShip->dPosY - 240),
  1196.                                              D3DVAL(0),
  1197.                                              DS3D_DEFERRED);
  1198.             bStart[BFIRE]   = TRUE;
  1199.             lpShip->bFiring = TRUE;
  1200.             }
  1201.         }
  1203.     if (lpShip->bBlockHit)
  1204.         {
  1205.         IDirectSound3DBuffer_SetPosition(lpShip->lpDirectSound3DBuffer[LBOOM],
  1207.                                           P2M(lpShip->dBulletPosX - 320),
  1208.                                          -P2M(lpShip->dBulletPosY - 240),
  1209.                                          D3DVAL(0),
  1210.                                          DS3D_DEFERRED);
  1212.         bStart[LBOOM] = TRUE;
  1213.         lpShip->bBlockHit = FALSE;
  1214.         }
  1216.     if (lpShip->bBounced)
  1217.         {
  1218.         IDirectSound3DBuffer_SetPosition(lpShip->lpDirectSound3DBuffer[SBOUNCE],
  1219.                                          P2M(lpShip->dPosX - 320),
  1220.                                          -P2M(lpShip->dPosY - 240),
  1221.                                          D3DVAL(0),
  1222.                                          DS3D_DEFERRED);
  1224.         bStart[SBOUNCE] = TRUE;
  1225.         lpShip->bBounced = FALSE;
  1226.         }
  1229.     if (lpShip->bDeath)
  1230.         {
  1231.         bStop [BFIRE]   = TRUE;
  1232.         bStop [SBOUNCE] = TRUE;
  1233.         bStop [SSTOP]   = TRUE;
  1234.         bStop [SSTART]  = TRUE;
  1235.         bStop [SENGINE] = TRUE;
  1236.         bStart[SBOOM]   = TRUE; 
  1237.         lpShip->bDeath  = FALSE;  //turn off sound flag.
  1238.         }
  1240.     //stop, update, and start sounds.
  1241.     for (i=0; i<MAX_SOUNDS; i++)
  1242.         {
  1243.         if (bStop[i])
  1244.             {
  1245.             IDirectSoundBuffer_Stop(lpShip->lpDirectSoundBuffer[i]);
  1246.             bStart[i] = FALSE;
  1247.             }
  1248.         }
  1249.     IDirectSound3DListener_CommitDeferredSettings(glpDirectSound3DListener);
  1251.     for (i=0; i<MAX_SOUNDS; i++)
  1252.         {
  1253.         if (bStart[i])
  1254.             {
  1255.              IDirectSoundBuffer_SetCurrentPosition(lpShip->lpDirectSoundBuffer[i], 0);
  1257.              if (DSERR_BUFFERLOST==IDirectSoundBuffer_Play(lpShip->lpDirectSoundBuffer[i],
  1258.                                                            0,
  1259.                                                            0,
  1260.                                                            (i==SENGINE) ? DSBPLAY_LOOPING : 0))
  1261.                 {
  1262.                 WaveReload(gSoundEffect[i]);
  1263.                 }
  1264.             }
  1265.         }
  1266.     lpShip->dwKeys = 0;
  1267. };
  1272. /*
  1273.  * RenderPlayerCB
  1274.  *
  1275.  * Renders a ship in its current state. Also checks if we hit the ship and informs
  1276.  * the ship that it has been destroyed.
  1277.   */
  1279. BOOL WINAPI RenderPlayerCB(DPID dpId, DWORD dwPlayerType, LPCDPNAME lpName, 
  1280. DWORD dwFlags, LPVOID lpContext)
  1281. {
  1282.     SHIP ship, ourShip;
  1283.     DWORD dwSize = sizeof(ship);
  1284.     BOOL bHit = FALSE;
  1285.     HRESULT hr;
  1286.     DWORD dwTickCount;
  1287.     
  1288.     // get ship data
  1289.     hr = DPlayGetPlayerData(dpId, &ship, &dwSize, DPGET_LOCAL);
  1291.     if (FAILED(hr))
  1292.     {
  1293.         wsprintf(gDebugBuff, TEXT("Get Player local data failed for id %dn"), dpId);
  1294.         DEBUG_OUT(gDebugBuff);
  1295.         goto FAIL;
  1296.     }
  1298. // no player data yet
  1299. if (0 == dwSize)
  1300. return TRUE; 
  1302.     // ignore current ship ?
  1303.     if (ship.bIgnore)
  1304.     {
  1305.     // if this ship was being ignored, update ignore time-out
  1306.     // A time-out is used here to ensure that this ship doesn't get ignored
  1307.     // forever on our screen in case the destroy message was dropped.
  1308.         dwTickCount = timeGetTime();
  1309.     ship.iCountDown -= dwTickCount - ship.dwLastTick;
  1310.         ship.dwLastTick = dwTickCount;
  1311.     if( ship.iCountDown < 0 ) 
  1312. {
  1313.             ship.bIgnore = FALSE;
  1314. }
  1316.         // save ship data
  1317.     hr = DPlaySetPlayerData(dpId, &ship, sizeof(ship), DPSET_LOCAL);
  1318.         if (FAILED(hr))
  1319.         {
  1320. wsprintf(gDebugBuff, TEXT("Set Player local data failed for id %dn"), dpId);
  1321. DEBUG_OUT(gDebugBuff);
  1322.             goto FAIL;
  1323.         }
  1324.         // we are ignoring this ship, so just bail
  1325.         return TRUE;
  1326.     }
  1328.     // bail, if ship is disabled
  1329.     if (!ship.bEnable) return TRUE;
  1331. // update ship's position
  1332. UpdatePosition(dpId, &ship);
  1334.     // get our player data to compare with others
  1335.     dwSize = sizeof(ship);
  1336.     hr = DPlayGetPlayerData(gOurID, &ourShip, &dwSize, DPGET_LOCAL);
  1337.     if (FAILED(hr))
  1338.     {
  1339.         wsprintf(gDebugBuff, TEXT("Get Player local data failed for id %dn"), dpId);
  1340.         DEBUG_OUT(gDebugBuff);
  1341.         goto FAIL;
  1342.     }
  1344. // check if our bullet hit the current ship
  1345. if((dpId != gOurID) && ourShip.bBulletEnable && ship.bEnable)
  1346. {
  1347. if( (ourShip.dBulletPosX > ship.dPosX) &&
  1348. (ourShip.dBulletPosX < (ship.dPosX + 32.0) ) &&
  1349. (ourShip.dBulletPosY > ship.dPosY) &&
  1350. (ourShip.dBulletPosY < (ship.dPosY + 32.0) ) )
  1351. {
  1352. // hasta-la-vista baby
  1353. DestroyShip(&ship);
  1354.             // we nailed it
  1355.             bHit = TRUE;
  1356.             // turn off ship locally
  1357.             ship.bEnable = FALSE;
  1358. // temporarily ignore ship until we get a response
  1359. ship.bIgnore = TRUE;
  1360. // set its ignore time-out
  1361. ship.iCountDown = HIDE_TIMEOUT;
  1362.             // time-stamp
  1363.             ship.dwLastTick = timeGetTime();
  1364. // turn our bullet off
  1365. ship.bBulletEnable = FALSE;
  1366. // update our score
  1367.             ourShip.dwScore += 1000;
  1368.          // save our score
  1369.         hr = DPlaySetPlayerData(gOurID, &ourShip, sizeof(ourShip), DPSET_LOCAL);
  1370.             if (FAILED(hr))
  1371.             {
  1372.                 ShowError(IDS_DPLAY_ERROR_SPLD);
  1373.                 goto FAIL;
  1374.             }
  1375. }
  1376. }
  1378. // render the ship
  1379. if (ship.bBulletEnable) DrawBullet(&ship);
  1380. if (ship.bEnable)       DrawShip(&ship);
  1382.     ProcessSoundFlags(&ship);
  1384. // save ship data
  1385. hr = DPlaySetPlayerData(dpId, &ship, sizeof(ship), DPSET_LOCAL);
  1386.     if (FAILED(hr))
  1387.     {
  1388. wsprintf(gDebugBuff, TEXT("Set Player local data failed for id %dn"), dpId);
  1389. DEBUG_OUT(gDebugBuff);
  1390.         goto FAIL;
  1391.     }
  1393. // inform the player
  1394.     if (bHit)
  1395.     {
  1396.         gShipHitMsg.Id = dpId;
  1397.         SendGameMessage((LPGENERICMSG) &gShipHitMsg, dpId);
  1398.     }
  1400.     // success
  1401.     return TRUE;
  1403. FAIL:
  1404.     // failed
  1405.     return FALSE;
  1406. }
  1408. /*
  1409.  * DrawScreen
  1410.  * 
  1411.  * Renders the current frame
  1412.  */
  1413. BOOL DrawScreen( void )
  1414. {
  1415.     BYTE    mask, col;
  1416.     int     x, y;
  1417.     HRESULT hr;
  1419. // clear screen
  1420.     EraseScreen();
  1421.     
  1422. // render players
  1423.     hr = DPlayEnumPlayers(NULL, RenderPlayerCB, NULL, 0);
  1424.     if (FAILED(hr))
  1425.     {
  1426.         ShowError(IDS_DPLAY_ERROR_EP);
  1427.         goto FAIL;
  1428.     }
  1430. // render field
  1431.     for( y=0; y<30; y++)
  1432.     {
  1433.         for( x=0; x<40; x++)
  1434. {
  1435. mask = 1 << (x & 0x7);
  1436. col = x >> 3;
  1437. if( gBlocks.bits[y][col] & mask )
  1438. DrawBlock( x, y );
  1439. }
  1440.     }
  1441.     
  1442. // render score
  1443.     if (!DrawScore())
  1444.     {
  1445.         goto FAIL;
  1446.     }
  1448. // render fragments
  1449.     DrawFragments();    
  1451. // render frame rate
  1452.     if( gbShowFrameCount )
  1453.         DisplayFrameRate();
  1455. // show
  1456.     FlipScreen();
  1458.     // success
  1459.     return TRUE;
  1461. FAIL:
  1462.     return FALSE;
  1463. }
  1465. /*
  1466.  * DisplayFrameRate
  1467.  * 
  1468.  * Renders current frame rate
  1469.  */
  1470. void DisplayFrameRate( void )
  1471. {
  1472.     DWORD time2;
  1473.     char buff[256];
  1474. static DWORD dwFrames;
  1476.     gdwFrameCount++;
  1477.     time2 = timeGetTime() - gdwFrameTime;
  1478.     if( time2 > 1000 )
  1479.     {
  1480.         dwFrames = (gdwFrameCount*1000)/time2;
  1481.         gdwFrameTime = timeGetTime();
  1482.         gdwFrameCount = 0;
  1483.     }
  1484.     if( dwFrames == 0 )
  1485.     {
  1486.         return;
  1487.     }
  1489.     if (dwFrames != gdwFramesLast)
  1490.     {
  1491.         gdwFramesLast = dwFrames;
  1492.     }
  1494.     if( dwFrames > 99 )
  1495.     {
  1496. dwFrames = 99;
  1497.     }
  1498.     buff[0] = (char)((dwFrames / 10) + '0');
  1499.     buff[1] = (char)((dwFrames % 10) + '0');
  1500.     buff[2] = '';
  1501.     bltScore(buff, 295, 10);
  1502. }
  1504. /*
  1505.  * DrawScore
  1506.  *
  1507.  * Renders our current score
  1508.  */
  1509. BOOL DrawScore( void )
  1510. {
  1511.     SHIP        ship;
  1512.     DWORD       dwSize;
  1513.     char        dwScorebuf[11];
  1514.     int         rem;
  1515.     HRESULT     hr;
  1517.     dwSize = sizeof(ship);
  1518.     hr = DPlayGetPlayerData(gOurID, &ship, &dwSize, DPGET_LOCAL);
  1519.     if (FAILED(hr))
  1520.     {
  1521.         wsprintf(gDebugBuff, TEXT("Get Player local data failed for id %dn"), gOurID);
  1522.         DEBUG_OUT(gDebugBuff);
  1523.         goto FAIL;
  1524.     }
  1526.     // blt everything in reverse order if we are doing destination transparency
  1527.     // calculate dwScore string
  1528.     dwScorebuf[0] = (BYTE)ship.dwScore/100000 + '0';
  1529.     rem = ship.dwScore % 100000;
  1530.     dwScorebuf[1] = rem/10000 + '0';
  1531.     rem = ship.dwScore % 10000;
  1532.     dwScorebuf[2] = rem/1000 + '0';
  1533.     rem = ship.dwScore % 1000;
  1534.     dwScorebuf[3] = rem/100 + '0';
  1535.     rem = ship.dwScore % 100;
  1536.     dwScorebuf[4] = rem/10 + '0';
  1537.     rem = ship.dwScore % 10;
  1538.     dwScorebuf[5] = rem + '0';
  1539.     dwScorebuf[6] = '';
  1541.     bltScore(dwScorebuf, 8, 8);
  1543. // save ship data
  1544. hr = DPlaySetPlayerData(gOurID, &ship, sizeof(ship), DPSET_LOCAL);
  1545.     if (FAILED(hr))
  1546.     {
  1547.         ShowError(IDS_DPLAY_ERROR_SPLD);
  1548.         goto FAIL;
  1549.     }
  1551.     return TRUE;
  1553. FAIL:
  1554.     // failed
  1555.     return FALSE;
  1556. }
  1558. /*
  1559.  * DrawBlock
  1560.  *
  1561.  * Renders a block
  1562.  */
  1563. void DrawBlock( int x, int y )
  1564. {
  1565.     RECT    src;
  1566.     
  1567.     src.top = 0;
  1568.     src.left = 224;
  1569.     src.right = src.left + 16;
  1570.     src.bottom = src.top + 16;
  1571.     bltObject( x << 4, y << 4, glpNum, &src, DDBLTFAST_SRCCOLORKEY );
  1572. }
  1574. /*
  1575.  * DrawShip
  1576.  *
  1577.  * Renders a ship
  1578.  */
  1579. void DrawShip( LPSHIP lpShip )
  1580. {
  1581.     RECT    src;
  1582.     LPDIRECTDRAWSURFACE surf;
  1584.     src.top = 32 * (lpShip->cFrame / 10 );
  1585.     src.left = 32 * (lpShip->cFrame % 10 );
  1586.     src.right = src.left + 32;
  1587.     src.bottom = src.top + 32;
  1588.     switch( lpShip->byType )
  1589.     {
  1590.     case 0: surf = glpShip0; break;
  1591.     case 1: surf = glpShip1; break;
  1592.     case 2: surf = glpShip2; break;
  1593.     case 3: surf = glpShip3; break;
  1594.     default: DEBUG_OUT(TEXT("Ship type not specifiedn")); return;
  1595.     }
  1596.     bltObject((int)lpShip->dPosX, (int)lpShip->dPosY, surf, &src, DDBLTFAST_SRCCOLORKEY );
  1597. }
  1599. /*
  1600.  * DrawBullet
  1601.  *
  1602.  * Renders a bullet 
  1603.  */
  1604. void DrawBullet( LPSHIP lpShip )
  1605. {
  1606.     RECT    src;
  1607.     
  1608.     src.top = BULLET_Y;
  1609.     src.left = BULLET_X + (lpShip->byType)*4;
  1610.     src.right = src.left + 3;
  1611.     src.bottom = src.top + 3;
  1612.     bltObject((int)lpShip->dBulletPosX, (int)lpShip->dBulletPosY, glpNum, &src, DDBLTFAST_SRCCOLORKEY );
  1613. }
  1615. /*
  1616.  * DrawFragments
  1617.  *
  1618.  * Renders the fragments
  1619.  */
  1621. void DrawFragments( void )
  1622. {
  1623.     int     i;
  1624.     
  1625.     for(i=0; i<64; i++)
  1626.     {
  1627. if( gFrags[i].valid )
  1628. {
  1629. bltObject((int)gFrags[i].dPosX, (int)gFrags[i].dPosY, gFrags[i].surf,
  1630. &(gFrags[i].src), DDBLTFAST_SRCCOLORKEY );
  1631. }
  1632.     }
  1633. }
  1635. /*
  1636.  * ReceiveGameMessages
  1637.  *
  1638.  * Checks if there are any messages for us and receives them
  1639.  */
  1640. HRESULT ReceiveMessages( void )
  1641. {
  1642. DPID idFrom, idTo;
  1643. LPVOID lpvMsgBuffer;
  1644. DWORD dwMsgBufferSize;
  1645. HRESULT hr;
  1647. // read all messages in queue
  1648. dwMsgBufferSize = gdwReceiveBufferSize;
  1649. lpvMsgBuffer = glpvReceiveBuffer;
  1651. while (TRUE)
  1652. {
  1653. // see what's out there
  1654. idFrom = 0;
  1655. idTo = 0;
  1657. hr = DPlayReceive(&idFrom, &idTo, DPRECEIVE_ALL, lpvMsgBuffer, &dwMsgBufferSize);
  1658. if (hr == DPERR_BUFFERTOOSMALL)
  1659. {
  1660. if (lpvMsgBuffer == NULL)
  1661. {
  1662. lpvMsgBuffer = GlobalAllocPtr(GHND, dwMsgBufferSize);
  1663. if (lpvMsgBuffer == NULL)
  1664. return (DPERR_NOMEMORY);
  1665. glpvReceiveBuffer = lpvMsgBuffer;
  1666. gdwReceiveBufferSize = dwMsgBufferSize;
  1667. }
  1668. else if (dwMsgBufferSize > gdwReceiveBufferSize)
  1669. {
  1670. lpvMsgBuffer = GlobalReAllocPtr(lpvMsgBuffer, dwMsgBufferSize, 0);
  1671. if (lpvMsgBuffer == NULL)
  1672. return (DPERR_NOMEMORY);
  1673. glpvReceiveBuffer = lpvMsgBuffer;
  1674. gdwReceiveBufferSize = dwMsgBufferSize;
  1675. }
  1676. }
  1677. else if ((hr == DP_OK) && 
  1678.                  ((dwMsgBufferSize >= sizeof(GENERICMSG)) || 
  1679.                   (dwMsgBufferSize >= sizeof(DPMSG_GENERIC))))
  1680. {
  1681. if (idFrom == DPID_SYSMSG)
  1682.             {
  1683. DoSystemMessage((LPDPMSG_GENERIC) lpvMsgBuffer, dwMsgBufferSize, idFrom, idTo);
  1684.             }
  1685. else
  1686.             {
  1687. DoApplicationMessage((LPGENERICMSG) lpvMsgBuffer, dwMsgBufferSize, idFrom, idTo);
  1688.             }
  1689. }
  1690. else
  1691. break;
  1692. };
  1694.     return hr;
  1695. }
  1697. /*
  1698.  * DoSystemMessage
  1699.  *
  1700.  * Evaluates system messages and performs appropriate actions
  1701.  */
  1702. void DoSystemMessage( LPDPMSG_GENERIC lpMsg, DWORD dwMsgSize, DPID idFrom, DPID idTo )
  1703. {
  1704.     switch( lpMsg->dwType)
  1705.     {
  1706.     case DPSYS_CREATEPLAYERORGROUP:
  1707.         {
  1708.          LPDPMSG_CREATEPLAYERORGROUP lpAddMsg = (LPDPMSG_CREATEPLAYERORGROUP) lpMsg;
  1710.             if( gbIsHost)
  1711.     {
  1712.                 gHostMsg.Blocks = gBlocks;
  1713.     SendGameMessage((LPGENERICMSG) &gHostMsg, lpAddMsg->dpId);
  1714.     }
  1715.         }
  1716. break;
  1718.     case DPSYS_DESTROYPLAYERORGROUP:
  1719.         {
  1720.             LPSHIP lpShip;
  1721.          LPDPMSG_DESTROYPLAYERORGROUP lpDestroyMsg = (LPDPMSG_DESTROYPLAYERORGROUP) lpMsg;
  1723.             if ((sizeof(SHIP) != lpDestroyMsg->dwLocalDataSize) || 
  1724.                 (NULL == lpDestroyMsg->lpLocalData))
  1725.                 break;
  1727.             lpShip = lpDestroyMsg->lpLocalData;
  1728.             ReleasePlayerLocalSoundData(lpShip);
  1729.         }
  1730. break;
  1732. case DPSYS_HOST:
  1733.         {     
  1734.             gbIsHost = TRUE;            
  1735. UpdateTitle();
  1736.         }
  1738. break;
  1740.     case DPSYS_SESSIONLOST:
  1741.         // inform user that session was lost
  1742.         ShowError(IDS_DPLAY_ERROR_SL);
  1743.         gbSessionLost = TRUE;
  1744.         break;
  1745.     }
  1746. }
  1748. /*
  1749.  * DoApplicationMessage
  1750.  *
  1751.  * Evaluates an application message and performs appropriate actions
  1752.  */
  1753. void DoApplicationMessage( LPGENERICMSG lpMsg, DWORD dwMsgSize, DPID idFrom, DPID idTo )
  1754. {        
  1755.     HRESULT hr;
  1757.     switch( lpMsg->byType )
  1758.     {
  1759.     case MSG_HOST:
  1760. {
  1761. LPHOSTMSG       lpHost;
  1763. if( !gbIsHost )
  1764. {
  1765. lpHost = (LPHOSTMSG) lpMsg;
  1766.                 // receive the field layout
  1767. gBlocks = lpHost->Blocks;
  1769.                 // have host initializtion at this point
  1770. gbHaveHostInit = TRUE;
  1771.                 
  1772.                 // start updating screen
  1773.                 gbIsActive = TRUE;
  1774. }
  1775. }
  1776. break;
  1778.     case MSG_BLOCKHIT:
  1779. {
  1780. LPBLOCKHITMSG   lpBlockHit;
  1782. lpBlockHit = (LPBLOCKHITMSG) lpMsg;
  1783. gBlocks.bits[lpBlockHit->byRow][lpBlockHit->byCol] &= ~lpBlockHit->byMask;
  1784. }
  1785. break;
  1787.     case MSG_ADDBLOCK:
  1788. {
  1789. LPADDBLOCKMSG   lpAddBlock;
  1791. lpAddBlock = (LPADDBLOCKMSG) lpMsg;
  1792. setBlock( lpAddBlock->byX, lpAddBlock->byY);
  1793. }
  1794. break;
  1796.     case MSG_SHIPHIT:
  1797.         {
  1798.     LPSHIPHITMSG    lpShipHit = (LPSHIPHITMSG) lpMsg;
  1799.             SHIP ship;
  1800.             DWORD dwSize;
  1802.             dwSize = sizeof(SHIP);
  1803.  // get player local data
  1804. hr = DPlayGetPlayerData(lpShipHit->Id, &ship, &dwSize, DPGET_LOCAL);
  1805.             if (FAILED(hr))
  1806.                 return;
  1808. // no player data yet
  1809. if (0 == dwSize)
  1810. return;
  1812. if (!ship.bIgnore) 
  1813.             {
  1814. // explode the ship on our screen
  1815. DestroyShip(&ship);
  1817.      // turn it off
  1818. ship.bEnable = FALSE;
  1819. ship.bBulletEnable = FALSE;
  1821. // if it is us
  1822. if (lpShipHit->Id == gOurID)
  1823. {
  1824.                     // set our hide time-out
  1825.      ship.iCountDown = HIDE_TIMEOUT;
  1826.                     ship.dwLastTick = timeGetTime();
  1827.                     // let the world know that we are dead
  1828.                     gShipHitMsg.Id = gOurID;
  1829. SendGameMessage((LPGENERICMSG) &gShipHitMsg, DPID_ALLPLAYERS);
  1830. }
  1831. }
  1832.             // update player local data
  1833.    DPlaySetPlayerData(lpShipHit->Id, &ship, sizeof(ship), DPSET_LOCAL);
  1834.         }
  1835. break;
  1837.     case MSG_CONTROL:
  1838.         {
  1839.             LPCONTROLMSG lpControlMsg;
  1840.             SHIP ship;
  1841.             DWORD dwSize;
  1843.             lpControlMsg = (LPCONTROLMSG) lpMsg;
  1844.             dwSize = sizeof(SHIP);
  1845. // get player local data
  1846. hr = DPlayGetPlayerData(idFrom, &ship, &dwSize, DPGET_LOCAL);
  1847.             if (FAILED(hr))
  1848.                 return;
  1850. // no player data yet
  1851. if (0 == dwSize)
  1852. return;
  1854.             // update its State
  1855.             UpdateState(&ship, (DWORD)lpControlMsg->byState);
  1857.             // save it back
  1858.     DPlaySetPlayerData(idFrom, &ship, dwSize, DPSET_LOCAL);
  1859.         }
  1860.         break;
  1862.     case MSG_SYNC:
  1863.         {
  1864.             LPSYNCMSG lpSyncMsg;
  1865.             SHIP ship;
  1866.             DWORD dwSize;
  1868.             lpSyncMsg = (LPSYNCMSG) lpMsg;
  1869.             dwSize = sizeof(SHIP);
  1870. // get player local data
  1871. hr = DPlayGetPlayerData(idFrom, &ship, &dwSize, DPGET_LOCAL);
  1872.             if (FAILED(hr))
  1873.                 return;
  1875. // we are seeing this player for the first time
  1876. // so do the initialization
  1877. if (0 == dwSize)
  1878. {
  1879. ZeroMemory(&ship, sizeof(ship));
  1881. // initialize sound buffers (this should never be us)                     
  1882.                 if(gOurID == idFrom) 
  1883.                 {
  1884.                     MessageBox (NULL, "gOurID == idFrom", "Ack!!!", MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL);
  1885.                     _asm int 3
  1886.                 }
  1887. InitPlayerLocalSoundData(&ship, FALSE);
  1889. ship.byType = lpSyncMsg->byShipType;
  1890.                 ship.dPosX = lpSyncMsg->dPosX;
  1891.                 ship.dPosY = lpSyncMsg->dPosY;
  1892.                 ship.cFrame = lpSyncMsg->cFrame;
  1893.                 ship.dwLastTick = timeGetTime();
  1894.                 ship.bEnable = TRUE;
  1895. }
  1897. if (ship.bEnable)
  1898.             {
  1899.                 // head towards rendezvous location (accelerate/decelerate as necessary)
  1900.                 ship.dVelX = (lpSyncMsg->dPosX - ship.dPosX)/1000;
  1901.                 ship.dVelY = (lpSyncMsg->dPosY - ship.dPosY)/1000;
  1902.                 ship.cFrame = lpSyncMsg->cFrame;
  1903.             }
  1904.             else if (!ship.bIgnore)
  1905.             // Ship is alive, but we just don't know it.
  1906. // So, display it at the rendezvous location.
  1907.             {
  1908.                 ship.dPosX = lpSyncMsg->dPosX;
  1909.                 ship.dPosY = lpSyncMsg->dPosY;
  1910.                 ship.cFrame = lpSyncMsg->cFrame;
  1911.                 ship.dwLastTick = timeGetTime();
  1912.                 ship.bEnable = TRUE;
  1913.             }
  1915.             // save it back
  1916.     DPlaySetPlayerData(idFrom, &ship, sizeof(ship), DPSET_LOCAL);
  1917.         }
  1918.         break;
  1920.     default:
  1921. {
  1922.             wsprintf(gDebugBuff, TEXT("Unknown message type %dn"), lpMsg->byType);
  1923. DEBUG_OUT( gDebugBuff );
  1924. }
  1925. break;
  1926.     }
  1927. }
  1929. /*
  1930.  * SendGameMessage
  1931.  *
  1932.  * Sends a message to specified player(s)
  1933.  */
  1934. void SendGameMessage( LPGENERICMSG lpMsg, DPID idTo )
  1935. {
  1936.     int             nBytes;
  1937. DWORD dwFlags = 0;
  1939.     if (gbSessionLost)
  1940.     {
  1941.         // no sends when we are not in the session
  1942.         return;
  1943.     }
  1945.     switch( lpMsg->byType )
  1946.     {
  1947.     case MSG_HOST:
  1948.         nBytes = sizeof( HOSTMSG );
  1949. dwFlags = DPSEND_GUARANTEED;
  1950. break;
  1952.     case MSG_BLOCKHIT:
  1953. nBytes = sizeof( BLOCKHITMSG );
  1954. break;
  1956.     case MSG_SHIPHIT:
  1957. nBytes = sizeof( SHIPHITMSG );
  1958. break;
  1960.     case MSG_ADDBLOCK:
  1961. nBytes = sizeof( ADDBLOCKMSG );
  1962. break;
  1964.     case MSG_CONTROL:
  1965. nBytes = sizeof( CONTROLMSG );
  1966.         break;
  1968.     case MSG_SYNC:
  1969. nBytes = sizeof( SYNCMSG );
  1970.         break;
  1972.     default:
  1973.         return;
  1974. }
  1976.     if (gbReliable)
  1977.     {
  1978.      dwFlags = DPSEND_GUARANTEED;
  1979.     }
  1981. // Send the message to the relevant player(s)
  1982. DPlaySend(gOurID, idTo, dwFlags, (LPVOID)lpMsg, nBytes);
  1983. }
  1985. /*
  1986.  * CleanupComm
  1987.  *
  1988.  * Cleans up communication stuff
  1989.  */
  1990. void CleanupComm(void)
  1991. {
  1992. HRESULT hr;
  1994. //free up all the local sound buffers
  1995.     ReleaseLocalData();
  1997.     // free the receive buffer
  1998.     if (glpvReceiveBuffer)
  1999. {
  2000.      GlobalFreePtr(glpvReceiveBuffer);
  2001. glpvReceiveBuffer = NULL;
  2002. }
  2004.     // delete our player
  2005.     if( gOurID ) 
  2006.     {
  2007.         hr = DPlayDestroyPlayer(gOurID);
  2008.         if (FAILED(hr))
  2009.         {
  2010.             ShowError(IDS_DPLAY_ERROR_DP);
  2011.         }
  2012. gOurID = 0;
  2013.     }
  2015. // cleanup directplay objects
  2016. hr = DPlayClose();
  2017. hr = DPlayRelease();
  2018. }