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

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

模拟服务器

开发平台：

C/C++

KPolygon.cpp：源码内容
  1. //---------------------------------------------------------------------------
  2. // Sword3 Engine (c) 1999-2000 by Kingsoft
  3. //
  4. // File: KPolygon.cpp
  5. // Date: 2002.01.10
  6. // Code: Spe
  7. // Desc: Polygon Functions
  8. //---------------------------------------------------------------------------
  9. #include "KWin32.h"
  10. #include "KDebug.h"
  11. #include "KPolygon.h"
  12. #include <string.h>
  13. //////////////////////////////
  14. // Construction/Destruction //
  15. //////////////////////////////
  17. KPolygon::KPolygon()
  18. {
  19. m_Polygon.nVertex = 0;
  20. ZeroMemory(m_Polygon.Pos, sizeof(POINT) * defMaxVertex);
  21. }
  23. BOOL KPolygon::IsPointInPolygon(POINT pos)
  24. {
  25. static POINT pPos[defMaxVertex+1];
  26. BOOL bRet = TRUE;
  27. int nFlag[2];
  28. int nResult;
  29. register int i;
  31. for (i = 0; i < m_Polygon.nVertex; i++)
  32. {
  33. pPos[i].x = m_Polygon.Pos[i].x - pos.x;
  34. pPos[i].y = m_Polygon.Pos[i].y - pos.y;
  35. }
  36. pPos[m_Polygon.nVertex] = pPos[0];
  37. nFlag[1] = 0;
  38. for (i = 0; i < m_Polygon.nVertex; i++)
  39. {
  40. nResult = pPos[i].x * pPos[i + 1].y - pPos[i + 1].x * pPos[i].y;
  41. nFlag[0]=(nResult>0)?1:((nResult<0)?-1:0);
  42. if (nFlag[0])
  43. {
  44. if (!nFlag[1])
  45. {
  46. nFlag[1] = nFlag[0];
  47. }
  48. if (nFlag[0] != nFlag[1])
  49. {
  50. bRet = FALSE;
  51. break;
  52. }
  53. }
  54. }
  55. return bRet;
  56. }
  58. BOOL KPolygon::IsPointInPolygon(int x, int y)
  59. {
  60. static POINT pPos[defMaxVertex+1];
  61. BOOL bRet = TRUE;
  62. int nFlag[2];
  63. int nResult;
  64. register int i;
  66. for (i = 0; i < m_Polygon.nVertex; i++)
  67. {
  68. pPos[i].x = m_Polygon.Pos[i].x - x;
  69. pPos[i].y = m_Polygon.Pos[i].y - y;
  70. }
  71. pPos[m_Polygon.nVertex] = pPos[0];
  72. nFlag[1] = 0;
  73. for (i = 0; i < m_Polygon.nVertex; i++)
  74. {
  75. nResult = pPos[i].x * pPos[i + 1].y - pPos[i + 1].x * pPos[i].y;
  76. nFlag[0]=(nResult>0)?1:((nResult<0)?-1:0);
  77. if (nFlag[0])
  78. {
  79. if (!nFlag[1])
  80. {
  81. nFlag[1] = nFlag[0];
  82. }
  83. if (nFlag[0] != nFlag[1])
  84. {
  85. bRet = FALSE;
  86. break;
  87. }
  88. }
  89. }
  90. return bRet;
  91. }
  94. int KPolygon::GetNearVertex(POINT pos)
  95. {
  96. int i;
  97. int nMin = 0x7fffffff;
  98. int nIndex;
  100. for (i = 0; i < m_Polygon.nVertex; i++)
  101. {
  102. if ((m_Polygon.Pos[i].x - pos.x) * (m_Polygon.Pos[i].x - pos.x) + (m_Polygon.Pos[i].y - pos.y) * (m_Polygon.Pos[i].y - pos.y) < nMin)
  103. {
  104. nIndex = i;
  105. nMin = (m_Polygon.Pos[i].x - pos.x) * (m_Polygon.Pos[i].x - pos.x) + (m_Polygon.Pos[i].y - pos.y) * (m_Polygon.Pos[i].y - pos.y);
  106. }
  107. }
  108. return nIndex;
  109. }
  111. BOOL KPolygon::GetIndexVertex(int i, POINT* vertex)
  112. {
  113. if (i >= m_Polygon.nVertex)
  114. return FALSE;
  115. vertex->x = m_Polygon.Pos[i].x;
  116. vertex->y = m_Polygon.Pos[i].y;
  117. return TRUE;
  118. }
  120. BOOL KPolygon::RemoveIndexVertex(int index)
  121. {
  122. if (m_Polygon.nVertex < 4)
  123. return FALSE;
  125. m_Polygon.nVertex --;
  126. for (int i = index; i < defMaxVertex - 1; i++)
  127. {
  128. m_Polygon.Pos[i] = m_Polygon.Pos[i+1];
  129. }
  130. return TRUE;
  131. }
  133. BOOL KPolygon::AddPointToVertex(POINT pos)
  134. {
  135. int nPrevIndex, nNextIndex;
  137. if (m_Polygon.nVertex < 3)
  138. {
  139. m_Polygon.Pos[m_Polygon.nVertex] = pos;
  140. m_Polygon.nVertex++;
  141. return TRUE;
  142. }
  144. if (m_Polygon.nVertex >= defMaxVertex)
  145. return FALSE;
  146. //-------------------------------------------------------------------
  147. // Add Point to Polygon Last point First
  148. POINT pVector[2];
  149. int nResult, nFlag[2];
  151. m_Polygon.Pos[m_Polygon.nVertex] = pos;
  152. nFlag[1] = 0;
  153. for (int i = 0; i < m_Polygon.nVertex + 1; i++)
  154. {
  155. nPrevIndex = i - 1;
  156. if (nPrevIndex < 0)
  157. nPrevIndex = m_Polygon.nVertex;
  158. nNextIndex = i + 1;
  159. if (nNextIndex > m_Polygon.nVertex)
  160. nNextIndex = 0;
  161. // Get Vector of point to next point
  162. pVector[0].x = m_Polygon.Pos[nNextIndex].x - m_Polygon.Pos[i].x;
  163. pVector[0].y = m_Polygon.Pos[nNextIndex].y - m_Polygon.Pos[i].y;
  164. // Get Vector of point to previous point
  165. pVector[1].x = m_Polygon.Pos[nPrevIndex].x - m_Polygon.Pos[i].x;
  166. pVector[1].y = m_Polygon.Pos[nPrevIndex].y - m_Polygon.Pos[i].y;
  168. nResult = pVector[0].x * pVector[1].y - pVector[1].x * pVector[0].y;
  169. nFlag[0] = (nResult > 0)?1:((nResult < 0)?-1:0);
  170. if (nFlag[0])
  171. {
  172. if (!nFlag[1])
  173. {
  174. nFlag[1] = nFlag[0];
  175. }
  176. if (nFlag[0] != nFlag[1])
  177. {
  178. m_Polygon.Pos[m_Polygon.nVertex].x = 0;
  179. m_Polygon.Pos[m_Polygon.nVertex].y = 0;
  180. return FALSE;
  181. }
  182. }
  183. }
  184. //-------------------------------------------------------------------
  185. m_Polygon.nVertex++;
  186. return TRUE;
  187. }
  189. BOOL KPolygon::AddPointToVertex(int x, int y)
  190. {
  191. int nPrevIndex, nNextIndex;
  193. if (m_Polygon.nVertex < 3)
  194. {
  195. m_Polygon.Pos[m_Polygon.nVertex].x = x;
  196. m_Polygon.Pos[m_Polygon.nVertex].y = y;
  197. m_Polygon.nVertex++;
  198. return TRUE;
  199. }
  201. if (m_Polygon.nVertex >= defMaxVertex)
  202. return FALSE;
  203. //-------------------------------------------------------------------
  204. // Add Point to Polygon Last point First
  205. POINT pVector[2];
  206. int nResult, nFlag[2];
  208. m_Polygon.Pos[m_Polygon.nVertex].x = x;
  209. m_Polygon.Pos[m_Polygon.nVertex].y = y;
  210. nFlag[1] = 0;
  211. for (int i = 0; i < m_Polygon.nVertex + 1; i++)
  212. {
  213. nPrevIndex = i - 1;
  214. if (nPrevIndex < 0)
  215. nPrevIndex = m_Polygon.nVertex;
  216. nNextIndex = i + 1;
  217. if (nNextIndex > m_Polygon.nVertex)
  218. nNextIndex = 0;
  219. // Get Vector of point to next point
  220. pVector[0].x = m_Polygon.Pos[nNextIndex].x - m_Polygon.Pos[i].x;
  221. pVector[0].y = m_Polygon.Pos[nNextIndex].y - m_Polygon.Pos[i].y;
  222. // Get Vector of point to previous point
  223. pVector[1].x = m_Polygon.Pos[nPrevIndex].x - m_Polygon.Pos[i].x;
  224. pVector[1].y = m_Polygon.Pos[nPrevIndex].y - m_Polygon.Pos[i].y;
  226. nResult = pVector[0].x * pVector[1].y - pVector[1].x * pVector[0].y;
  227. nFlag[0] = (nResult > 0)?1:((nResult < 0)?-1:0);
  228. if (nFlag[0])
  229. {
  230. if (!nFlag[1])
  231. {
  232. nFlag[1] = nFlag[0];
  233. }
  234. if (nFlag[0] != nFlag[1])
  235. {
  236. m_Polygon.Pos[m_Polygon.nVertex].x = 0;
  237. m_Polygon.Pos[m_Polygon.nVertex].y = 0;
  238. return FALSE;
  239. }
  240. }
  241. }
  242. //-------------------------------------------------------------------
  243. m_Polygon.nVertex++;
  244. return TRUE;
  245. }
  248. void KPolygon::LoopVertex(int nTurn)
  249. {
  250. if (nTurn > m_Polygon.nVertex)
  251. return;
  252. if (nTurn < 0)
  253. nTurn = m_Polygon.nVertex + nTurn;
  254. int nNext;
  255. POINT BackPos[defMaxVertex];
  256. memcpy(BackPos, m_Polygon.Pos, sizeof(POINT) * defMaxVertex);
  257. for (int j = 0; j < m_Polygon.nVertex; j++)
  258. {
  259. nNext = j + nTurn;
  260. if (nNext >= m_Polygon.nVertex)
  261. nNext -= m_Polygon.nVertex;
  262. m_Polygon.Pos[j] = BackPos[nNext];
  263. }
  264. }
  266. void KPolygon::Clear()
  267. {
  268. m_Polygon.nVertex = 0;
  269. ZeroMemory(m_Polygon.Pos, sizeof(POINT) * defMaxVertex);
  270. }
  272. void KPolygon::GetCenterPos(POINT *pos)
  273. {
  274. pos->x = 0;
  275. pos->y = 0;
  276. for (int i = 0; i < m_Polygon.nVertex; i++)
  277. {
  278. pos->x += m_Polygon.Pos[i].x;
  279. pos->y += m_Polygon.Pos[i].y;
  280. }
  281. pos->x /= m_Polygon.nVertex;
  282. pos->y /= m_Polygon.nVertex;
  283. }
  285. BOOL KPolygon::ShiftVertex(int nDir, int nDistance)
  286. {
  287. int i;
  289. switch(nDir)
  290. {
  291. case 0:
  292. for (i = 0; i < m_Polygon.nVertex; i++)
  293. {
  294. m_Polygon.Pos[i].y += nDistance;
  295. }
  296. break;
  297. case 1:
  298. for (i = 0; i < m_Polygon.nVertex; i++)
  299. {
  300. m_Polygon.Pos[i].x -= nDistance;
  301. m_Polygon.Pos[i].y += nDistance;
  302. }
  303. break;
  304. case 2:
  305. for (i = 0; i < m_Polygon.nVertex; i++)
  306. {
  307. m_Polygon.Pos[i].x -= nDistance;
  308. }
  309. break;
  310. case 3:
  311. for (i = 0; i < m_Polygon.nVertex; i++)
  312. {
  313. m_Polygon.Pos[i].x -= nDistance;
  314. m_Polygon.Pos[i].y -= nDistance;
  315. }
  316. break;
  317. case 4:
  318. for (i = 0; i < m_Polygon.nVertex; i++)
  319. {
  320. m_Polygon.Pos[i].y -= nDistance;
  321. }
  322. break;
  323. case 5:
  324. for (i = 0; i < m_Polygon.nVertex; i++)
  325. {
  326. m_Polygon.Pos[i].x += nDistance;
  327. m_Polygon.Pos[i].y -= nDistance;
  328. }
  329. break;
  330. case 6:
  331. for (i = 0; i < m_Polygon.nVertex; i++)
  332. {
  333. m_Polygon.Pos[i].x += nDistance;
  334. }
  335. break;
  336. case 7:
  337. for (i = 0; i < m_Polygon.nVertex; i++)
  338. {
  339. m_Polygon.Pos[i].x += nDistance;
  340. m_Polygon.Pos[i].y += nDistance;
  341. }
  342. break;
  343. default:
  344. return FALSE;
  345. }
  347. return TRUE;
  348. }
  350. int KPolygon::GetLeftVertex()
  351. {
  352. int nLeft = m_Polygon.Pos[0].x;
  353. int nIdx = 0;
  355. for (int i = 1; i < m_Polygon.nVertex; i++)
  356. {
  357. if (m_Polygon.Pos[i].x < nLeft)
  358. {
  359. nLeft = m_Polygon.Pos[i].x;
  360. nIdx = i;
  361. }
  362. }
  363. return nIdx;
  364. }
  366. int KPolygon::GetRightVertex()
  367. {
  368. int nRight = m_Polygon.Pos[0].x;
  369. int nIdx = 0;
  371. for (int i = 1; i < m_Polygon.nVertex; i++)
  372. {
  373. if (m_Polygon.Pos[i].x > nRight)
  374. {
  375. nRight = m_Polygon.Pos[i].x;
  376. nIdx = i;
  377. }
  378. }
  379. return nIdx;
  380. }