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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
cRaceCar.cpp
资源名称：Visual_C++GameDevelop.rar　[点击查看]
上传用户：sycq158
上传日期：2008-10-22
资源大小：15361k
文件大小：29k
源码类别：

游戏

开发平台：

Visual C++

cRaceCar.cpp：源码内容
  1. // RACE X
  2. //
  3. // Written by Mauricio Teichmann Ritter
  4. //
  5. // Copyright (C) 2002, Brazil. All rights reserved.
  6. // 
  7. //
  9. #include "stdafx.h"
  10. #include "RaceX.h"
  11. #include "cRaceCar.h"
  12. #include ".applibckeyboard.h"
  13. #include <math.h>
  14. #include <stdio.h>
  15. #include "cRaceTrack.h"
  19. #define CARBOUND_POINTS 4
  21. //////////////////////////////////////////////////////////////////////
  22. // Construction/Destruction
  23. //////////////////////////////////////////////////////////////////////
  26. cRaceCar::cRaceCar()
  27. {
  28. m_iMaxSpeed = 270;
  29. m_iSpeed = 0;
  30. m_fDirectionY = -9;
  31. m_fDirectionX = 0;
  32. m_fIncrementY = 1;
  33. m_fIncrementX = 1;
  35. m_fBackupIncrementX = 1;
  36. m_fBackupIncrementY = 1;
  37. m_iBackupDistanceToNextCheckPoint = 0;
  38. m_fBackupDirectionY = -9;
  39. m_fBackupDirectionX = 0;
  40. m_iBackupAngle = 0;
  43. m_iAngle = 0;
  45. m_iCheckPoint = -1;
  46. m_iLaps = 0;
  48. m_pBound = (POINT*) malloc(sizeof(POINT) * CARBOUND_POINTS);
  50. m_lLastTurn = 0;
  51. m_lLastSpeedIncr = 0;
  53. m_iCarState = CARSTATE_OK;
  55. POINT tmpPoints[] = { {12,4},  {26,4},  {26,29}, {12,29}};
  58. m_pBound =(POINT*)  memcpy((void*) m_pBound,(void*) &tmpPoints, sizeof(POINT)* CARBOUND_POINTS);
  60. m_hcRaceCar.CreatePolygonBound(m_pBound, CARBOUND_POINTS);
  61. }
  63. cRaceCar::~cRaceCar()
  64. {
  65. free(m_pBound);
  66. m_hcRaceCar.Destroy();
  67. }
  69. void cRaceCar::SetPos(int iX, int iY)
  70. {
  71. m_fPosX = (float)iX;
  72. m_fPosY = (float)iY;
  73. }
  75. void cRaceCar::Create(int iColor)
  76. {
  77. m_sprCar.Create(GetMainApp()->m_hInst, iColor, 360, 160, RGB(0,0,0), 40, 40);
  78. m_hcRaceCar.CreateRectBound(40,40);
  79. iCrashTime = 0;
  81. m_iColor = iColor;
  83. m_pSound.Create(MAKEINTRESOURCE(IDR_ENGINE), DSBCAPS_CTRL3D | DSBCAPS_CTRLFREQUENCY, DS3DALG_HRTF_LIGHT);
  84. m_pSound.m_pSoundBuffer->SetCurrentPosition( 0 );
  86. m_pCrashSound.Create(MAKEINTRESOURCE(IDR_EXPLODE), DSBCAPS_CTRL3D, DS3DALG_HRTF_LIGHT);
  87. m_pCrashSound.m_pSoundBuffer->SetCurrentPosition( 0 );
  89. m_lCurrentTime = 0;
  90. m_bRemoteKeyboardStatus = 0;
  92. m_bLastSent_Speed = -1;
  93. m_bLastSent_Position = -1;
  94. m_bLastSent_CarState = -1;
  95. m_bLastSent_Laps = -1;
  96. m_bLastSent_Angle = -1;
  97. m_dwLastSent_LastLapTime = -1;
  98. m_nLastSent_PosX = -1;
  99. m_nLastSent_PosY = -1;
  100. }
  102. void cRaceCar::Destroy()
  103. {
  104. m_sprCar.Destroy();
  105. m_hcRaceCar.Destroy();
  106. m_sprCarExplode_0.Destroy();
  107. m_sprCarExplode_135.Destroy();
  108. m_sprCarExplode_180.Destroy();
  109. m_sprCarExplode_225.Destroy();
  110. m_sprCarExplode_270.Destroy();
  111. m_sprCarExplode_315.Destroy();
  112. m_sprCarExplode_45.Destroy();
  113. m_sprCarExplode_90.Destroy();
  114. m_pSound.Destroy();
  115. m_pCrashSound.Destroy();
  116. }
  118. void cRaceCar::Draw(int iViewX, int iViewY)
  119. {
  120. // Draw the car based on the current position in the map
  121. int iClipX = 0, iClipY = 0;
  122. int iClipWidth = 40, iClipHeight = 40;
  123. int iX = (int)m_fPosX - iViewX;
  124. int iY = (int) m_fPosY - iViewY;
  126. if((int)m_fPosX - iViewX > 640)
  127. return;
  129. if((int)m_fPosX - iViewX + 40 < 0)
  130. return;
  132. if((int) m_fPosY - iViewY > 460)
  133. return;
  135. if((int) m_fPosY - iViewY +40 < 0)
  136. return;
  140. if((int) m_fPosY - iViewY + 40 > 460)
  141. iClipHeight = 40-((int) m_fPosY - iViewY + 40 - 460);
  143. if((int) m_fPosX - iViewX + 40 > 640)
  144. iClipWidth = 40-((int) m_fPosX - iViewX + 40 - 640);
  146. if((int)m_fPosX - iViewX < 0)
  147. {
  148. iClipX = abs((int)m_fPosX - iViewX);
  149. iClipWidth -= iClipX;
  150. iX = 0;
  151. }
  153. if((int)m_fPosY - iViewY < 0)
  154. {
  155. iClipY = abs((int)m_fPosY - iViewY);
  156. iClipHeight -= iClipY;
  157. iY = 0;
  158. }
  160. if(m_iCarState == CARSTATE_CRASHED_WALL)
  161. {
  162. // If we crashed, play the explosion sprite
  163. if(m_iAngle == 0)
  164. m_sprCarExplode_0.Draw(GetMainApp()->m_pBackBuffer, iX, iY,m_sprCarExplode_0.IsEnd() ? FALSE : TRUE, iClipX, iClipY, iClipWidth, iClipHeight);
  166. if(m_iAngle > 0 && m_iAngle < 90)
  167. m_sprCarExplode_45.Draw(GetMainApp()->m_pBackBuffer, iX, iY,m_sprCarExplode_45.IsEnd() ? FALSE : TRUE, iClipX, iClipY, iClipWidth, iClipHeight);
  169. if(m_iAngle == 90)
  170. m_sprCarExplode_90.Draw(GetMainApp()->m_pBackBuffer, iX, iY,m_sprCarExplode_90.IsEnd() ? FALSE : TRUE, iClipX, iClipY, iClipWidth, iClipHeight);
  172. if(m_iAngle > 90 && m_iAngle < 180)
  173. m_sprCarExplode_135.Draw(GetMainApp()->m_pBackBuffer, iX, iY,m_sprCarExplode_135.IsEnd() ? FALSE : TRUE, iClipX, iClipY, iClipWidth, iClipHeight);
  175. if(m_iAngle == 180)
  176. m_sprCarExplode_180.Draw(GetMainApp()->m_pBackBuffer, iX, iY,m_sprCarExplode_180.IsEnd() ? FALSE : TRUE, iClipX, iClipY, iClipWidth, iClipHeight);
  178. if(m_iAngle > 180 && m_iAngle < 270)
  179. m_sprCarExplode_225.Draw(GetMainApp()->m_pBackBuffer, iX, iY,m_sprCarExplode_225.IsEnd() ? FALSE : TRUE, iClipX, iClipY, iClipWidth, iClipHeight);
  181. if(m_iAngle == 270)
  182. m_sprCarExplode_270.Draw(GetMainApp()->m_pBackBuffer, iX, iY,m_sprCarExplode_270.IsEnd() ? FALSE : TRUE, iClipX, iClipY, iClipWidth, iClipHeight);
  184. if(m_iAngle > 270 && m_iAngle < 360)
  185. m_sprCarExplode_315.Draw(GetMainApp()->m_pBackBuffer, iX, iY,m_sprCarExplode_315.IsEnd() ? FALSE : TRUE, iClipX, iClipY, iClipWidth, iClipHeight);
  186. }
  187. else
  188. {
  189. // otherwise, blit the normal car, in its current angle
  190. m_sprCar.Draw(GetMainApp()->m_pBackBuffer, iX, iY, FALSE, iClipX, iClipY, iClipWidth, iClipHeight);
  191. }
  193. // If you want to see the car bounding rect, uncomment this
  195. /*HDC hdc;
  196. GetMainApp()->m_pBackBuffer->GetDC(&hdc);
  197. OffsetRgn(m_hcRaceCar.hBoundingPoly, (int)m_fPosX - iViewX, (int) m_fPosY - iViewY);
  198. FillRgn(hdc, m_hcRaceCar.hBoundingPoly, (HBRUSH) GetStockObject(BLACK_BRUSH));
  199. OffsetRgn(m_hcRaceCar.hBoundingPoly, -1*((int)m_fPosX - iViewX), -1*((int) m_fPosY - iViewY));
  200. GetMainApp()->m_pBackBuffer->ReleaseDC(hdc);
  201. */
  202. }
  205. void cRaceCar::Process(void* pTrack)
  206. {
  207. #define SPEEDXTURN 70
  208. #define TURN_TIME  45
  209. #define RAISESPEED_TIME 85
  210. #define MAX_SPEED_FOR_CURVE 180
  211. #define MAX_SPEED_FOR_IDLE  200
  213. //升高速度量从而降低游戏速度
  214. //降低速度量从而使游戏更快速
  215. #define _SPEED_FACTOR_ 17
  217. int iX, iY;
  218. static long lLastMessage;
  220. //iTurnCar = TURN_RIGHT;
  221. cRaceTrack* theTrack = (cRaceTrack*)pTrack;
  222. cKeyboard pKeyboard;
  224. //如果赛车不在正常状态
  225. if(m_iCarState != CARSTATE_OK)
  226. {
  227. //赛车发生碰撞，需要调入爆炸的声音
  228. if(iCrashTime == 0)
  229. {
  230. iCrashTime = GetTickCount();
  231. if(m_iCarState != CARSTATE_RACECOMPLETED)
  232. m_pCrashSound.Play();
  233. }
  234. //爆炸
  235. Crashed();
  236. if(m_iCarState == CARSTATE_RACECOMPLETED)
  237. {
  238. }
  239. else
  240. {
  241. if(GetTickCount() - iCrashTime > 2500)
  242. {
  244. // Crash time elapse, return the car to the backuped position
  245. m_sprCarExplode_0.Destroy();
  246. m_sprCarExplode_135.Destroy();
  247. m_sprCarExplode_180.Destroy();
  248. m_sprCarExplode_225.Destroy();
  249. m_sprCarExplode_270.Destroy();
  250. m_sprCarExplode_315.Destroy();
  251. m_sprCarExplode_45.Destroy();
  252. m_sprCarExplode_90.Destroy();
  254. if( (GetRaceXApp()->m_bIsMultiplayer == TRUE && GetRaceXApp()->GetMultiplayer()->IsHosting()) ||
  255. GetRaceXApp()->m_bIsMultiplayer == FALSE)
  256. {
  257. m_fDirectionX = m_fBackupDirectionX;
  258. m_fDirectionY = m_fBackupDirectionY;
  259. m_fIncrementX = m_fBackupIncrementX;
  260. m_fIncrementY = m_fBackupIncrementY;
  262. m_iDistanceToNextCheckPoint = m_iBackupDistanceToNextCheckPoint;
  263. iTurnCar = iBackupTurnCar;
  264. m_iAngle = m_iBackupAngle;
  265. m_fPosX = m_fBackupPosX;
  266. m_fPosY = m_fBackupPosY;
  267. m_sprCar.m_iAbsolutePosition = m_iBackupSprite;
  269. if(theTrack->GetRoadType((int)m_fPosX+10, (int)m_fPosY+10) == ID_ROADTYPE_ROADQ2 ||
  270.    theTrack->GetRoadType((int)m_fPosX+10, (int)m_fPosY+10) == ID_ROADTYPE_MEDIUMCURVEQ0P3 ||
  271.    theTrack->GetRoadType((int)m_fPosX+10, (int)m_fPosY+10) == ID_ROADTYPE_MEDIUMCURVEQ0P2)
  272. {
  273. m_fPosY+=10;
  274. }
  276. if(theTrack->GetRoadType((int)m_fPosX+10, (int)m_fPosY+10) == ID_ROADTYPE_ROADQ3||
  277.    theTrack->GetRoadType((int)m_fPosX+10, (int)m_fPosY+10) == ID_ROADTYPE_MEDIUMCURVEQ2P3 ||
  278.    theTrack->GetRoadType((int)m_fPosX+10, (int)m_fPosY+10) == ID_ROADTYPE_MEDIUMCURVEQ2P2)
  279. {
  280. m_fPosY-=10;
  281. }
  283. if(theTrack->GetRoadType((int)m_fPosX+10, (int)m_fPosY+10) == ID_ROADTYPE_ROADQ0 ||
  284.    theTrack->GetRoadType((int)m_fPosX+10, (int)m_fPosY+10) == ID_ROADTYPE_MEDIUMCURVEQ2P1 ||
  285.    theTrack->GetRoadType((int)m_fPosX+10, (int)m_fPosY+10) == ID_ROADTYPE_MEDIUMCURVEQ2P2)
  286. {
  287. m_fPosX+=10;
  288. }
  290. if(theTrack->GetRoadType((int)m_fPosX+10,(int) m_fPosY+10) == ID_ROADTYPE_ROADQ1 ||
  291.    theTrack->GetRoadType((int)m_fPosX+10, (int)m_fPosY+10) == ID_ROADTYPE_MEDIUMCURVEQ3P1 ||
  292.    theTrack->GetRoadType((int)m_fPosX+10, (int)m_fPosY+10) == ID_ROADTYPE_MEDIUMCURVEQ3P2)
  293. {
  294. m_fPosX-=10;
  295. }
  297. RotateBound(m_iAngle);
  299. iX = 0;
  300. iY = 0;
  301. m_iDistanceToNextCheckPoint = 999999999;
  302. do
  303. {
  304. iX = iX / 40;
  305. iY = iY / 40;
  306. theTrack->GetCheckPointPosition(&iX, &iY, m_iCheckPoint+1);
  307. if(m_iDistanceToNextCheckPoint > (int) sqrt( ((m_fPosX - iX)*(m_fPosX - iX)) + ((m_fPosY - iY)*(m_fPosY - iY)) ))
  308. {
  309. m_iDistanceToNextCheckPoint = (int) sqrt( ((m_fPosX - iX)*(m_fPosX - iX)) + ((m_fPosY - iY)*(m_fPosY - iY)));
  310. }
  312. if(iX != -1)
  313. iX += 40;
  315. }while(iX>0);
  317. for(int i=0;i<theTrack->GetNumberOfCars();i++)
  318. {
  319. if(m_bID != theTrack->m_pRaceCars[i]->GetID())
  320. {
  321. int iSrcX, iSrcY;
  323. theTrack->m_pRaceCars[i]->GetPos(&iSrcX, &iSrcY);
  325. if(m_hcRaceCar.HaveHitted(&theTrack->m_pRaceCars[i]->m_hcRaceCar, m_fPosX, m_fPosY, iSrcX, iSrcY) == FALSE)
  326. {
  327. m_iCarState = CARSTATE_OK;
  328. iCrashTime = 0;
  329. }
  330. }
  331. }
  332. }
  333. }
  334. }
  335. }
  336. else
  337. {
  338. int i;
  339. iCrashTime = 0;
  341. //如果赛车由人控制，则读取键盘值，判断用户意图
  342. if(m_iControlType == CTRL_USER)
  343. {
  344. if(pKeyboard.CheckKey(DIK_RIGHT))
  345. {
  346. TurnCarRight();
  347. }
  349. if(pKeyboard.CheckKey(DIK_LEFT))
  350. {
  351. TurnCarLeft();
  352. }
  354. if(pKeyboard.CheckKey(DIK_DOWN))
  355. {
  356. BreakCar();
  357. }
  359. if(pKeyboard.CheckKey(DIK_UP))
  360. {
  361. Accelerate();
  362. }
  363. else
  364. {
  365. Idle();
  366. }
  367. }/*USER CONTROL*/
  371. //远端用户，发送键盘消息到主机
  372. if(m_iControlType == CTRL_NETWORK_REMOTE &&
  373. GetRaceXApp()->m_bIsMultiplayer == TRUE &&
  374. GetRaceXApp()->GetMultiplayer()->IsHosting() )
  375. {
  376. // 键盘状态是一个字节变量，设置某些位从而判断哪个键被按下
  377. if(m_bRemoteKeyboardStatus & 0x01)
  378. {
  379. TurnCarRight();
  380. }
  381. if(m_bRemoteKeyboardStatus & 0x02)
  382. {
  383. TurnCarLeft();
  384. }
  385. if(m_bRemoteKeyboardStatus & 0x04)
  386. {
  387. BreakCar();
  388. }
  389. if(m_bRemoteKeyboardStatus & 0x08)
  390. {
  391. Accelerate();
  392. }
  393. else
  394. {
  395. Idle();
  396. }
  397. }
  399. //电脑控制的赛车
  400. if(m_iControlType == CTRL_COMPUTER)
  401. {
  402. BOOL bCanBrake = FALSE;
  403. //如果当前地图中贴片的角度和当前赛车的行进角度不一样，则需调整赛车的行进角度
  404. if(m_iAngle != theTrack->GetAngle(m_fPosX+20, m_fPosY+20) &&
  405.    theTrack->GetAngle(m_fPosX+20, m_fPosY+20) != 370)
  406. {
  408. int iValue1 = (360-m_iAngle)+theTrack->GetAngle(m_fPosX+20, m_fPosY+20);
  409. if(iValue1 > 360)
  410. {
  411. iValue1 = iValue1 % 360;
  412. }
  414. int iValue2 = (m_iAngle-theTrack->GetAngle(m_fPosX+20, m_fPosY+20));
  415. if(iValue2 < 0)
  416. {
  417. iValue2+=360;
  418. }
  420. if(iValue1 < iValue2)
  421. {
  422. TurnCarRight();
  423. bCanBrake = TRUE;
  424. }
  425. else
  426. {
  427. TurnCarLeft();
  428. bCanBrake = TRUE;
  429. }
  430. }
  431. //如果速度过快，则刹车
  432. if(m_iSpeed > 270)
  433. {
  434. if(theTrack->CarHittedRoad(this, (int) m_fPosX+20+(m_iSpeed * (m_fDirectionX/9.0f)), (int) m_fPosY+20+ (m_iSpeed * (m_fDirectionY/9.0f))) == TRUE)
  435. BreakCar();
  436. }
  437. if(bCanBrake == TRUE)
  438. {
  439. for(i=m_iSpeed-30;i>=0;i-=40)
  440. {
  441. if(theTrack->CarHittedRoad(this,(int)m_fPosX+20+(i*(m_fDirectionX/9.0f)),(int)m_fPosY+20+ (i * (m_fDirectionY/9.0f))) == TRUE)
  442. {
  443. BreakCar();
  444. }
  445. }
  446. }
  447. Accelerate();
  448. }/*COMPUTER CONTROL*/
  449. }
  453. //如果赛车被一个远端用户控制
  454. if(m_iControlType == CTRL_NETWORK_LOCAL &&
  455. GetRaceXApp()->m_bIsMultiplayer == TRUE &&
  456. !GetRaceXApp()->GetMultiplayer()->IsHosting() )
  457. {
  458. m_bRemoteKeyboardStatus = 0;
  460. //从远端读取键盘状态值
  461. if(pKeyboard.CheckKey(DIK_RIGHT))
  462. {
  463. m_bRemoteKeyboardStatus |= 0x01;
  464. }
  466. if(pKeyboard.CheckKey(DIK_LEFT))
  467. {
  468. m_bRemoteKeyboardStatus |= 0x02;
  469. }
  471. if(pKeyboard.CheckKey(DIK_DOWN))
  472. {
  473. m_bRemoteKeyboardStatus |= 0x04;
  474. }
  476. if(pKeyboard.CheckKey(DIK_UP))
  477. {
  478. m_bRemoteKeyboardStatus |= 0x08;
  479. }
  481. if(GetRaceXApp()->m_bSendKeyboard == TRUE || GetTickCount()-lLastMessage > 100)
  482. {
  483. GetRaceXApp()->GetMultiplayer()->SendTo(GetRaceXApp()->GetMultiplayer()->GetHost(), MSG_KEYBOARD_STATUS, &m_bRemoteKeyboardStatus, 1, 0/*DPNSEND_SYNC*/);
  484. GetRaceXApp()->m_bSendKeyboard = FALSE;
  485. lLastMessage = GetTickCount();
  486. }
  487. }
  489. if((GetRaceXApp()->m_bIsMultiplayer==TRUE&&GetRaceXApp()->GetMultiplayer()->IsHosting())||
  490. GetRaceXApp()->m_bIsMultiplayer == FALSE)
  491. {
  492. //处理完用户/电脑/网络输入后，重新定位赛车位置
  493. m_fPosY = m_fPosY + ((float)m_fDirectionY / 9.0f) * ((float)m_iSpeed / _SPEED_FACTOR_);
  494. m_fPosX = m_fPosX + ((float)m_fDirectionX / 9.0f) * ((float)m_iSpeed / _SPEED_FACTOR_);
  496. // Track control goes here
  497. // Check if we are passing throught a checkpoint or how far we are from thw
  498. // next check point
  499. if(m_iCarState == CARSTATE_OK)
  500. {
  501. if(m_iCheckPoint == -1)
  502. {
  503. if(theTrack->GetCheckPoint((int)m_fPosX+10,(int) m_fPosY+18) == 1)
  504. {
  505. m_iCheckPoint = 1;
  506. m_lCurrentTime = GetTickCount();
  508. iX = 0;
  509. iY = 0;
  510. m_iDistanceToNextCheckPoint = 999999999;
  511. do
  512. {
  513. iX = iX / 40;
  514. iY = iY / 40;
  515. theTrack->GetCheckPointPosition(&iX, &iY, m_iCheckPoint+1);
  516. if(m_iDistanceToNextCheckPoint > (int) sqrt( ((m_fPosX - iX)*(m_fPosX - iX)) + ((m_fPosY - iY)*(m_fPosY - iY)) ))
  517. {
  518. m_iDistanceToNextCheckPoint = (int) sqrt( ((m_fPosX - iX)*(m_fPosX - iX)) + ((m_fPosY - iY)*(m_fPosY - iY)));
  519. }
  520. if(iX != -1)
  521. iX += 40;
  522. }while(iX>0);
  523. }
  524. }
  525. else
  526. {
  527. if(theTrack->GetCheckPoint((int)m_fPosX+10, (int)m_fPosY+18) <= m_iCheckPoint)
  528. {
  529. if(theTrack->GetCheckPoint((int)m_fPosX+10, (int)m_fPosY+18) == 1 &&
  530.    m_iCheckPoint == theTrack->GetMaxCheckPoint())
  531. {
  532. m_vcLapTimes.push_back(GetTickCount()-m_lCurrentTime);
  533. m_lCurrentTime = GetTickCount();
  535. m_iCheckPoint = 1;
  537. iX = 0;
  538. iY = 0;
  539. m_iDistanceToNextCheckPoint = 999999999;
  540. do
  541. {
  542. iX = iX / 40;
  543. iY = iY / 40;
  544. theTrack->GetCheckPointPosition(&iX, &iY, m_iCheckPoint+1);
  545. if(m_iDistanceToNextCheckPoint > (int) sqrt( ((m_fPosX - iX)*(m_fPosX - iX)) + ((m_fPosY - iY)*(m_fPosY - iY)) ))
  546. {
  547. m_iDistanceToNextCheckPoint = (int) sqrt( ((m_fPosX - iX)*(m_fPosX - iX)) + ((m_fPosY - iY)*(m_fPosY - iY)));
  548. }
  550. if(iX != -1)
  551. iX += 40;
  553. }while(iX>0);
  554. m_iLaps++;
  555. if(m_iLaps == theTrack->GetNumberOfLaps())
  556. {
  557. m_iCarState = CARSTATE_RACECOMPLETED;
  558. }
  559. else
  560. {
  561. if(m_iControlType == CTRL_USER)
  562. theTrack->m_sndSemaphore.Play();
  563. }
  564. }
  565. else
  566. {
  567. iX = 0;
  568. iY = 0;
  569. m_iDistanceToNextCheckPoint = 999999999;
  570. do
  571. {
  572. iX = iX / 40;
  573. iY = iY / 40;
  574. theTrack->GetCheckPointPosition(&iX, &iY, m_iCheckPoint+1);
  575. if(m_iDistanceToNextCheckPoint > (int) sqrt( ((m_fPosX - iX)*(m_fPosX - iX)) + ((m_fPosY - iY)*(m_fPosY - iY)) ))
  576. {
  577. m_iDistanceToNextCheckPoint = (int) sqrt( ((m_fPosX - iX)*(m_fPosX - iX)) + ((m_fPosY - iY)*(m_fPosY - iY)));
  578. }
  579. if(iX != -1)
  580. iX += 40;
  581. }while(iX>0);
  582. }
  583. }
  584. else
  585. {
  586. if(theTrack->GetCheckPoint((int)m_fPosX+10, (int)m_fPosY+18) == m_iCheckPoint+1)
  587. {
  588. m_iCheckPoint++;
  589. iX = 0;
  590. iY = 0;
  591. m_iDistanceToNextCheckPoint = 999999999;
  592. do
  593. {
  594. iX = iX / 40;
  595. iY = iY / 40;
  596. theTrack->GetCheckPointPosition(&iX, &iY, m_iCheckPoint+1);
  597. if(m_iDistanceToNextCheckPoint > (int) sqrt( ((m_fPosX - iX)*(m_fPosX - iX)) + ((m_fPosY - iY)*(m_fPosY - iY)) ))
  598. {
  599. m_iDistanceToNextCheckPoint = (int) sqrt( ((m_fPosX - iX)*(m_fPosX - iX)) + ((m_fPosY - iY)*(m_fPosY - iY)));
  600. }
  601. if(iX != -1)
  602. iX += 40;
  604. }while(iX>0);
  606. m_fBackupDirectionX = m_fDirectionX;
  607. m_iBackupDistanceToNextCheckPoint = m_iDistanceToNextCheckPoint;
  608. m_fBackupDirectionY = m_fDirectionY;
  609. m_fBackupIncrementX = m_fIncrementX;
  610. m_fBackupIncrementY = m_fIncrementY;
  611. m_iBackupAngle = m_iAngle;
  612. m_fBackupPosX = m_fPosX;
  613. m_fBackupPosY = m_fPosY;
  614. m_iBackupSprite = m_sprCar.m_iAbsolutePosition;
  615. iBackupTurnCar = iTurnCar;
  616. }
  617. else
  618. {
  619. iX = 0;
  620. iY = 0;
  621. m_iDistanceToNextCheckPoint = 999999999;
  622. do
  623. {
  624. iX = iX / 40;
  625. iY = iY / 40;
  626. theTrack->GetCheckPointPosition(&iX, &iY, m_iCheckPoint+1);
  627. if(m_iDistanceToNextCheckPoint > (int) sqrt( ((m_fPosX - iX)*(m_fPosX - iX)) + ((m_fPosY - iY)*(m_fPosY - iY)) ))
  628. {
  629. m_iDistanceToNextCheckPoint = (int) sqrt( ((m_fPosX - iX)*(m_fPosX - iX)) + ((m_fPosY - iY)*(m_fPosY - iY)));
  630. }
  632. if(iX != -1)
  633. iX += 40;
  635. }while(iX>0);
  636. }
  638. }
  639. }
  640. }
  641. }
  642. if(m_iControlType != CTRL_USER && m_iControlType != CTRL_NETWORK_LOCAL)
  643. {
  644. m_pSound.SetPosition(m_fPosX/200.0f, m_fPosY/200.0f, 0.0f);
  645. m_pCrashSound.SetPosition(m_fPosX/200.0f, m_fPosY/200.0f, 0.0f);
  646. //m_pSound.SetVelocity((float)m_iSpeed/27,(float)m_iSpeed/27, 0.0f);
  647. }
  649. DWORD dwFreq = 0;
  650. if(GetSpeed() != 0)
  651. {
  652. m_pSound.Play(0, DSBPLAY_LOOPING);
  653. dwFreq = 22050 + (GetSpeed() * 50);
  654. m_pSound.m_pSoundBuffer->SetFrequency(dwFreq);
  655. }
  656. else
  657. {
  658. m_pSound.Stop();
  659. }
  661. if(m_iControlType == CTRL_USER || m_iControlType == CTRL_NETWORK_LOCAL)
  662. {
  663. cSoundInterface pSInterface;
  665. pSInterface.SetListernerPosition( m_fPosX/200.0f, (m_fPosY/200.0f), 0.0f);
  667. }
  669. }
  671. void cRaceCar::GetPos(int *iX, int *iY)
  672. {
  673. *iX = (int) m_fPosX;
  674. *iY = (int) m_fPosY;
  675. }
  677. void cRaceCar::RotateBound(int iAngle)
  678. {
  679. #define PI 3.141592654f
  681. m_hcRaceCar.Destroy();
  683. POINT *pFirstPoint;
  684. POINT *pPoints;
  687. pPoints = (POINT*) malloc(CARBOUND_POINTS * sizeof(POINT));
  689. memcpy(pPoints, m_pBound,  CARBOUND_POINTS * sizeof(POINT));
  691. pFirstPoint = pPoints;
  692. // Move the vertices so that we made the center of the car the 0,0 axis
  693. for(int i=0;i<CARBOUND_POINTS;i++)
  694. {
  695. pPoints->x = pPoints->x - 19;
  696. pPoints->y = pPoints->y - 18;
  697. pPoints++;
  698. }
  701. // Rotate the points
  702. pPoints = pFirstPoint;
  703. for(i=0;i<CARBOUND_POINTS;i++)
  704. {
  705. double x,y;
  707. x = (cos(PI * (double)iAngle / 180.0) * (double)pPoints->x - sin(PI * (double)iAngle / 180.0) * (double) pPoints->y);
  708. y = (sin(PI * (double)iAngle / 180.0) * (double)pPoints->x + cos(PI * (double)iAngle / 180.0) * (double) pPoints->y);
  710. //x+=0.5;
  711. //y+=0.5;
  713. pPoints->x = (int)x;
  714. pPoints->y = (int)y;
  716. pPoints++;
  717. }
  719. pPoints = pFirstPoint;
  720. // Move the vertices back to the correct position
  721. for(i=0;i<CARBOUND_POINTS;i++)
  722. {
  723. pPoints->x = pPoints->x + 19;
  724. pPoints->y = pPoints->y + 18;
  725. pPoints++;
  726. }
  728. // Restore the original pointer
  729. pPoints = pFirstPoint;
  731. m_hcRaceCar.CreatePolygonBound(pPoints, CARBOUND_POINTS);
  733. free(pPoints);
  734. }
  736. void cRaceCar::SetLastCheckPoint(int iLastCheckPoint)
  737. {
  738. m_iCheckPoint = iLastCheckPoint;
  739. }
  741. int cRaceCar::GetLastCheckPoint()
  742. {
  743. return m_iCheckPoint;
  744. }
  746. int cRaceCar::GetSpeed()
  747. {
  748. return m_iSpeed;
  749. }
  751. void cRaceCar::SetControlType(int iType)
  752. {
  753. m_iControlType = iType;
  754. if(m_iControlType == CTRL_USER || m_iControlType == CTRL_NETWORK_LOCAL)
  755. {
  756. m_pSound.Create(MAKEINTRESOURCE(IDR_ENGINE), DSBCAPS_CTRLFREQUENCY, DS3DALG_DEFAULT);
  757. m_pCrashSound.Create(MAKEINTRESOURCE(IDR_EXPLODE), DSBCAPS_CTRLFREQUENCY, DS3DALG_DEFAULT);
  758. }
  759. }
  761. int cRaceCar::GetControlType()
  762. {
  763. return m_iControlType;
  764. }
  766. void cRaceCar::TurnCarLeft()
  767. {
  768. if(GetTickCount() - m_lLastTurn > TURN_TIME)
  769. {
  770. if(m_fDirectionY == 9)
  771. {
  772. m_fIncrementY = 1;
  773. }
  775. if(m_fDirectionY == -9)
  776. {
  777. m_fIncrementY = -1;
  778. }
  780. if(m_fDirectionX == 9)
  781. {
  782. m_fIncrementX = 1;
  783. }
  785. if(m_fDirectionX == -9)
  786. {
  787. m_fIncrementX = -1;
  788. }
  790. m_fDirectionX -= m_fIncrementX;
  791. m_fDirectionY -= m_fIncrementY;
  793. m_sprCar.Previous();
  795. m_iAngle -= 10;
  797. if(m_iAngle < 0)
  798. m_iAngle = 360 + m_iAngle;
  800. RotateBound(m_iAngle);
  801. m_lLastTurn = GetTickCount();
  803. }
  804. }
  806. void cRaceCar::TurnCarRight()
  807. {
  808. if(GetTickCount() - m_lLastTurn > TURN_TIME)
  809. {
  810. if(m_fDirectionY == 9)
  811. {
  812. m_fIncrementY = -1;
  813. }
  814. if(m_fDirectionY == -9)
  815. {
  816. m_fIncrementY = 1;
  817. }
  818. if(m_fDirectionX == 9)
  819. {
  820. m_fIncrementX = -1;
  821. }
  822. if(m_fDirectionX == -9)
  823. {
  824. m_fIncrementX = 1;
  825. }
  826. m_fDirectionX += m_fIncrementX;
  827. m_fDirectionY += m_fIncrementY;
  829. m_sprCar.Next();
  831. m_iAngle += 10;
  832. if(m_iAngle >= 360)
  833. m_iAngle = (m_iAngle - 360);
  834. RotateBound(m_iAngle);
  835. m_lLastTurn = GetTickCount();
  836. }
  837. }
  839. void cRaceCar::Accelerate()
  840. {
  841. // If its time to accelerate
  842. if(GetTickCount() - m_lLastSpeedIncr > (UINT)RAISESPEED_TIME )
  843. {
  844. m_iSpeed=m_iSpeed+5;
  845. // If the car is controlled by the computer and the level is above hard, make
  846. // the cars accelerate faster
  847. if(GetRaceXApp()->GetDifficultyLevel() > 40 && m_iControlType == CTRL_COMPUTER )
  848. {
  849. m_iSpeed += ((GetRaceXApp()->GetDifficultyLevel()-50)/10);
  850. }
  852. // If we haven磘 rechead the maximum speed, raise it up
  853. if(m_iSpeed > m_iMaxSpeed - (m_iControlType == CTRL_COMPUTER ? 40 - GetRaceXApp()->GetDifficultyLevel(): 0) )
  854. {
  855. m_iSpeed = m_iMaxSpeed - (m_iControlType == CTRL_COMPUTER ? 40 - GetRaceXApp()->GetDifficultyLevel() : 0);
  856. }
  857. m_lLastSpeedIncr = GetTickCount();
  858. }
  859. }
  861. void cRaceCar::HitCar()
  862. {
  863. // Car hitted something
  864. // Apply heat behavior in car (decrease speed and maintain angle)
  865. m_iSpeed=m_iSpeed-40;
  866. m_lLastSpeedIncr = GetTickCount();
  867. if(m_iSpeed < 0)
  868. {
  869. m_iSpeed = 0;
  870. }
  871. }
  873. void cRaceCar::BreakCar()
  874. {
  875. // Break car
  876. if(GetTickCount() - m_lLastSpeedIncr > (UINT)RAISESPEED_TIME )
  877. {
  878. m_iSpeed=m_iSpeed-20;
  880. if(m_iSpeed < 0)
  881. {
  882. m_iSpeed = 0;
  883. }
  884. m_lLastSpeedIncr = GetTickCount();
  885. }
  886. }
  888. void cRaceCar::Idle()
  889. {
  890. // User is not pressing anything
  891. if(GetTickCount() - m_lLastSpeedIncr > (UINT)RAISESPEED_TIME )
  892. {
  893. m_iSpeed=m_iSpeed-5;
  894. if(m_iSpeed < 0)
  895. {
  896. m_iSpeed = 0;
  897. }
  898. m_lLastSpeedIncr = GetTickCount();
  899. }
  900. }
  902. void cRaceCar::SetCarState(int iState)
  903. {
  904. m_iCarState = iState;
  906. // If we set the car to the crash state, we should
  907. // load the crash tiles, depending on the car color
  908. if(m_iCarState == CARSTATE_CRASHED_WALL)
  909. {
  910. switch(m_iColor)
  911. {
  912. case IDB_CAR_GREEN:
  913. if(m_iAngle == 0)
  914. m_sprCarExplode_0.Create(GetMainApp()->m_hInst, IDB_EXPLODE_0_GREEN, 320, 200, RGB(0,0,0), 40, 40);
  915. if(m_iAngle > 0 && m_iAngle < 90)
  916. m_sprCarExplode_45.Create(GetMainApp()->m_hInst, IDB_EXPLODE_45_GREEN, 320, 200, RGB(0,0,0), 40, 40);
  917. if(m_iAngle == 90)
  918. m_sprCarExplode_90.Create(GetMainApp()->m_hInst, IDB_EXPLODE_90_GREEN, 320, 200, RGB(0,0,0), 40, 40);
  919. if(m_iAngle > 90 && m_iAngle < 180)
  920. m_sprCarExplode_135.Create(GetMainApp()->m_hInst, IDB_EXPLODE_135_GREEN, 320, 200, RGB(0,0,0), 40, 40);
  921. if(m_iAngle == 180)
  922. m_sprCarExplode_180.Create(GetMainApp()->m_hInst, IDB_EXPLODE_180_GREEN, 320, 200, RGB(0,0,0), 40, 40);
  923. if(m_iAngle > 180 && m_iAngle < 270)
  924. m_sprCarExplode_225.Create(GetMainApp()->m_hInst, IDB_EXPLODE_225_GREEN, 320, 200, RGB(0,0,0), 40, 40);
  925. if(m_iAngle == 270)
  926. m_sprCarExplode_270.Create(GetMainApp()->m_hInst, IDB_EXPLODE_270_GREEN, 320, 200, RGB(0,0,0), 40, 40);
  927. if(m_iAngle > 270 && m_iAngle < 360)
  928. m_sprCarExplode_315.Create(GetMainApp()->m_hInst, IDB_EXPLODE_315_GREEN, 320, 200, RGB(0,0,0), 40, 40);
  929. break;
  930. case IDB_CAR_RED:
  931. if(m_iAngle == 0)
  932. m_sprCarExplode_0.Create(GetMainApp()->m_hInst, IDB_EXPLODE_0_RED, 320, 200, RGB(0,0,0), 40, 40);
  933. if(m_iAngle > 0 && m_iAngle < 90)
  934. m_sprCarExplode_45.Create(GetMainApp()->m_hInst, IDB_EXPLODE_45_RED, 320, 200, RGB(0,0,0), 40, 40);
  935. if(m_iAngle == 90)
  936. m_sprCarExplode_90.Create(GetMainApp()->m_hInst, IDB_EXPLODE_90_RED, 320, 200, RGB(0,0,0), 40, 40);
  937. if(m_iAngle > 90 && m_iAngle < 180)
  938. m_sprCarExplode_135.Create(GetMainApp()->m_hInst, IDB_EXPLODE_135_RED, 320, 200, RGB(0,0,0), 40, 40);
  939. if(m_iAngle == 180)
  940. m_sprCarExplode_180.Create(GetMainApp()->m_hInst, IDB_EXPLODE_180_RED, 320, 200, RGB(0,0,0), 40, 40);
  941. if(m_iAngle > 180 && m_iAngle < 270)
  942. m_sprCarExplode_225.Create(GetMainApp()->m_hInst, IDB_EXPLODE_225_RED, 320, 200, RGB(0,0,0), 40, 40);
  943. if(m_iAngle == 270)
  944. m_sprCarExplode_270.Create(GetMainApp()->m_hInst, IDB_EXPLODE_270_RED, 320, 200, RGB(0,0,0), 40, 40);
  945. if(m_iAngle > 270 && m_iAngle < 360)
  946. m_sprCarExplode_315.Create(GetMainApp()->m_hInst, IDB_EXPLODE_315_RED, 320, 200, RGB(0,0,0), 40, 40);
  947. break;
  948. case IDB_CAR_YEALLOW:
  949. if(m_iAngle == 0)
  950. m_sprCarExplode_0.Create(GetMainApp()->m_hInst, IDB_EXPLODE_0_YEALLOW, 320, 200, RGB(0,0,0), 40, 40);
  951. if(m_iAngle > 0 && m_iAngle < 90)
  952. m_sprCarExplode_45.Create(GetMainApp()->m_hInst, IDB_EXPLODE_45_YEALLOW, 320, 200, RGB(0,0,0), 40, 40);
  953. if(m_iAngle == 90)
  954. m_sprCarExplode_90.Create(GetMainApp()->m_hInst, IDB_EXPLODE_90_YEALLOW, 320, 200, RGB(0,0,0), 40, 40);
  955. if(m_iAngle > 90 && m_iAngle < 180)
  956. m_sprCarExplode_135.Create(GetMainApp()->m_hInst, IDB_EXPLODE_135_YEALLOW, 320, 200, RGB(0,0,0), 40, 40);
  957. if(m_iAngle == 180)
  958. m_sprCarExplode_180.Create(GetMainApp()->m_hInst, IDB_EXPLODE_180_YEALLOW, 320, 200, RGB(0,0,0), 40, 40);
  959. if(m_iAngle > 180 && m_iAngle < 270)
  960. m_sprCarExplode_225.Create(GetMainApp()->m_hInst, IDB_EXPLODE_225_YEALLOW, 320, 200, RGB(0,0,0), 40, 40);
  961. if(m_iAngle == 270)
  962. m_sprCarExplode_270.Create(GetMainApp()->m_hInst, IDB_EXPLODE_270_YEALLOW, 320, 200, RGB(0,0,0), 40, 40);
  963. if(m_iAngle > 270 && m_iAngle < 360)
  964. m_sprCarExplode_315.Create(GetMainApp()->m_hInst, IDB_EXPLODE_315_YEALLOW, 320, 200, RGB(0,0,0), 40, 40);
  965. break;
  966. case IDB_CAR_BLUE:
  967. if(m_iAngle == 0)
  968. m_sprCarExplode_0.Create(GetMainApp()->m_hInst, IDB_EXPLODE_0_BLUE, 320, 200, RGB(0,0,0), 40, 40);
  969. if(m_iAngle > 0 && m_iAngle < 90)
  970. m_sprCarExplode_45.Create(GetMainApp()->m_hInst, IDB_EXPLODE_45_BLUE, 320, 200, RGB(0,0,0), 40, 40);
  971. if(m_iAngle == 90)
  972. m_sprCarExplode_90.Create(GetMainApp()->m_hInst, IDB_EXPLODE_90_BLUE, 320, 200, RGB(0,0,0), 40, 40);
  973. if(m_iAngle > 90 && m_iAngle < 180)
  974. m_sprCarExplode_135.Create(GetMainApp()->m_hInst, IDB_EXPLODE_135_BLUE, 320, 200, RGB(0,0,0), 40, 40);
  975. if(m_iAngle == 180)
  976. m_sprCarExplode_180.Create(GetMainApp()->m_hInst, IDB_EXPLODE_180_BLUE, 320, 200, RGB(0,0,0), 40, 40);
  977. if(m_iAngle > 180 && m_iAngle < 270)
  978. m_sprCarExplode_225.Create(GetMainApp()->m_hInst, IDB_EXPLODE_225_BLUE, 320, 200, RGB(0,0,0), 40, 40);
  979. if(m_iAngle == 270)
  980. m_sprCarExplode_270.Create(GetMainApp()->m_hInst, IDB_EXPLODE_270_BLUE, 320, 200, RGB(0,0,0), 40, 40);
  981. if(m_iAngle > 270 && m_iAngle < 360)
  982. m_sprCarExplode_315.Create(GetMainApp()->m_hInst, IDB_EXPLODE_315_BLUE, 320, 200, RGB(0,0,0), 40, 40);
  983. break;
  984. }
  985. }
  986. }
  988. int cRaceCar::GetCarState()
  989. {
  990. return m_iCarState;
  991. }
  993. void cRaceCar::Crashed()
  994. {
  995. // Car Crashed
  996. if(GetTickCount() - m_lLastSpeedIncr > (UINT)RAISESPEED_TIME )
  997. {
  998. if(m_iSpeed > 180)
  999. m_iSpeed=m_iSpeed-50;
  1000. else
  1001. m_iSpeed=m_iSpeed-25;
  1003. if(m_iSpeed < 0)
  1004. {
  1005. m_iSpeed = 0;
  1006. }
  1007. m_lLastSpeedIncr = GetTickCount();
  1008. }
  1009. }
  1011. int cRaceCar::GetPosition()
  1012. {
  1013. return m_iPosition;
  1014. }
  1016. void cRaceCar::SetPosition(int iPosition)
  1017. {
  1018. m_iPosition = iPosition;
  1019. }
  1021. int cRaceCar::GetDistanceToNextCheckPoint()
  1022. {
  1023. return m_iDistanceToNextCheckPoint;
  1024. }
  1026. long cRaceCar::GetLapElapseTime(int iLap)
  1027. {
  1028. // Return the elapse time of the lap
  1029. if(iLap == -1)
  1030. {
  1031. if(m_lCurrentTime == 0 && m_iControlType != CTRL_NETWORK_LOCAL)
  1032. return 0;
  1033. else
  1034. {
  1035. if(m_iControlType == CTRL_NETWORK_LOCAL)
  1036. return m_dwElapseTime;
  1037. else
  1038. return GetTickCount()-m_lCurrentTime;
  1039. }
  1040. }
  1041. else
  1042. return m_vcLapTimes[iLap];
  1043. }
  1045. long cRaceCar::GetLastLapTime()
  1046. {
  1047. if(m_vcLapTimes.size() == 0)
  1048. return 0;
  1049. else
  1050. return m_vcLapTimes[m_vcLapTimes.size()-1];
  1051. }
  1053. int cRaceCar::GetCarColor()
  1054. {
  1055. return m_iColor;
  1056. }
  1058. void cRaceCar::SetID(BYTE iValue)
  1059. {
  1060. m_bID = iValue;
  1061. }
  1063. BYTE cRaceCar::GetID()
  1064. {
  1065. return m_bID;
  1066. }
  1068. void cRaceCar::SetSpeed(int iValue)
  1069. {
  1070. m_iSpeed = iValue;
  1071. }
  1073. void cRaceCar::AddLapTime(DWORD dwTime)
  1074. {
  1075. m_vcLapTimes.push_back(dwTime);
  1076. }
  1078. void cRaceCar::Backup()
  1079. {
  1080. // Backup all the current state of the car
  1081. m_fBackupDirectionX = m_fDirectionX;
  1082. m_iBackupDistanceToNextCheckPoint = m_iDistanceToNextCheckPoint;
  1083. m_fBackupDirectionY = m_fDirectionY;
  1084. m_fBackupIncrementX = m_fIncrementX;
  1085. m_fBackupIncrementY = m_fIncrementY;
  1086. m_iBackupAngle = m_iAngle;
  1087. m_fBackupPosX = m_fPosX;
  1088. m_fBackupPosY = m_fPosY;
  1089. m_iBackupSprite = m_sprCar.m_iAbsolutePosition;
  1090. iBackupTurnCar = iTurnCar;
  1091. RotateBound(m_iAngle);
  1092. }
  1094. void cRaceCar::MoveForward(int iSpeed)
  1095. {
  1096. // Move the car forward, using an alternate speed
  1097. // Used when someone hits your car
  1098. m_fPosY = m_fPosY + ((float)m_fDirectionY / 9.0f) * ((float)iSpeed / _SPEED_FACTOR_);
  1099. m_fPosX = m_fPosX + ((float)m_fDirectionX / 9.0f) * ((float)iSpeed / _SPEED_FACTOR_);
  1100. }