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

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

游戏

开发平台：

Visual C++

mapinfo.cpp：源码内容
  2. #include "global.h"
  3. #include "mapinfo.h"
  5. //-----------------------------------------------------------------------------
  6. // Name: 
  7. // Desc: 
  8. //-----------------------------------------------------------------------------
  9. CMapInfo::CMapInfo() {
  10. m_bReversed = false;
  11. m_nBlocks = 0;
  12. m_cxBlocks = 0;
  13. m_cyBlocks = 0;
  15. m_szFileName = NULL;
  16. m_ptBase  = NULL;
  17. m_pBlocks  = NULL;
  18. m_pTankInfo  = NULL;
  20. }
  23. //-----------------------------------------------------------------------------
  24. // Name: 
  25. // Desc: 
  26. //-----------------------------------------------------------------------------
  27. CMapInfo::~CMapInfo() {
  28. DestroyMap();
  29. }
  32. //-----------------------------------------------------------------------------
  33. // Name: 
  34. // Desc: 
  35. //-----------------------------------------------------------------------------
  36. void CMapInfo::DestroyMap() {
  37. //DELETE_PTR( m_szFileName ); // Undefined error here
  38. //DELETE_ARRAY( m_ptBase );
  39. //DELETE_ARRAY( m_pBlocks );
  40. //DELETE_ARRAY( m_pTankInfo );
  41. }
  44. //-----------------------------------------------------------------------------
  45. // Name: 
  46. // Desc: 
  47. //-----------------------------------------------------------------------------
  48. bool CMapInfo::LoadMap( const char *filename ) {
  49. if ( !filename )
  50. return false;
  52. DestroyMap();
  53. m_szFileName = new char[strlen(filename)+1];
  54. strcpy( m_szFileName, filename );
  56. HANDLE hfile;
  57. DWORD read, ret;
  58. FILEHEADER header;
  60. // Open exist file
  61. hfile = CreateFile( m_szFileName, GENERIC_READ,
  62. 0, NULL, OPEN_EXISTING,
  63. FILE_ATTRIBUTE_NORMAL, NULL );
  64. if ( hfile == INVALID_HANDLE_VALUE ) 
  65. goto err_quit_loadmap;
  67. // Read file header and test if the file format is legal
  68. read = sizeof(FILEHEADER);
  69. if ( !ReadFile( hfile, (LPVOID)&header, read, &ret, NULL ) ) 
  70. goto err_quit_loadmap;
  72. if ( header.dwFileID != GAME_MAP_FILE_IDENTITY ||
  73. header.dwVersion != GAME_MAP_VER_1_2_0 ) 
  74. goto err_quit_loadmap;
  76. // Read base possitions
  77. m_ptBase = new POINT[2];
  78. read = sizeof(POINT) * 2;
  79. if ( !ReadFile( hfile, (LPVOID)m_ptBase, read, &ret , NULL ) )  
  80. goto err_quit_loadmap;
  82. // Read tanks' original infomation settings
  83. m_pTankInfo = new TANKINFO[20];
  84. if ( !m_pTankInfo )  
  85. goto err_quit_loadmap;
  87. read = sizeof(TANKINFO)*20;
  88. if( !ReadFile( hfile, (LPVOID)m_pTankInfo, read, &ret, NULL ) )  
  89. goto err_quit_loadmap;
  91. // Read block infomations
  92. m_nBlocks = header.nBlocks;
  93. m_cxBlocks = DEFAULT_CX_BLOCKS;
  94. m_cyBlocks = DEFAULT_CY_BLOCKS;
  96. m_pBlocks = new BLOCK[m_nBlocks];
  97. if ( !m_pBlocks ) 
  98. goto err_quit_loadmap;
  100. read = sizeof(BLOCK) * m_nBlocks;
  101. ZeroMemory( m_pBlocks, read );
  102. if( !ReadFile( hfile, (LPVOID)m_pBlocks, read, &ret, NULL ) ) 
  103. goto err_quit_loadmap;
  105. // Close file handle
  106. CloseHandle(hfile);
  108. // Need to be added in further version of map
  109. m_uiTankNum = 20;
  111. return true;
  113. // False return
  114. err_quit_loadmap:
  116. CloseHandle(hfile);
  117. DestroyMap();
  118. m_nBlocks  = 0;
  119. m_cxBlocks = 0;
  120. m_cyBlocks = 0;
  121. return false;
  122. }
  125. //-----------------------------------------------------------------------------
  126. // Name: 
  127. // Desc: 
  128. //-----------------------------------------------------------------------------
  129. void CMapInfo::SetReversed( bool flag ) {
  130. if ( m_bReversed != flag && CenterRotate180() )
  131. m_bReversed = flag;
  132. }
  134. //-----------------------------------------------------------------------------
  135. // Name: 
  136. // Desc: 
  137. //-----------------------------------------------------------------------------
  138. void CMapInfo::ConvertCoord( CObject * pobj ) {
  139. pobj->SetPos( g_FrameLeft - pobj->GetLeft(), g_FrameLeft - pobj->GetTop() );
  140. }
  142. //-----------------------------------------------------------------------------
  143. // Name: 
  144. // Desc: 
  145. //-----------------------------------------------------------------------------
  146. void CMapInfo::Protect( RECT rt, bool flag, POINT *ppts, int &changed ) {
  147. int x, y;
  148. int xend = rt.left/32+1, yend = rt.top/32+1;
  149. int total = 0;
  151. for ( y = yend-2; y <= yend; y++ )  {
  152. if ( y < 0 || y > m_cyBlocks-2)
  153. continue;
  154. for ( x = xend-2; x <= xend; x++ ) {
  155. if ( x < 0 || x > m_cxBlocks-2)
  156. continue;
  157. if ( total < changed ) {
  158. if ( flag )
  159. (m_pBlocks+y*m_cyBlocks+x)->byClass = LAND_IRON;
  160. else
  161. (m_pBlocks+y*m_cyBlocks+x)->byClass = LAND_BRICK;
  162. ppts[total].x = x;
  163. ppts[total].y = y;
  164. total++;
  165. }
  166. }
  167. }
  168. changed = total;
  169. }
  171. //-----------------------------------------------------------------------------
  172. // Name: 
  173. // Desc: 
  174. //-----------------------------------------------------------------------------
  175. bool CMapInfo::CenterRotate180() {
  176. if ( !(HorReverseMap() && VerReverseMap()) )
  177. return false;
  179. // Reverse base position too
  180. if ( m_ptBase ) {
  181. m_ptBase[0].x = (m_cxBlocks-2)*32-m_ptBase[0].x;
  182. m_ptBase[0].y = (m_cyBlocks-2)*32-m_ptBase[0].y;
  183. m_ptBase[1].x = (m_cxBlocks-2)*32-m_ptBase[1].x;
  184. m_ptBase[1].y = (m_cyBlocks-2)*32-m_ptBase[1].y;
  185. }
  186. return true;
  187. }
  190. //-----------------------------------------------------------------------------
  191. // Name: 
  192. // Desc: 
  193. //-----------------------------------------------------------------------------
  194. bool CMapInfo::HorReverseMap() {
  195. if ( !m_pBlocks || m_cxBlocks == 0)
  196. return false;
  198. int i,j,half,opp;
  199. BLOCK block;
  201. half = (m_cxBlocks-1)/2; // Divide to two pars, left and right
  202. for(j=0; j<m_cyBlocks-1; j++) {
  203. for(i=0; i<half; i++) {
  204. // exchange b[j][i] and b[j][19-i]
  205. opp = m_cxBlocks-2-i;
  206. HorReverseBlock(i,j);
  207. HorReverseBlock(opp,j);
  208. block = *(m_pBlocks+j*m_cyBlocks+i);
  209. *(m_pBlocks+j*m_cyBlocks+i) = *(m_pBlocks+j*m_cyBlocks+opp);
  210. *(m_pBlocks+j*m_cyBlocks+opp) = block;
  211. }
  212. }
  213. return true;
  214. }
  217. //-----------------------------------------------------------------------------
  218. // Name: 
  219. // Desc: 
  220. //-----------------------------------------------------------------------------
  221. bool CMapInfo::VerReverseMap() {
  222. if ( !m_pBlocks || m_cyBlocks == 0)
  223. return false;
  225. int i,j,half,opp;
  226. BLOCK block;
  228. half = (m_cyBlocks-1)/2; // Divide to two parts, up and down
  229. for(i=0; i<m_cxBlocks-1; i++) {
  230. for(j=0; j<half; j++) {
  231. // exchange b[j][i] and b[19-j][i]
  232. opp = m_cyBlocks-2-j;
  233. VerReverseBlock( i, j );
  234. VerReverseBlock( i, opp );
  235. block = *( m_pBlocks + j*m_cyBlocks + i);
  236. *( m_pBlocks + j*m_cyBlocks+i ) = *( m_pBlocks + opp*m_cyBlocks+i );
  237. *( m_pBlocks+ opp*m_cyBlocks+i ) = block;
  238. }
  239. }
  241. return true;
  242. }
  245. //-----------------------------------------------------------------------------
  246. // Name: 
  247. // Desc: 
  248. //-----------------------------------------------------------------------------
  249. void CMapInfo::HorReverseBlock( int x, int y ) {
  250. BYTE b1,b2,b3,b4,obs;
  252. obs = (m_pBlocks+y*m_cyBlocks+x)->byObstacle;
  254. if(obs != 0 && obs != 0x0f) {
  255. b1 = obs & 0x01;
  256. b2 = obs & 0x02;
  257. b3 = obs & 0x04;
  258. b4 = obs & 0x08;
  259. (m_pBlocks+y*m_cyBlocks+x)->byObstacle = (b1<<3) +
  260. (b2<<1) + (b3>>1) + (b4>>3);
  261. }
  262. }
  264. //-----------------------------------------------------------------------------
  265. // Name: 
  266. // Desc: 
  267. //-----------------------------------------------------------------------------
  268. void CMapInfo::VerReverseBlock( int x, int y ) {
  269. BYTE b1,b2,b3,b4,obs;
  271. obs = (m_pBlocks+y*m_cyBlocks+x)->byObstacle;
  273. if(obs != 0 && obs != 0x0f) {
  274. b1 = obs & 0x01;
  275. b2 = obs & 0x02;
  276. b3 = obs & 0x04;
  277. b4 = obs & 0x08;
  278. (m_pBlocks+y*m_cyBlocks+x)->byObstacle = (b1<<1) + 
  279. (b2>>1) + (b3<<1) + (b4>>1);
  280. }
  281. }
  282. //-----------------------------------------------------------------------------
  283. // Name: 
  284. // Desc: 
  285. //-----------------------------------------------------------------------------
  286. int CMapInfo::BlockCounter( DWORD land, CObjBlock *pobb ) {
  287. int counter = 0;
  288. BLOCK *pblk;
  289. for ( int i=0; i<m_cyBlocks-1; i++ )
  290. for ( int j=0; j<m_cxBlocks-1; j++ ) {
  291. pblk = m_pBlocks+i*m_cxBlocks+j;
  292. if ( pblk->byClass == land ) {
  293. if ( pobb ) {
  294. pobb[counter].CreateObjBlock( j, i, land );
  295. pobb[counter].SetTotalFrame( 3 );
  296. }
  297. counter++;
  298. }
  299. }
  300. return counter;
  301. }
  304. //-----------------------------------------------------------------------------
  305. // Name: 
  306. // Desc: 
  307. //-----------------------------------------------------------------------------
  308. bool CMapInfo::BlockLocator( int x, int y, RECT *prc, int &level ) {
  309. BLOCK *pblock = m_pBlocks + x + y*m_cxBlocks;
  310. DWORD dwLocType; 
  312. level = LAYER_GROUND;
  313. switch(pblock->byClass)
  314. {
  315. case LAND_BRICK:
  316. dwLocType = LOC_BLOCK_BRICK0;
  317. break;
  318. case LAND_IRON:
  319. dwLocType = LOC_BLOCK_IRON0;
  320. break;
  321. case LAND_RIVER:
  322. dwLocType = LOC_BLOCK_RIVER0;
  323. break;
  324. case LAND_GRASS:
  325. dwLocType = LOC_BLOCK_GRASS0;
  326. level = LAYER_TREE;
  327. break;
  328. case LAND_ICE:
  329. dwLocType = LOC_BLOCK_ICE0;
  330. break;
  331. case LAND_NONE:
  332. default:
  333. dwLocType = LOC_BLOCK_NONE;
  334. }
  336. int *pres = &ResArray[dwLocType][0];
  337. prc->left = pblock->byObstacle * (*(pres+RESSIZE_WIDTH)) + (*(pres+RESPOS_LEFT));
  338. prc->top  = *(pres+RESPOS_TOP);
  339. prc->right  = prc->left + (*(pres+RESSIZE_WIDTH));
  340. prc->bottom = prc->top + (*(pres+RESSIZE_HEIGHT));
  342. return true;
  343. }
  347. //-----------------------------------------------------------------------------
  348. // Name: 
  349. // Desc: 
  350. //-----------------------------------------------------------------------------
  351. bool CMapInfo::ObjectLocator( CObject *pobj, RECT *prc, int &level ) {
  352. DWORD type = pobj->GetType();
  354. if ( type == OBJTYPE_TANK ) {
  355. prc->top  = RES_POST_TANK;
  356. prc->left = RES_POSL_TANK;
  357. prc->left +=  ((CObjTank *)pobj)->m_uiDirection - 1;
  358. prc->left  *= g_FrameSmall;
  359. prc->top   *= g_FrameSmall;
  360. level = LAYER_TANK;
  361. } else if ( type == OBJTYPE_BULLET ) {
  362. prc->top  = 128;
  363. prc->left = pobj->GetFrameCurrent() * g_FrameSmall;
  364. level = LAYER_BULLET;
  365. } else if ( type == OBJTYPE_BASE ) {
  366. prc->top  = RES_POST_BASE;
  367. prc->left = RES_POSL_BASE;
  368. }
  370. prc->right  = prc->left + pobj->GetWidth();
  371. prc->bottom = prc->top + pobj->GetHeight();
  373. return true;
  374. }
  377. //-----------------------------------------------------------------------------
  378. // Name: 
  379. // Desc: 
  380. //-----------------------------------------------------------------------------
  381. bool CMapInfo::ObjBlockLocator( CObjBlock *poblk, RECT *prc, int &level ) {
  382. if ( poblk->GetLand() == LAND_RIVER ) {
  383. BLOCK *pblock = m_pBlocks + poblk->GetBx() + 
  384. poblk->GetBy()*m_cxBlocks;
  385. prc->left = pblock->byObstacle + RES_POSL_LAND;
  386. prc->top = RES_POST_LAND_RIVER + poblk->GetFrameCurrent();
  387. prc->left  *= g_FrameSmall;
  388. prc->top   *= g_FrameSmall;
  389. prc->right  = prc->left + g_FrameSmall;
  390. prc->bottom = prc->top + g_FrameSmall;
  391. level = LAYER_GROUND;
  392. }
  393. return true;
  394. }
  396. //-----------------------------------------------------------------------------
  397. // Name: 
  398. // Desc: 
  399. //-----------------------------------------------------------------------------
  400. bool CMapInfo::ColR2R( RECT &rt_move, RECT rt_stable, POINT step ) {
  401. bool intersect = false;
  403. SetRect( &rt_move, rt_move.left - rt_stable.right, rt_move.top - rt_stable.bottom,
  404. rt_move.right - rt_stable.left, rt_move.bottom - rt_stable.top );
  406. while ( rt_move.left * rt_move.right < 0  && rt_move.top * rt_move.bottom < 0 ) {
  407. intersect = true;
  408. if ( step.x != 0 ) {
  409. rt_move.left -= step.x;
  410. rt_move.right -= step.x;
  411. } else if ( step.y != 0 ) {
  412. rt_move.top -= step.y;
  413. rt_move.bottom -= step.y;
  414. } else
  415. break;
  416. }
  418. rt_move.left += rt_stable.right;
  419. rt_move.top += rt_stable.bottom;
  420. rt_move.right += rt_stable.left;
  421. rt_move.bottom += rt_stable.top;
  423. return intersect;
  424. }
  426. //-----------------------------------------------------------------------------
  427. // Name: 
  428. // Desc: 
  429. //-----------------------------------------------------------------------------
  430. void CMapInfo::ColRToMobile( RECT &rt, POINT step, CMobileObject **ppmos,
  431.  int num, int except, UINT team, bool checkteam,
  432.  int &hit )
  433. {
  434. hit = -1;
  436. for ( int i=0; i<num; i++ ) {
  437. if ( i == except || !ppmos[i] || 
  438. ( ppmos[i]->GetStat() & OBJSTAT_CADAVER ) )
  439. continue;
  440. if ( checkteam && team == ppmos[i]->m_uiTeamType ) 
  441. continue;
  442. if ( ColR2R( rt, ppmos[i]->GetRect(), step ) )
  443. hit = i;
  444. }
  445. }
  447. //-----------------------------------------------------------------------------
  448. // Name: 
  449. // Desc: 
  450. //-----------------------------------------------------------------------------
  451. void CMapInfo::ColRToB( POINT &lt, WidthType wt, POINT step, DWORD block_land, 
  452.   DWORD &over_land, DWORD remove_land, POINT *ptChanged,
  453.   int &changed )
  454. {
  455. BLOCK *pblks[4];
  456. POINT index[4];
  457. int mask[4];
  458. DWORD over_ret, land;
  459. bool bBlocked; 
  460. int total = 0;
  461. int bound;
  463. // Boundary test
  464. if ( wt == WIDTH_32 )
  465. bound = g_FrameWidth-32;
  466. else
  467. bound = g_FrameWidth-16;
  468. if ( lt.x < 0 )
  469. lt.x = 0;
  470. else if ( lt.x > bound )
  471. lt.x = bound;
  472. if ( lt.y < 0 )
  473. lt.y = 0;
  474. else if ( lt.y > bound )
  475. lt.y = bound;
  477. // Block Test
  478. do {
  479. // 4 block indices
  480. index[0].x = lt.x / g_FrameSmall;
  481. index[0].y = lt.y / g_FrameSmall;
  482. index[2].x = index[0].x;
  483. index[1].x = index[0].x + 1;
  484. index[3].x = index[1].x;
  485. index[1].y = index[0].y;
  486. index[2].y = index[0].y + 1;
  487. index[3].y = index[2].y;
  489. // 4 masks
  490. if ( wt == WIDTH_32 )
  491. Get4Mask( lt.x, lt.y, mask );
  492. else
  493. Get4Mask16( lt.x, lt.y, mask );
  495. // Test with these 4 blocks
  496. bBlocked = false;
  497. over_ret = 0;
  499. for ( int i=0; i<4; i++ )
  500. {
  501. pblks[i] = m_pBlocks +  index[i].y * m_cxBlocks + index[i].x;
  502. if ( mask[i] & pblks[i]->byObstacle ) // overlap
  503. {
  504. land = 1 << pblks[i]->byClass;
  505. if ( land & remove_land ) { // remove
  506. if ( total < changed ) {
  507. pblks[i]->byObstacle &= ~mask[i];
  508. ptChanged[total] = index[i];
  509. }
  510. total++;
  511. }
  512. if ( land & block_land ) { // block
  513. bBlocked = true;
  514. }
  515. if ( land & over_land ) // over, set the bit
  516. over_ret |= land;
  517. }
  518. }
  520. // Block or not
  521. if ( bBlocked ) {
  522. if ( step.x != 0 ) {
  523. while ( lt.x % 16 != 0 )
  524. lt.x -= step.x;
  525. }
  526. else if ( step.y != 0 ) {
  527. while ( lt.y % 16 != 0 )
  528. lt.y -= step.y;
  529. }
  530. } else
  531. break;
  532. } while (true);
  534. // Set return values
  535. changed = total;
  536. over_land = over_ret;
  537. }
  539. //-----------------------------------------------------------------------------
  540. // Name: 
  541. // Desc: 
  542. //-----------------------------------------------------------------------------
  543. void CMapInfo::Get4Mask( int left, int top, int *mask) {
  544. int iver = top % g_FrameSmall,
  545. ihor = left % g_FrameSmall;
  547. // Assign mask array, LT-RT-LB-RB
  548. // All case here.
  549. if ( iver > g_FrameBasis) {
  550. if ( ihor > g_FrameBasis ) { // 1:2:2:4
  551. mask[0] = 2;
  552. mask[1] = 6;
  553. mask[2] = 3;
  554. mask[3] = 15;
  555. } else if ( ihor == g_FrameBasis ) { // 1:1:2:2
  556. mask[0] = 2;
  557. mask[1] = 4;
  558. mask[2] = 3;
  559. mask[3] = 12;
  560. } else if ( ihor > 0 ) { // 2:1:4:2
  561. mask[0] = 6;
  562. mask[1] = 4;
  563. mask[2] = 15;
  564. mask[3] = 12;
  565. } else { // 2:0:4:0
  566. mask[0] = 6;
  567. mask[1] = 0;
  568. mask[2] = 15;
  569. mask[3] = 0;
  570. }
  571. } else if ( iver == g_FrameBasis ) {
  572. if ( ihor > g_FrameBasis ) { // 1:2:1:2
  573. mask[0] = 2;
  574. mask[1] = 6;
  575. mask[2] = 1;
  576. mask[3] = 9;
  577. } else if ( ihor == g_FrameBasis ) { // 1:1:1:1
  578. mask[0] = 2;
  579. mask[1] = 4;
  580. mask[2] = 1;
  581. mask[3] = 8;
  582. } else if ( ihor > 0 ) { // 2:1:2:1
  583. mask[0] = 6;
  584. mask[1] = 4;
  585. mask[2] = 9;
  586. mask[3] = 8;
  587. } else { // 2:0:2:0
  588. mask[0] = 6;
  589. mask[1] = 0;
  590. mask[2] = 9;
  591. mask[3] = 0;
  592. }
  593. } else if ( iver > 0 ) {
  594. if ( ihor > g_FrameBasis ) { // 2:4:1:2
  595. mask[0] = 3;
  596. mask[1] = 15;
  597. mask[2] = 1;
  598. mask[3] = 9;
  599. } else if ( ihor == g_FrameBasis ) { // 2:2:1:1
  600. mask[0] = 3;
  601. mask[1] = 12;
  602. mask[2] = 1;
  603. mask[3] = 8;
  604. } else if ( ihor > 0 ) { // 4:2:2:1
  605. mask[0] = 15;
  606. mask[1] = 12;
  607. mask[2] = 9;
  608. mask[3] = 8;
  609. } else { // 4:0:2:0
  610. mask[0] = 15;
  611. mask[1] = 0;
  612. mask[2] = 9;
  613. mask[3] = 0;
  614. }
  615. } else {
  616. if ( ihor > g_FrameBasis ) { // 2:4:0:0
  617. mask[0] = 3;
  618. mask[1] = 15;
  619. mask[2] = 0;
  620. mask[3] = 0;
  621. } else if ( ihor == g_FrameBasis ) { // 2:2:0:0
  622. mask[0] = 3;
  623. mask[1] = 12;
  624. mask[2] = 0;
  625. mask[3] = 0;
  626. } else if ( ihor > 0 ) { // 4:2:0:0
  627. mask[0] = 15;
  628. mask[1] = 12;
  629. mask[2] = 0;
  630. mask[3] = 0;
  631. } else { // 4:0:0:0
  632. mask[0] = 15;
  633. mask[1] = 0;
  634. mask[2] = 0;
  635. mask[3] = 0;
  636. }
  637. }
  638. }
  640. //-----------------------------------------------------------------------------
  641. // Name: 
  642. // Desc: 
  643. //-----------------------------------------------------------------------------
  644. void CMapInfo::Get4Mask16( int left, int top, int *mask) {
  645. int iver = top % g_FrameSmall,
  646. ihor = left % g_FrameSmall;
  648. // Assign mask array, LT-RT-LB-RB
  649. // All case here.
  650. if ( iver > g_FrameBasis) {
  651. if ( ihor > g_FrameBasis ) { // 1:2:2:4
  652. mask[0] = 2;
  653. mask[1] = 4;
  654. mask[2] = 1;
  655. mask[3] = 8;
  656. } else if ( ihor == g_FrameBasis ) { // 1:1:2:2
  657. mask[0] = 2;
  658. mask[1] = 0;
  659. mask[2] = 1;
  660. mask[3] = 0;
  661. } else if ( ihor > 0 ) { // 2:1:4:2
  662. mask[0] = 6;
  663. mask[1] = 0;
  664. mask[2] = 9;
  665. mask[3] = 0;
  666. } else { // 2:0:4:0
  667. mask[0] = 4;
  668. mask[1] = 0;
  669. mask[2] = 8;
  670. mask[3] = 0;
  671. }
  672. } else if ( iver == g_FrameBasis ) {
  673. if ( ihor > g_FrameBasis ) { // 1:2:1:2
  674. mask[0] = 2;
  675. mask[1] = 4;
  676. mask[2] = 0;
  677. mask[3] = 0;
  678. } else if ( ihor == g_FrameBasis ) { // 1:1:1:1
  679. mask[0] = 2;
  680. mask[1] = 0;
  681. mask[2] = 0;
  682. mask[3] = 0;
  683. } else if ( ihor > 0 ) { // 2:1:2:1
  684. mask[0] = 6;
  685. mask[1] = 0;
  686. mask[2] = 0;
  687. mask[3] = 0;
  688. } else { // 2:0:2:0
  689. mask[0] = 4;
  690. mask[1] = 0;
  691. mask[2] = 0;
  692. mask[3] = 0;
  693. }
  694. } else if ( iver > 0 ) {
  695. if ( ihor > g_FrameBasis ) { // 2:4:1:2
  696. mask[0] = 3;
  697. mask[1] = 12;
  698. mask[2] = 0;
  699. mask[3] = 0;
  700. } else if ( ihor == g_FrameBasis ) { // 2:2:1:1
  701. mask[0] = 3;
  702. mask[1] = 0;
  703. mask[2] = 0;
  704. mask[3] = 0;
  705. } else if ( ihor > 0 ) { // 4:2:2:1
  706. mask[0] = 15;
  707. mask[1] = 0;
  708. mask[2] = 0;
  709. mask[3] = 0;
  710. } else { // 4:0:2:0
  711. mask[0] = 12;
  712. mask[1] = 0;
  713. mask[2] = 0;
  714. mask[3] = 0;
  715. }
  716. } else {
  717. if ( ihor > g_FrameBasis ) { // 2:4:0:0
  718. mask[0] = 1;
  719. mask[1] = 8;
  720. mask[2] = 0;
  721. mask[3] = 0;
  722. } else if ( ihor == g_FrameBasis ) { // 2:2:0:0
  723. mask[0] = 1;
  724. mask[1] = 0;
  725. mask[2] = 0;
  726. mask[3] = 0;
  727. } else if ( ihor > 0 ) { // 4:2:0:0
  728. mask[0] = 9;
  729. mask[1] = 0;
  730. mask[2] = 0;
  731. mask[3] = 0;
  732. } else { // 4:0:0:0
  733. mask[0] = 8;
  734. mask[1] = 0;
  735. mask[2] = 0;
  736. mask[3] = 0;
  737. }
  738. }
  739. }
  741. //-----------------------------------------------------------------------------
  742. // Name: 
  743. // Desc: 
  744. //-----------------------------------------------------------------------------
  747. /*
  748. All case here.
  751. if ( iver > g_FrameBasis) {
  752. if ( ihor > g_FrameBasis ) { // 1:2:2:4
  753. mask[0] = 3;
  754. mask[1] = 15;
  755. mask[2] = 1;
  756. mask[3] = 8;
  757. } else if ( ihor == g_FrameBasis ) { // 1:1:2:2
  758. mask[0] = 15;
  759. mask[1] = 12;
  760. mask[2] = 9;
  761. mask[3] = 8;
  762. } else if ( ihor > 0 ) { // 2:1:4:2
  763. mask[0] = 15;
  764. mask[1] = 12;
  765. mask[2] = 9;
  766. mask[3] = 8;
  767. } else { // 2:0:4:0
  768. mask[0] = 15;
  769. mask[1] = 0;
  770. mask[2] = 9;
  771. mask[3] = 0;
  772. }
  773. } else if ( iver == g_FrameBasis ) {
  774. if ( ihor > g_FrameBasis ) { // 1:2:1:2
  775. mask[0] = 3;
  776. mask[1] = 15;
  777. mask[2] = 1;
  778. mask[3] = 8;
  779. } else if ( ihor == g_FrameBasis ) { // 1:1:1:1
  780. mask[0] = 15;
  781. mask[1] = 12;
  782. mask[2] = 9;
  783. mask[3] = 8;
  784. } else if ( ihor > 0 ) { // 2:1:2:1
  785. mask[0] = 15;
  786. mask[1] = 12;
  787. mask[2] = 9;
  788. mask[3] = 8;
  789. } else { // 2:0:2:0
  790. mask[0] = 15;
  791. mask[1] = 0;
  792. mask[2] = 9;
  793. mask[3] = 0;
  794. }
  795. } else if ( iver > 0 ) {
  796. if ( ihor > g_FrameBasis ) { // 2:4:1:2
  797. mask[0] = 3;
  798. mask[1] = 15;
  799. mask[2] = 1;
  800. mask[3] = 8;
  801. } else if ( ihor == g_FrameBasis ) { // 2:2:1:1
  802. mask[0] = 15;
  803. mask[1] = 12;
  804. mask[2] = 9;
  805. mask[3] = 8;
  806. } else if ( ihor > 0 ) { // 4:2:2:1
  807. mask[0] = 15;
  808. mask[1] = 12;
  809. mask[2] = 9;
  810. mask[3] = 8;
  811. } else { // 4:0:2:0
  812. mask[0] = 15;
  813. mask[1] = 0;
  814. mask[2] = 9;
  815. mask[3] = 0;
  816. }
  817. } else {
  818. if ( ihor > g_FrameBasis ) { // 2:4:0:0
  819. mask[0] = 3;
  820. mask[1] = 15;
  821. mask[2] = 1;
  822. mask[3] = 8;
  823. } else if ( ihor == g_FrameBasis ) { // 2:2:0:0
  824. mask[0] = 15;
  825. mask[1] = 12;
  826. mask[2] = 9;
  827. mask[3] = 8;
  828. } else if ( ihor > 0 ) { // 4:2:0:0
  829. mask[0] = 15;
  830. mask[1] = 12;
  831. mask[2] = 9;
  832. mask[3] = 8;
  833. } else { // 4:0:0:0
  834. mask[0] = 15;
  835. mask[1] = 0;
  836. mask[2] = 9;
  837. mask[3] = 0;
  838. }
  839. }
  841.   */