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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
KLittleMap.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：19k
源码类别：

模拟服务器

开发平台：

C/C++

KLittleMap.cpp：源码内容
  1. //---------------------------------------------------------------------------
  2. // Sword3 Engine (c) 2003 by Kingsoft
  3. //
  4. // File: KLittleMap.cpp
  5. // Date: 2003.05.08
  6. // Code: 边城浪子
  7. //---------------------------------------------------------------------------
  8. #include "KCore.h"
  10. #ifndef _SERVER
  12. #include "ImgRef.h"
  13. #include "KSubWorld.h"
  14. #include "KRegion.h"
  15. #include "KLittleMap.h"
  16. #include "KPlayer.h"
  17. #include    "../../Engine/Src/KSG_StringProcess.h"
  19. //---------------------------------------------------------------------------
  20. // 功能：构造函数
  21. //---------------------------------------------------------------------------
  22. KLittleMap::KLittleMap()
  23. {
  24. memset(&m_sMapRect, 0, sizeof(this->m_sMapRect));
  25. m_nMapWidth = 0;
  26. m_nMapHeight = 0;
  27. m_pbyLoadFlag = NULL;
  28. m_ppbtBarrier = NULL;
  30. m_nScreenX = 500;
  31. m_nScreenY = 100;
  32. m_nShowWidth = LITTLE_MAP_SHOW_REGION_WIDTH;
  33. m_nShowHeight = LITTLE_MAP_SHOW_REGION_HEIGHT;
  35. m_sBarrierColor.Color_dw = 0xffffff00;
  36. m_sSelfColor.Color_dw = 0x00ff00ff;
  37. m_sTeammateColor.Color_dw = 0x00ff00ff;
  38. m_sPlayerColor.Color_dw = 0x00ff00ff;
  39. m_sFightNpcColor.Color_dw = 0x00ff00ff;
  40. m_sNormalNpcColor.Color_dw = 0x00ff00ff;
  41. m_bTeammateShowFlag = TRUE;
  42. m_bPlayerShowFlag = TRUE;
  43. m_bFightNpcShowFlag = TRUE;
  44. m_bNormalNpcShowFlag = TRUE;
  45. m_bColorLoadFlag = FALSE;
  46. }
  48. //---------------------------------------------------------------------------
  49. // 功能：析构函数
  50. //---------------------------------------------------------------------------
  51. KLittleMap::~KLittleMap()
  52. {
  53. Release();
  54. m_nShowFlag = 0;
  55. }
  57. //---------------------------------------------------------------------------
  58. // 功能：清空
  59. //---------------------------------------------------------------------------
  60. void KLittleMap::Release()
  61. {
  62. if (m_ppbtBarrier)
  63. {
  64. for (int i = 0; i < m_nMapWidth * m_nMapHeight; i++)
  65. {
  66. if (!m_ppbtBarrier[i])
  67. continue;
  68. delete []m_ppbtBarrier[i];
  69. m_ppbtBarrier[i] = NULL;
  70. }
  71. delete []m_ppbtBarrier;
  72. m_ppbtBarrier = NULL;
  73. }
  75. if (m_pbyLoadFlag)
  76. {
  77. delete []m_pbyLoadFlag;
  78. m_pbyLoadFlag = NULL;
  79. }
  81. memset(&m_sMapRect, 0, sizeof(this->m_sMapRect));
  82. m_nMapWidth = 0;
  83. m_nMapHeight = 0;
  85. // m_nShowFlag = 0;
  86. }
  88. //---------------------------------------------------------------------------
  89. // 功能：初始化，分配内存空间
  90. //---------------------------------------------------------------------------
  91. void KLittleMap::Init(int nLeft, int nTop, int nRight, int nBottom)
  92. {
  93. Release();
  95. if (nRight < nLeft || nBottom < nTop)
  96. return;
  98. this->m_sMapRect.left = nLeft;
  99. this->m_sMapRect.top = nTop;
  100. this->m_sMapRect.right = nRight;
  101. this->m_sMapRect.bottom = nBottom;
  102. this->m_nMapWidth = nRight - nLeft + 1;
  103. this->m_nMapHeight = nBottom - nTop + 1;
  105. this->m_pbyLoadFlag = (BYTE*)new BYTE[m_nMapWidth * m_nMapHeight];
  106. memset(m_pbyLoadFlag, 0, sizeof(BYTE) * m_nMapWidth * m_nMapHeight);
  108. this->m_ppbtBarrier = (BYTE**)new LPVOID[m_nMapWidth * m_nMapHeight];
  109. for (int i = 0; i < m_nMapWidth * m_nMapHeight; i++)
  110. {
  111. this->m_ppbtBarrier[i] = NULL;
  112. }
  114. if (m_bColorLoadFlag == FALSE)
  115. {
  116. KIniFile cColorIni;
  117. int nR, nG, nB;
  118. char szTemp[32];
  119.         const char *pcszTemp = NULL;
  121. m_bColorLoadFlag = TRUE;
  122. // g_SetFilePath("\");
  123. if (cColorIni.Load(defLITTLE_MAP_SET_FILE))
  124. {
  125. cColorIni.GetString("MapColor", "MapColor", "255,255,255", szTemp, sizeof(szTemp));
  126.             
  127.             pcszTemp = szTemp;
  128.             nR = KSG_StringGetInt(&pcszTemp, 255);
  129.             KSG_StringSkipSymbol(&pcszTemp, ',');
  130.             nG = KSG_StringGetInt(&pcszTemp, 255);
  131.             KSG_StringSkipSymbol(&pcszTemp, ',');
  132.             nB = KSG_StringGetInt(&pcszTemp, 255);
  133. //sscanf(szTemp, "%d,%d,%d", &nR, &nG, &nB);
  135. this->m_sBarrierColor.Color_b.r = (BYTE)nR;
  136. this->m_sBarrierColor.Color_b.g = (BYTE)nG;
  137. this->m_sBarrierColor.Color_b.b = (BYTE)nB;
  138. this->m_sBarrierColor.Color_b.a = 0;
  140. cColorIni.GetString("MapColor", "SelfColor", "255,255,255", szTemp, sizeof(szTemp));
  142.             pcszTemp = szTemp;
  143.             nR = KSG_StringGetInt(&pcszTemp, 255);
  144.             KSG_StringSkipSymbol(&pcszTemp, ',');
  145.             nG = KSG_StringGetInt(&pcszTemp, 255);
  146.             KSG_StringSkipSymbol(&pcszTemp, ',');
  147.             nB = KSG_StringGetInt(&pcszTemp, 255);
  148. //sscanf(szTemp, "%d,%d,%d", &nR, &nG, &nB);
  150. this->m_sSelfColor.Color_b.r = (BYTE)nR;
  151. this->m_sSelfColor.Color_b.g = (BYTE)nG;
  152. this->m_sSelfColor.Color_b.b = (BYTE)nB;
  153. this->m_sSelfColor.Color_b.a = 0;
  155. cColorIni.GetInteger("MapColor", "TeammateShow", 1, &this->m_bTeammateShowFlag);
  156. cColorIni.GetString("MapColor", "TeammateColor", "255,255,255", szTemp, sizeof(szTemp));
  158.             pcszTemp = szTemp;
  159.             nR = KSG_StringGetInt(&pcszTemp, 255);
  160.             KSG_StringSkipSymbol(&pcszTemp, ',');
  161.             nG = KSG_StringGetInt(&pcszTemp, 255);
  162.             KSG_StringSkipSymbol(&pcszTemp, ',');
  163.             nB = KSG_StringGetInt(&pcszTemp, 255);
  164. //sscanf(szTemp, "%d,%d,%d", &nR, &nG, &nB);
  166. this->m_sTeammateColor.Color_b.r = (BYTE)nR;
  167. this->m_sTeammateColor.Color_b.g = (BYTE)nG;
  168. this->m_sTeammateColor.Color_b.b = (BYTE)nB;
  169. this->m_sTeammateColor.Color_b.a = 0;
  171. cColorIni.GetInteger("MapColor", "PlayerShow", 1, &this->m_bPlayerShowFlag);
  172. cColorIni.GetString("MapColor", "PlayerColor", "255,255,255", szTemp, sizeof(szTemp));
  174.             pcszTemp = szTemp;
  175.             nR = KSG_StringGetInt(&pcszTemp, 255);
  176.             KSG_StringSkipSymbol(&pcszTemp, ',');
  177.             nG = KSG_StringGetInt(&pcszTemp, 255);
  178.             KSG_StringSkipSymbol(&pcszTemp, ',');
  179.             nB = KSG_StringGetInt(&pcszTemp, 255);
  180. //sscanf(szTemp, "%d,%d,%d", &nR, &nG, &nB);
  182. this->m_sPlayerColor.Color_b.r = (BYTE)nR;
  183. this->m_sPlayerColor.Color_b.g = (BYTE)nG;
  184. this->m_sPlayerColor.Color_b.b = (BYTE)nB;
  185. this->m_sPlayerColor.Color_b.a = 0;
  187. cColorIni.GetInteger("MapColor", "FightNpcShow", 1, &this->m_bFightNpcShowFlag);
  188. cColorIni.GetString("MapColor", "FightNpcColor", "255,255,255", szTemp, sizeof(szTemp));
  190.             pcszTemp = szTemp;
  191.             nR = KSG_StringGetInt(&pcszTemp, 255);
  192.             KSG_StringSkipSymbol(&pcszTemp, ',');
  193.             nG = KSG_StringGetInt(&pcszTemp, 255);
  194.             KSG_StringSkipSymbol(&pcszTemp, ',');
  195.             nB = KSG_StringGetInt(&pcszTemp, 255);
  196. //sscanf(szTemp, "%d,%d,%d", &nR, &nG, &nB);
  198. this->m_sFightNpcColor.Color_b.r = (BYTE)nR;
  199. this->m_sFightNpcColor.Color_b.g = (BYTE)nG;
  200. this->m_sFightNpcColor.Color_b.b = (BYTE)nB;
  201. this->m_sFightNpcColor.Color_b.a = 0;
  203. cColorIni.GetInteger("MapColor", "NormalNpcShow", 1, &this->m_bNormalNpcShowFlag);
  204. cColorIni.GetString("MapColor", "NormalNpcColor", "255,255,255", szTemp, sizeof(szTemp));
  206.             pcszTemp = szTemp;
  207.             nR = KSG_StringGetInt(&pcszTemp, 255);
  208.             KSG_StringSkipSymbol(&pcszTemp, ',');
  209.             nG = KSG_StringGetInt(&pcszTemp, 255);
  210.             KSG_StringSkipSymbol(&pcszTemp, ',');
  211.             nB = KSG_StringGetInt(&pcszTemp, 255);
  212. //sscanf(szTemp, "%d,%d,%d", &nR, &nG, &nB);
  214. this->m_sNormalNpcColor.Color_b.r = (BYTE)nR;
  215. this->m_sNormalNpcColor.Color_b.g = (BYTE)nG;
  216. this->m_sNormalNpcColor.Color_b.b = (BYTE)nB;
  217. this->m_sNormalNpcColor.Color_b.a = 0;
  218. }
  219. }
  220. }
  222. //---------------------------------------------------------------------------
  223. // 功能：获得某个region的障碍数据的存储地址
  224. //---------------------------------------------------------------------------
  225. BYTE* KLittleMap::GetBarrierBuf(int nX, int nY)
  226. {
  227. if (nX < m_sMapRect.left ||
  228. nX > m_sMapRect.right ||
  229. nY < m_sMapRect.top ||
  230. nY > m_sMapRect.bottom)
  231. return NULL;
  232. if (!m_pbyLoadFlag || !m_ppbtBarrier)
  233. return NULL;
  234. int nRegion = (nY - m_sMapRect.top) * m_nMapWidth + nX - m_sMapRect.left;
  235. if (m_pbyLoadFlag[nRegion])
  236. return NULL;
  237. if (!m_ppbtBarrier[nRegion])
  238. {
  239. m_ppbtBarrier[nRegion] = (BYTE*)new BYTE[REGION_GRID_WIDTH * REGION_GRID_HEIGHT];
  240. memset(m_ppbtBarrier[nRegion], 0, sizeof(BYTE) * REGION_GRID_WIDTH * REGION_GRID_HEIGHT);
  241. }
  242. return m_ppbtBarrier[nRegion];
  243. }
  245. //---------------------------------------------------------------------------
  246. // 功能：设定已载入某个region的障碍数据
  247. //---------------------------------------------------------------------------
  248. void KLittleMap::SetHaveLoad(int nX, int nY)
  249. {
  250. if (nX < m_sMapRect.left ||
  251. nX > m_sMapRect.right ||
  252. nY < m_sMapRect.top ||
  253. nY > m_sMapRect.bottom)
  254. return;
  255. if (m_pbyLoadFlag)
  256. m_pbyLoadFlag[(nY - m_sMapRect.top) * m_nMapWidth + nX - m_sMapRect.left] = 1;
  257. }
  259. //---------------------------------------------------------------------------
  260. // 功能：绘制
  261. //---------------------------------------------------------------------------
  262. void KLittleMap::Draw(int nX, int nY)
  263. {
  264. if (!m_nShowFlag)
  265. return;
  266. if (!this->m_pbyLoadFlag || !this->m_ppbtBarrier)
  267. return;
  269. int nRx, nRy, nOx, nOy, nSx, nSy, nTx, nTy;
  271. nSx = nX - REGION_GRID_WIDTH * m_nShowWidth / 2;
  272. nSy = nY - REGION_GRID_HEIGHT * m_nShowHeight / 2;
  274. // 显示障碍
  275. m_nPointPos = 0;
  276. for (int i = 0; i < m_nShowWidth * REGION_GRID_WIDTH; i++)
  277. {
  278. for (int j = 0; j < m_nShowHeight * REGION_GRID_HEIGHT; j++)
  279. {
  280. nRx = (nSx + i) / REGION_GRID_WIDTH;
  281. nRy = (nSy + j) / REGION_GRID_HEIGHT;
  282. if (nRx < m_sMapRect.left ||
  283. nRx > m_sMapRect.right ||
  284. nRy < m_sMapRect.top ||
  285. nRy > m_sMapRect.bottom)
  286. continue;
  287. nRx -= m_sMapRect.left;
  288. nRy -= m_sMapRect.top;
  289. if (!m_pbyLoadFlag[nRy * m_nMapWidth + nRx] || !m_ppbtBarrier[nRy * m_nMapWidth + nRx])
  290. continue;
  291. nOx = (nSx + i) % REGION_GRID_WIDTH;
  292. nOy = (nSy + j) % REGION_GRID_HEIGHT;
  293. if (m_ppbtBarrier[nRy * m_nMapWidth + nRx][nOy * REGION_GRID_WIDTH + nOx])
  294. {
  295. m_sPoint[m_nPointPos].Color.Color_dw = m_sBarrierColor.Color_dw;
  296. m_sPoint[m_nPointPos].oPosition.nZ = 0;
  297. m_sPoint[m_nPointPos].oPosition.nX = m_nScreenX + i * 2;
  298. m_sPoint[m_nPointPos].oPosition.nY = m_nScreenY + j;
  299. m_nPointPos++;
  300. if (m_nPointPos == LITTLE_MAP_POINT_NUM)
  301. {
  302. g_pRepresent->DrawPrimitives(m_nPointPos, m_sPoint, RU_T_POINT, true);
  303. m_nPointPos = 0;
  304. }
  305. }
  306. }
  307. }
  308. if (m_nPointPos > 0 && m_nPointPos < LITTLE_MAP_POINT_NUM)
  309. {
  310. g_pRepresent->DrawPrimitives(m_nPointPos, m_sPoint, RU_T_POINT, true);
  311. m_nPointPos = 0;
  312. }
  314. int nNpcIdx;
  316. // 显示其他玩家和普通npc
  317. nNpcIdx = 0;
  318. while (1)
  319. {
  320. nNpcIdx = NpcSet.GetNextIdx(nNpcIdx);
  321. if (nNpcIdx == 0)
  322. break;
  323. if (Npc[nNpcIdx].m_RegionIndex == -1)
  324. continue;
  325. if (Npc[nNpcIdx].m_Kind == kind_normal)
  326. {
  327. if (!m_bFightNpcShowFlag)
  328. continue;
  329. nRx = LOWORD(Npc[nNpcIdx].m_dwRegionID);
  330. nRy = HIWORD(Npc[nNpcIdx].m_dwRegionID);
  331. if (nRx < m_sMapRect.left || nRx > m_sMapRect.right || nRy < m_sMapRect.top || nRy > m_sMapRect.bottom)
  332. continue;
  333. nOx = Npc[nNpcIdx].m_MapX;
  334. nOy = Npc[nNpcIdx].m_MapY;
  335. nTx = nRx * REGION_GRID_WIDTH + nOx;
  336. nTy = nRy * REGION_GRID_HEIGHT + nOy;
  338. m_sBigPoint.Color.Color_dw = m_sFightNpcColor.Color_dw;
  339. m_sBigPoint.oPosition.nX = m_nScreenX + (nTx - nSx) * 2 - 1;
  340. m_sBigPoint.oPosition.nY = m_nScreenY + nTy - nSy - 1;
  341. m_sBigPoint.oEndPos.nX = m_sBigPoint.oPosition.nX + 3;
  342. m_sBigPoint.oEndPos.nY = m_sBigPoint.oPosition.nY + 3;
  343. g_pRepresent->DrawPrimitives(1, &m_sBigPoint, RU_T_SHADOW, true);
  344. }
  345. else if (Npc[nNpcIdx].m_Kind == kind_dialoger)
  346. {
  347. if (!m_bNormalNpcShowFlag)
  348. continue;
  349. nRx = LOWORD(Npc[nNpcIdx].m_dwRegionID);
  350. nRy = HIWORD(Npc[nNpcIdx].m_dwRegionID);
  351. if (nRx < m_sMapRect.left || nRx > m_sMapRect.right || nRy < m_sMapRect.top || nRy > m_sMapRect.bottom)
  352. continue;
  353. nOx = Npc[nNpcIdx].m_MapX;
  354. nOy = Npc[nNpcIdx].m_MapY;
  355. nTx = nRx * REGION_GRID_WIDTH + nOx;
  356. nTy = nRy * REGION_GRID_HEIGHT + nOy;
  358. m_sBigPoint.Color.Color_dw = m_sNormalNpcColor.Color_dw;
  359. m_sBigPoint.oPosition.nX = m_nScreenX + (nTx - nSx) * 2 - 1;
  360. m_sBigPoint.oPosition.nY = m_nScreenY + nTy - nSy - 1;
  361. m_sBigPoint.oEndPos.nX = m_sBigPoint.oPosition.nX + 3;
  362. m_sBigPoint.oEndPos.nY = m_sBigPoint.oPosition.nY + 3;
  363. g_pRepresent->DrawPrimitives(1, &m_sBigPoint, RU_T_SHADOW, true);
  364. }
  365. else if (Npc[nNpcIdx].m_Kind == kind_player)
  366. {
  367. if (!m_bPlayerShowFlag)
  368. continue;
  369. if (nNpcIdx == Player[CLIENT_PLAYER_INDEX].m_nIndex)
  370. continue;
  371. if (m_bTeammateShowFlag &&
  372. Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag &&
  373. ((DWORD)g_Team[0].m_nCaptain == Npc[nNpcIdx].m_dwID || g_Team[0].FindMemberID(Npc[nNpcIdx].m_dwID) >= 0))
  374. continue;
  375. nRx = LOWORD(Npc[nNpcIdx].m_dwRegionID);
  376. nRy = HIWORD(Npc[nNpcIdx].m_dwRegionID);
  377. if (nRx < m_sMapRect.left || nRx > m_sMapRect.right || nRy < m_sMapRect.top || nRy > m_sMapRect.bottom)
  378. continue;
  379. nOx = Npc[nNpcIdx].m_MapX;
  380. nOy = Npc[nNpcIdx].m_MapY;
  381. nTx = nRx * REGION_GRID_WIDTH + nOx;
  382. nTy = nRy * REGION_GRID_HEIGHT + nOy;
  384. m_sBigPoint.Color.Color_dw = m_sPlayerColor.Color_dw;
  385. m_sBigPoint.oPosition.nX = m_nScreenX + (nTx - nSx) * 2 - 1;
  386. m_sBigPoint.oPosition.nY = m_nScreenY + nTy - nSy - 1;
  387. m_sBigPoint.oEndPos.nX = m_sBigPoint.oPosition.nX + 3;
  388. m_sBigPoint.oEndPos.nY = m_sBigPoint.oPosition.nY + 3;
  389. g_pRepresent->DrawPrimitives(1, &m_sBigPoint, RU_T_SHADOW, true);
  390. }
  391. }
  393. // 显示队友
  394. if (Player[CLIENT_PLAYER_INDEX].m_cTeam.m_nFlag && m_bTeammateShowFlag)
  395. {
  396. // 队长
  397. if ((DWORD)g_Team[0].m_nCaptain != Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwID)
  398. {
  399. nNpcIdx = NpcSet.SearchID(g_Team[0].m_nCaptain);
  400. if (nNpcIdx > 0 && Npc[nNpcIdx].m_RegionIndex != -1)
  401. {
  402. nRx = LOWORD(Npc[nNpcIdx].m_dwRegionID);
  403. nRy = HIWORD(Npc[nNpcIdx].m_dwRegionID);
  404. if (nRx >= m_sMapRect.left && nRx <= m_sMapRect.right && nRy >= m_sMapRect.top && nRy <= m_sMapRect.bottom)
  405. {
  406. nOx = Npc[nNpcIdx].m_MapX;
  407. nOy = Npc[nNpcIdx].m_MapY;
  408. nTx = nRx * REGION_GRID_WIDTH + nOx;
  409. nTy = nRy * REGION_GRID_HEIGHT + nOy;
  411. m_sBigPoint.Color.Color_dw = m_sTeammateColor.Color_dw;
  412. m_sBigPoint.oPosition.nX = m_nScreenX + (nTx - nSx) * 2 - 1;
  413. m_sBigPoint.oPosition.nY = m_nScreenY + nTy - nSy - 1;
  414. m_sBigPoint.oEndPos.nX = m_sBigPoint.oPosition.nX + 3;
  415. m_sBigPoint.oEndPos.nY = m_sBigPoint.oPosition.nY + 3;
  416. g_pRepresent->DrawPrimitives(1, &m_sBigPoint, RU_T_SHADOW, true);
  417. }
  418. }
  419. }
  420. // 队友
  421. for (i = 0; i < MAX_TEAM_MEMBER; i++)
  422. {
  423. if (g_Team[0].m_nMember[i] <= 0 || (DWORD)g_Team[0].m_nMember[i] == Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwID)
  424. continue;
  425. nNpcIdx = NpcSet.SearchID(g_Team[0].m_nMember[i]);
  426. if (nNpcIdx <= 0 || Npc[nNpcIdx].m_RegionIndex == -1)
  427. continue;
  428. nRx = LOWORD(Npc[nNpcIdx].m_dwRegionID);
  429. nRy = HIWORD(Npc[nNpcIdx].m_dwRegionID);
  430. if (nRx < m_sMapRect.left || nRx > m_sMapRect.right || nRy < m_sMapRect.top || nRy > m_sMapRect.bottom)
  431. continue;
  432. nOx = Npc[nNpcIdx].m_MapX;
  433. nOy = Npc[nNpcIdx].m_MapY;
  434. nTx = nRx * REGION_GRID_WIDTH + nOx;
  435. nTy = nRy * REGION_GRID_HEIGHT + nOy;
  437. m_sBigPoint.Color.Color_dw = m_sTeammateColor.Color_dw;
  438. m_sBigPoint.oPosition.nX = m_nScreenX + (nTx - nSx) * 2 - 1;
  439. m_sBigPoint.oPosition.nY = m_nScreenY + nTy - nSy - 1;
  440. m_sBigPoint.oEndPos.nX = m_sBigPoint.oPosition.nX + 3;
  441. m_sBigPoint.oEndPos.nY = m_sBigPoint.oPosition.nY + 3;
  442. g_pRepresent->DrawPrimitives(1, &m_sBigPoint, RU_T_SHADOW, true);
  443. }
  444. }
  446. // 显示主角位置
  447. nRx = nX / REGION_GRID_WIDTH;
  448. nRy = nY / REGION_GRID_HEIGHT;
  449. if (nRx < m_sMapRect.left || nRx > m_sMapRect.right || nRy < m_sMapRect.top || nRy > m_sMapRect.bottom)
  450. return;
  451. nRx -= m_sMapRect.left;
  452. nRy -= m_sMapRect.top;
  453. nOx = nX % REGION_GRID_WIDTH;
  454. nOy = nY % REGION_GRID_HEIGHT;
  456. m_sBigPoint.Color.Color_dw = m_sSelfColor.Color_dw;
  457. m_sBigPoint.oPosition.nX = m_nScreenX + (nX - nSx) * 2 - 1;
  458. m_sBigPoint.oPosition.nY = m_nScreenY + nY - nSy - 1;
  459. m_sBigPoint.oEndPos.nX = m_sBigPoint.oPosition.nX + 3;
  460. m_sBigPoint.oEndPos.nY = m_sBigPoint.oPosition.nY + 3;
  461. g_pRepresent->DrawPrimitives(1, &m_sBigPoint, RU_T_SHADOW, true);
  462. }
  464. //---------------------------------------------------------------------------
  465. // 功能：队友显示开关
  466. //---------------------------------------------------------------------------
  467. void KLittleMap::SetTeammateShow(BOOL bFlag)
  468. {
  469. this->m_bTeammateShowFlag = bFlag;
  470. }
  472. //---------------------------------------------------------------------------
  473. // 功能：其它玩家显示开关
  474. //---------------------------------------------------------------------------
  475. void KLittleMap::SetPlayerShow(BOOL bFlag)
  476. {
  477. this->m_bPlayerShowFlag = bFlag;
  478. }
  480. //---------------------------------------------------------------------------
  481. // 功能：战斗npc显示开关
  482. //---------------------------------------------------------------------------
  483. void KLittleMap::SetFightNpcShow(BOOL bFlag)
  484. {
  485. this->m_bFightNpcShowFlag = bFlag;
  486. }
  488. //---------------------------------------------------------------------------
  489. // 功能：普通npc显示开关
  490. //---------------------------------------------------------------------------
  491. void KLittleMap::SetNormalNpcShow(BOOL bFlag)
  492. {
  493. this->m_bNormalNpcShowFlag = bFlag;
  494. }
  496. //---------------------------------------------------------------------------
  497. // 功能：设定小地图在屏幕上的显示位置
  498. //---------------------------------------------------------------------------
  499. void KLittleMap::SetScreenPos(int nX, int nY)
  500. {
  501. m_nScreenX = nX;
  502. m_nScreenY = nY;
  503. }
  505. //---------------------------------------------------------------------------
  506. // 功能：小地图显示开关
  507. //---------------------------------------------------------------------------
  508. void KLittleMap::Show(int nFlag)
  509. {
  510. this->m_nShowFlag = nFlag;
  511. }
  513. //---------------------------------------------------------------------------
  514. // 功能：设定显示内容的大小
  515. //---------------------------------------------------------------------------
  516. void KLittleMap::SetShowSize(int nWidth, int nHeight)
  517. {
  518. nWidth /= REGION_GRID_WIDTH * 2;
  519. nHeight /= REGION_GRID_HEIGHT;
  520. if (nWidth < 3)
  521. nWidth = 3;
  522. if (nHeight < 3)
  523. nHeight = 3;
  524. if (nWidth > 20)
  525. nWidth = 20;
  526. if (nHeight > 15)
  527. nHeight = 15;
  528. this->m_nShowWidth = nWidth;
  529. this->m_nShowHeight = nHeight;
  531. // for test
  532. // int i, j;
  533. // int x, y;
  534. // x = LOWORD(Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwRegionID) - m_nShowWidth / 2;
  535. // y = HIWORD(Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_dwRegionID) - m_nShowHeight / 2;
  536. // for (i = x; i < x + m_nShowWidth; i++)
  537. // {
  538. // for (j = y; j < y + m_nShowHeight; j++)
  539. // {
  540. // KRegion::LoadLittleMapData(i, j, SubWorld[0].m_szMapPath, GetBarrierBuf(i, j));
  541. // SetHaveLoad(i, j);
  542. // }
  543. // }
  544. }
  546. #endif