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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DirextX编程 > 查看源码
DXIsoMap.cpp
资源名称：IsoTest_src.zip　[点击查看]
上传用户：pfmy85
上传日期：2007-01-07
资源大小：22k
文件大小：16k
源码类别：

DirextX编程

开发平台：

Visual C++

DXIsoMap.cpp：源码内容
  1. // DXIsoMap.cpp: implementation of the CDXIsoMap class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "DXIsoMap.h"
  7. #include "DDDevice.h"
  9. #include "DDDIBSurface.h"
  11. #include "PackFile.h"
  12. #include "IsoType.h"
  13. //#include "stdafx.h"
  14. //#include "Isotest.h"
  16. #ifdef _DEBUG
  17. #undef THIS_FILE
  18. static char THIS_FILE[]=__FILE__;
  19. #define new DEBUG_NEW
  20. #endif
  22. const CHAR CDXIsoMap::m_CellFigue[16][32] = 
  23. {
  24. {1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2},
  25. {1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2},
  26. {1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2},
  27. {1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2},
  28. {1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2},
  29. {1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2},
  30. {1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2},
  31. {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  32. {3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,4},
  33. {3,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,4,4},
  34. {3,3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,4,4,4,4},
  35. {3,3,3,3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,4,4,4,4,4,4,4},
  36. {3,3,3,3,3,3,3,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0,4,4,4,4,4,4,4,4,4,4},
  37. {3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,0,0,0,0,0,4,4,4,4,4,4,4,4,4,4,4,4},
  38. {3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,0,4,4,4,4,4,4,4,4,4,4,4,4,4,4},
  39. {3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4}
  40. };
  42. const int CDXIsoMap::m_nCellWidth = 32;
  43. const int CDXIsoMap::m_nCellHeight = 16;
  45. const int CDXIsoMap::m_nCellWidthShift = 5;
  46. const int CDXIsoMap::m_nCellHeightShift = 4;
  48. const BYTE CDXIsoMap::m_CellIdxFlg = 0x10;
  49. const BYTE CDXIsoMap::m_CellRmrFlg = 0X20;
  50. const BYTE CDXIsoMap::m_CellNpcFlg = 0x40;
  51. const BYTE CDXIsoMap::m_CellLnkFlg = 0x80;
  52. //////////////////////////////////////////////////////////////////////
  53. // Construction/Destruction
  54. //////////////////////////////////////////////////////////////////////
  56. CDXIsoMap::CDXIsoMap()
  57. {
  58. m_bAutoDelete = false;
  60. m_pMapData = NULL;
  61. m_nPosX = 0;
  62. m_nPosY = 0;
  63. m_nPosTX = 0;
  64. m_nPosTY = 0;
  65. m_nOffX = 0;
  66. m_nOffY = 0;
  68. m_pPassValues = NULL;
  70. m_pTiles = NULL;
  71. }
  73. CDXIsoMap::~CDXIsoMap()
  74. {
  75. if (m_pPassValues != NULL)
  76. {
  77. delete  []m_pPassValues;
  78. m_pPassValues = NULL;
  79. }
  81. if (m_pMapData != NULL)
  82. {
  83. delete  []m_pMapData;
  84. m_pMapData = NULL;
  85. }
  87. if (m_bAutoDelete == true)
  88. {
  89. if (m_pTiles != NULL)
  90. {
  91. delete  m_pTiles;
  92. }
  93. }
  95. m_pTiles = NULL;
  96. }
  98. bool CDXIsoMap::Create(CDDSurface* pTiles,
  99. LPCTSTR lpszFileName,
  100. CPackFileManager* pPackFileManager/* = NULL*/)
  101. {
  102. ASSERT(pTiles != NULL);
  103. ASSERT(lpszFileName != NULL);
  105. int nCellColumns;
  106. int nCellRows;
  107. CELL* pMapData = NULL;
  108. if (pPackFileManager != NULL) // use CPackFile
  109. {
  110. CPackFile packFile;
  111. if (packFile.Open(pPackFileManager, lpszFileName) == false)
  112. return  false;
  114. packFile.Read(&nCellColumns, sizeof(int));
  115. packFile.Read(&nCellRows, sizeof(int));
  117. int nSize = nCellColumns * nCellRows;
  118. pMapData = new  CELL[nSize];
  119. ASSERT(pMapData != NULL);
  121. packFile.Read(pMapData, sizeof(CELL) * nSize);
  122. }
  123. else
  124. {
  125. HANDLE fh = ::CreateFile(lpszFileName, GENERIC_READ,
  126. FILE_SHARE_READ, (LPSECURITY_ATTRIBUTES)NULL, OPEN_EXISTING,
  127. FILE_ATTRIBUTE_NORMAL, NULL);
  128. if (fh == INVALID_HANDLE_VALUE)
  129. return  false;
  131. DWORD dwRead;
  132. ::ReadFile(fh, &nCellColumns, sizeof(int), &dwRead, NULL);
  133. ::ReadFile(fh, &nCellRows, sizeof(int), &dwRead, NULL);
  135. int nSize = nCellColumns * nCellRows;
  136. pMapData = new  CELL[nSize];
  137. ASSERT(pMapData != NULL);
  139. ::ReadFile(fh, pMapData, sizeof(CELL) * nSize, &dwRead, NULL);
  140. ::CloseHandle(fh);
  141. }
  143. return  Create(pTiles,
  144. nCellColumns, nCellRows,
  145. pMapData);
  146. }
  148. bool CDXIsoMap::Save(LPCTSTR lpszFileName)
  149. {
  150. HANDLE fh = ::CreateFile(lpszFileName, GENERIC_WRITE,
  151. 0, (LPSECURITY_ATTRIBUTES)NULL, CREATE_ALWAYS,
  152.           FILE_ATTRIBUTE_NORMAL, NULL);
  153. if (fh == INVALID_HANDLE_VALUE)
  154. return  false;
  156. DWORD dwWriteBytes;
  157. ::WriteFile(fh, &m_nColumns, sizeof(int), &dwWriteBytes, NULL);
  158. ::WriteFile(fh, &m_nRows, sizeof(int), &dwWriteBytes, NULL);
  159. ::WriteFile(fh, m_pMapData, sizeof(int) * m_nColumns * m_nRows, &dwWriteBytes, NULL);
  160. ::CloseHandle(fh);
  161. return  true;
  162. }
  164. bool CDXIsoMap::Create(CDDSurface*  pTiles,
  165. int  nCellColumns, int  nCellRows,
  166. CELL* pMapData)
  167. {
  168. m_pTiles = pTiles;
  170. m_nPosX = m_nCellWidth >> 1;
  171. m_nPosY = m_nCellHeight >> 1;
  173. m_nColumns = nCellColumns;
  174. m_nRows = nCellRows;
  176. m_nTotalWidth = m_nColumns << (m_nCellWidthShift - 1);
  177. m_nTotalHeight = m_nRows << m_nCellHeightShift;
  179. ASSERT(m_pMapData == NULL);
  180. m_pMapData = pMapData;
  182. m_nSrcSurfaceCellRows = (m_pTiles->GetWidth() / m_nCellWidth);
  184. return  true;
  185. }
  187. bool CDXIsoMap::Create(CDDSurface*  pTiles,
  188. int  nCellColumns, int  nCellRows, int  nFill)
  189. {
  190. int nSize = nCellColumns * nCellRows;
  191. CELL* pMapData = new  CELL[nSize];
  192. ASSERT(pMapData != NULL);
  194. for (int  i = 0; i < nSize; ++ i)
  195. {
  196. pMapData[i].base.index = (BYTE)nFill;
  197. if (nFill & 0X100)
  198. pMapData[i].base.flag = m_CellIdxFlg;
  199. else pMapData[i].base.flag = 0;
  201. pMapData[i].fringe.index = 0;
  202. pMapData[i].fringe.flag = 0;
  203. }
  205. return  Create(pTiles,
  206. nCellColumns, nCellRows,
  207. pMapData);
  208. }
  210. // 在屏幕的(nDestX, nDestY)位置画图块
  211. // IN:
  212. // nDestX
  213. // nDestY: 屏幕坐标
  214. void CDXIsoMap::BltTile(CDDSurface*  pDestSurface,
  215. int nDestX, int nDestY, CELL* pCell)
  216. {
  217. RECT drc, drc0;
  218. drc.left = nDestX;
  219. drc.top = nDestY;
  220. drc.right = nDestX + m_nCellWidth;
  221. drc.bottom = nDestY + m_nCellHeight;
  223. if (IntersectRect(&drc0, &drc, &m_rcDest))
  224. {
  225. int nOffY = drc0.top - drc.top;
  226. int nOffX = drc0.left - drc.left;
  227. int nW = drc0.right - drc0.left;
  228. int nH = drc0.bottom - drc0.top;
  229. int nTileIndex = pCell->base.index;
  230. if (pCell->base.flag & m_CellIdxFlg)
  231. nTileIndex += 0x100;
  232. int x1, y1;
  233. RECT src;
  234. if (nTileIndex)
  235. {
  236. x1 = (nTileIndex % m_nSrcSurfaceCellRows) << m_nCellWidthShift;
  237. y1 = (nTileIndex / m_nSrcSurfaceCellRows) << m_nCellHeightShift;
  239. src.top = y1 + nOffY;
  240. src.left = x1 + nOffX;
  241. src.bottom = src.top + nH;
  242. src.right = src.left + nW;
  244. m_pTiles->Draw(pDestSurface, drc0.left, drc0.top, &src);
  245. }
  247. nTileIndex = pCell->fringe.index;
  248. if (pCell->fringe.flag & m_CellIdxFlg)
  249. nTileIndex += 0x100;
  250. if (nTileIndex)
  251. {
  252. x1 = (nTileIndex % m_nSrcSurfaceCellRows) << m_nCellWidthShift;
  253. y1 = (nTileIndex / m_nSrcSurfaceCellRows) << m_nCellHeightShift;
  255. src.top = y1 + nOffY;
  256. src.left = x1 + nOffX;
  257. src.bottom = src.top + nH;
  258. src.right = src.left + nW;
  260. m_pTiles->Draw(pDestSurface, drc0.left, drc0.top, &src);
  261. }
  262. }
  263. }
  265. void CDXIsoMap::SetViewRect(LPRECT lprcView)
  266. {
  267. ASSERT(lprcView != NULL);
  268. m_rcDest.top = lprcView->top;
  269. m_rcDest.left = lprcView->left;
  270. m_rcDest.bottom = lprcView->bottom;
  271. m_rcDest.right = lprcView->right;
  272. }
  274. void CDXIsoMap::Draw(CDDSurface*  pDestSurface, LPRECT lprcDest)
  275. {
  276. if (lprcDest != NULL)
  277. {
  278. m_rcDest.top = lprcDest->top;
  279. m_rcDest.left = lprcDest->left;
  280. m_rcDest.bottom = lprcDest->bottom;
  281. m_rcDest.right = lprcDest->right;
  282. }
  284. int nHalfW = m_nCellWidth >> 1;
  285. int nHalfH = m_nCellHeight >> 1;
  287. int nOffsetX;
  288. int nOffsetY;
  289. if (m_nPosTX & 1)
  290. {
  291. nOffsetX = (m_nPosX-nHalfW) & (m_nCellWidth-1);
  292. nOffsetY = (m_nPosY-nHalfH) & (m_nCellHeight-1);
  293. }
  294. else
  295. {
  296. nOffsetX = m_nPosX & (m_nCellWidth-1);
  297. nOffsetY = m_nPosY & (m_nCellHeight-1);
  298. }
  299. nOffsetX = -nOffsetX;
  300. nOffsetY = -nOffsetY;
  302. int nOffTx, nOffTy;
  303. if (m_nPosTX & 1)
  304. {
  305. nOffTx = m_nPosTX - 1;
  306. nOffTy = m_nPosTY;
  307. nOffsetX = nOffsetX - nHalfW;
  308. nOffsetY = nOffsetY - nHalfH;
  309. }
  310. else
  311. {
  312. nOffTx = m_nPosTX - 2;
  313. nOffTy = m_nPosTY - 1;
  314. nOffsetX = nOffsetX - m_nCellWidth;
  315. nOffsetY = nOffsetY - m_nCellHeight;
  316. }
  319. int dy = nOffsetY+ m_rcDest.top;
  321. for (int i = nOffTy; ; i++)
  322. {
  323. if ((i>=0) && (i < m_nRows))
  324. {
  325. int dx = nOffsetX + m_rcDest.left;
  326. for (int j= nOffTx; ;)
  327. {
  328. if ((j>=0) && (j < m_nColumns))
  329. BltTile(pDestSurface, dx, dy,
  330. &(m_pMapData[i*m_nColumns+j]));
  331. j++;
  332. if ((j>=0) && (j < m_nColumns))
  333. BltTile(pDestSurface, dx+nHalfW, dy+nHalfH, 
  334. &(m_pMapData[i*m_nColumns+j]));
  335. j++;
  336. dx += m_nCellWidth;
  337. if (dx >= m_rcDest.right) break;
  338. }
  339. }
  340. dy += m_nCellHeight;
  341. if (dy >= m_rcDest.bottom) break;
  342. }
  343. }
  345. void CDXIsoMap::AbsoluteCell(int nPixelX, int nPixelY,
  346.  int &nCellX, int &nCellY,
  347.  BOOL bAbsolutePixel/*=TRUE*/)
  348. {
  349. if (bAbsolutePixel) // in map cord
  350. {
  351. nCellX = (nPixelX >> m_nCellWidthShift) << 1;
  352. nCellY = nPixelY >> m_nCellHeightShift;
  353. }
  354. else // in screen cord
  355. {
  356. nCellX = (((nPixelX-m_rcDest.left)+m_nPosX)
  357. >> m_nCellWidthShift) << 1;
  358. nCellY = ((nPixelY-m_rcDest.top)+m_nPosY) >> m_nCellHeightShift;
  359. }
  361. int nPx, nPy;
  362. if (bAbsolutePixel) // in map cord
  363. {
  364. nPx = nPixelX & (m_nCellWidth-1);
  365. nPy = nPixelY & (m_nCellHeight-1);
  366. }
  367. else // in screen cord
  368. {
  369. nPx = ((nPixelX-m_rcDest.left)+m_nPosX) & (m_nCellWidth-1);
  370. nPy = ((nPixelY-m_rcDest.top)+m_nPosY) & (m_nCellHeight-1);
  371. }
  373. switch( m_CellFigue[nPy][nPx] )
  374.     {
  375.     case 1: nCellX--; nCellY--; break;
  376. case 2: nCellX++; nCellY--; break;
  377. case 3: nCellX--; break;
  378. case 4: nCellX++; break;
  379. }
  380. }
  382. // 根据绝对图块坐标计算出象素坐标
  383. // int nCellX  绝对横向图块坐标
  384. // int nCellY  绝对纵向图块坐标
  385. // int nPixelX  横向象素坐标
  386. // int nPixelY  纵向象素坐标
  387. // BOOL bAbsolute  计算绝对象素坐标还是相对(屏幕)象素坐标
  388. void CDXIsoMap::Cell2Pixel(int nCellX, int nCellY,
  389.    int &nPixelX, int &nPixelY,
  390.    BOOL bAbsolute/*=TRUE*/)
  391. {
  392. // 先计算偶数列图块的绝对象素坐标
  393. nPixelX = (nCellX >> 1) << m_nCellWidthShift;
  394. nPixelY = nCellY << m_nCellHeightShift;
  396. // 计算图块的绝对象素坐标
  397. if (nCellX & 1)
  398. {
  399. nPixelX += (m_nCellWidth >> 1);
  400. nPixelY += (m_nCellHeight >> 1);
  401. }
  403. if (!bAbsolute)
  404. {
  405. // 计算相对(屏幕)坐标
  406. nPixelX -= m_nPosX;
  407. nPixelY -= m_nPosY;
  408. nPixelX += m_rcDest.left;
  409. nPixelY += m_rcDest.top;
  410. }
  411. }
  413. // calculate posiontion of the next adjecent cell in nDirection
  414. // nDirection:
  415. // 3 4 5
  416. // 2   6
  417. // 1 0 7
  418. void CDXIsoMap::NextCell(int &x, int &y, int nDirection)
  419. {
  420. if( x & 1)
  421.     {
  422. switch( nDirection )
  423.     {
  424. case DOWN :       y++; break;
  425. case LEFT_DOWN : x--;  y++; break;
  426. case LEFT : x-=2;   break;
  427. case LEFT_UP : x--;       break;
  428. case UP :       y--; break;
  429. case RIGHT_UP : x++;       break;
  430. case RIGHT : x+=2;      break;
  431. case RIGHT_DOWN : x++;  y++; break;
  432.     }
  433.     }
  434.     else
  435.     {
  436. switch( nDirection )
  437.      {
  438. case DOWN :       y++; break;
  439. case LEFT_DOWN : x--;    break;
  440. case LEFT : x-=2;   break;
  441. case LEFT_UP : x--;  y--; break;
  442. case UP :       y--; break;
  443. case RIGHT_UP : x++;  y--; break;
  444. case RIGHT : x+=2;      break;
  445. case RIGHT_DOWN : x++;    break;
  446.      }
  447.     }
  448. }
  450. void CDXIsoMap::MoveTo(int nPosX, int nPosY)
  451. {
  452. static int nHalfW = m_nCellWidth >> 1;
  453. static int nHalfH = m_nCellHeight >> 1;
  455. m_nPosX = nPosX;
  456. m_nPosY = nPosY;
  458. int nLeft = nHalfW;
  459. int nRight = m_nTotalWidth -
  460. (m_rcDest.right - m_rcDest.left) - nHalfW;
  461. if (m_nPosX < nLeft)
  462. m_nPosX = nLeft;
  463. if (m_nPosX > nRight)
  464. m_nPosX = nRight;
  466. int nTop = nHalfH;
  467. int nBottom = m_nTotalHeight -
  468. (m_rcDest.bottom - m_rcDest.top) - nHalfH;
  469. if (m_nPosY < nTop)
  470. m_nPosY = nTop;
  471. if (m_nPosY > nBottom)
  472. m_nPosY = nBottom;
  474. AbsoluteCell(m_nPosX, m_nPosY, m_nPosTX, m_nPosTY);
  475. }
  477. void CDXIsoMap::ScrollX(int nOffset)
  478. {
  479. static int nHalfW = m_nCellWidth >> 1;
  480. int nLeft = nHalfW;
  481. int nRight = m_nTotalWidth -
  482. (m_rcDest.right - m_rcDest.left) - nHalfW;
  483. m_nPosX += nOffset;
  484. if (m_nPosX < nLeft)
  485. m_nPosX = nLeft;
  486. if (m_nPosX > nRight)
  487. m_nPosX = nRight;
  489. AbsoluteCell(m_nPosX, m_nPosY, m_nPosTX, m_nPosTY);
  491. }
  493. void CDXIsoMap::ScrollY(int nOffset)
  494. {
  495. static int nHalfH = m_nCellHeight >> 1;
  496. int nTop = nHalfH;
  497. int nBottom = m_nTotalHeight -
  498. (m_rcDest.bottom - m_rcDest.top) - nHalfH;
  499. m_nPosY += nOffset;
  500. if (m_nPosY < nTop)
  501. m_nPosY = nTop;
  502. if (m_nPosY > nBottom)
  503. m_nPosY = nBottom;
  505. AbsoluteCell(m_nPosX, m_nPosY, m_nPosTX, m_nPosTY);
  506. }
  508. void CDXIsoMap::Scroll(DIRECTION eDir)
  509. {
  510. switch (eDir)
  511. {
  512. case DOWN:
  513. ScrollY(1);
  514. break;
  515. case LEFT_DOWN:
  516. ScrollX(-2);
  517. ScrollY(1);
  518. break;
  519. case LEFT:
  520. ScrollX(-2);
  521. break;
  522. case LEFT_UP:
  523. ScrollX(-2);
  524. ScrollY(-1);
  525. break;
  526. case UP:
  527. ScrollY(-1);
  528. break;
  529. case RIGHT_UP:
  530. ScrollX(2);
  531. ScrollY(-1);
  532. break;
  533. case RIGHT:
  534. ScrollX(2);
  535. break;
  536. case RIGHT_DOWN:
  537. ScrollX(2);
  538. ScrollY(1);
  539. break;
  540. }
  541. }
  543. CELL* CDXIsoMap::GetCell(int nTx, int nTy)
  544. {
  545. ASSERT((nTx< m_nColumns) && (nTy < m_nRows));
  546. return (&m_pMapData[nTy*m_nColumns+nTx]);
  547. }
  549. // 在屏幕的(nDestX, nDestY)位置重画高度高于nHeight的图块
  550. // IN:
  551. // nDestX
  552. // nDestY: 屏幕坐标
  553. void CDXIsoMap::BltTileAbove(CDDSurface*  pDestSurface,
  554. int nDestX, int nDestY, CELL* pCell, int nHeight)
  555. {
  556. RECT drc, drc0;
  557. drc.left = nDestX;
  558. drc.top = nDestY;
  559. drc.right = nDestX + m_nCellWidth;
  560. drc.bottom = nDestY + m_nCellHeight;
  562. if (IntersectRect(&drc0, &drc, &m_rcDest))
  563. {
  564. int nOffY = drc0.top - drc.top;
  565. int nOffX = drc0.left - drc.left; 
  566. int nW = drc0.right - drc0.left;
  567. int nH = drc0.bottom - drc0.top;
  569. int nTileIndex;
  570. int x1, y1;
  571. RECT src;
  573. if ((pCell->base.flag & 0x0F) >= nHeight)
  574. {
  575. nTileIndex = pCell->base.index;
  576. if (pCell->base.flag & m_CellIdxFlg)
  577. nTileIndex += 0x100;
  578. if (nTileIndex)
  579. {
  580. x1 = (nTileIndex % m_nSrcSurfaceCellRows) << m_nCellWidthShift;
  581. y1 = (nTileIndex / m_nSrcSurfaceCellRows) << m_nCellHeightShift;
  583. src.top = y1 + nOffY;
  584. src.left = x1 + nOffX;
  585. src.bottom = src.top + nH;
  586. src.right = src.left + nW;
  588. m_pTiles->Draw(pDestSurface, drc0.left, drc0.top, &src);
  589. }
  590. }
  592. if ((pCell->fringe.flag & 0x0F) >= nHeight)
  593. {
  594. nTileIndex = pCell->fringe.index;
  595. if (pCell->fringe.flag & m_CellIdxFlg)
  596. nTileIndex += 0x100;
  597. if (nTileIndex)
  598. {
  599. x1 = (nTileIndex % m_nSrcSurfaceCellRows) << m_nCellWidthShift;
  600. y1 = (nTileIndex / m_nSrcSurfaceCellRows) << m_nCellHeightShift;
  602. src.top = y1 + nOffY;
  603. src.left = x1 + nOffX;
  604. src.bottom = src.top + nH;
  605. src.right = src.left + nW;
  607. m_pTiles->Draw(pDestSurface, drc0.left, drc0.top, &src);
  608. }
  609. }
  610. }
  611. }
  613. // 从图块(nX, nY)开始向上重画8块
  614. // 因为16*8=128为人物高度的最大值
  615. // IN:
  616. // nX:
  617. // nY: 绝对图块坐标
  618. void CDXIsoMap::DrawColAbove(CDDSurface *pDest, int nX, int nY)
  619. {
  620. int tx, ty;
  621. int x, y;
  623. tx = nX;
  624. ty = nY;
  625. for(int i=0; i<8; i++)
  626. {
  627. // 再转换成当前图块左上角的相对象素坐标
  628. Cell2Pixel(tx, ty, x, y, FALSE);
  629. BltTileAbove(pDest, x, y, GetCell(tx, ty), i*2+1);
  630. if (ty>0)
  631. NextCell(tx, ty, UP);
  632. else
  633. break;
  634. }
  635. }
  637. // 遮掩算法
  638. // IN:
  639. // nX: Hero所处的屏幕坐标
  640. // nY: 
  641. void CDXIsoMap::DrawAbove(CDDSurface *pDest, int nX, int nY)
  642. {
  643. int tx, ty;
  644. int x, y;
  645. // 根据相对象素坐标计算绝对图块坐标
  646. AbsoluteCell(nX, nY, x, y, FALSE);
  647. tx = x;
  648. ty = y;
  649. // 中间列
  650. DrawColAbove(pDest, tx, ty);
  651. // 左边列
  652. NextCell(tx, ty, LEFT_DOWN);
  653. DrawColAbove(pDest, tx, ty);
  654. NextCell(tx, ty, LEFT_UP);
  655. DrawColAbove(pDest, tx, ty);
  656. NextCell(tx, ty, LEFT_DOWN);
  657. DrawColAbove(pDest, tx, ty);
  658. // 右边列
  660. tx = x;
  661. ty = y;
  662. NextCell(tx, ty, RIGHT_DOWN);
  663. DrawColAbove(pDest, tx, ty);
  664. NextCell(tx, ty, RIGHT_UP);
  665. DrawColAbove(pDest, tx, ty);
  666. NextCell(tx, ty, RIGHT_DOWN);
  667. DrawColAbove(pDest, tx, ty);
  668. }