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

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

模拟服务器

开发平台：

C/C++

KPlayerPK.cpp：源码内容
  1. //---------------------------------------------------------------------------
  2. // Sword3 Engine (c) 2003 by Kingsoft
  3. //
  4. // File: KPlayerPK.cpp
  5. // Date: 2003.07.15
  6. // Code: 边城浪子
  7. // Desc: PlayerPK Class
  8. //---------------------------------------------------------------------------
  11. #include "KCore.h"
  12. #include "KPlayer.h"
  13. #include "KPlayerDef.h"
  14. #include "KPlayerPK.h"
  16. #ifndef _SERVER
  17. #include "CoreShell.h"
  18. #endif
  20. #ifdef _SERVER
  22. //-------------------------------------------------------------------------
  23. // 功能：构造函数
  24. //-------------------------------------------------------------------------
  25. KPlayerPK::KPlayerPK()
  26. {
  27. m_nPlayerIndex = 0;
  28. }
  30. //-------------------------------------------------------------------------
  31. // 功能：初始化
  32. //-------------------------------------------------------------------------
  33. void KPlayerPK::Init(int nPlayerIdx)
  34. {
  35. this->m_nPlayerIndex = nPlayerIdx;
  37. m_nNormalPKFlag = 1;
  38. m_nEnmityPKState = enumPK_ENMITY_STATE_CLOSE;
  39. m_nEnmityPKAim = 0;
  40. m_nEnmityPKTime = 0;
  41. m_nEnmityPKLaunchFlag = 0;
  42. m_nExercisePKFlag = 0;
  43. m_nExercisePKAim = 0;
  44. m_nPKValue = 0;
  45. }
  47. void KPlayerPK::Active()
  48. {
  49. EnmityPKCountDown();
  50. }
  52. //-------------------------------------------------------------------------
  53. // 功能：设定正常PK状态 TRUE 打开，可以砍人  FALSE 关闭，不可以砍人
  54. //-------------------------------------------------------------------------
  55. void KPlayerPK::SetNormalPKState(BOOL bFlag)
  56. {
  57. m_nNormalPKFlag = bFlag;
  59. PK_NORMAL_FLAG_SYNC sFlag;
  60. sFlag.ProtocolType = s2c_pksyncnormalflag;
  61. sFlag.m_btFlag = m_nNormalPKFlag;
  62. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, (BYTE*)&sFlag, sizeof(PK_NORMAL_FLAG_SYNC));
  63. }
  65. //-------------------------------------------------------------------------
  66. // 功能：获得正常PK状态 TRUE 打开，可以砍人  FALSE 关闭，不可以砍人
  67. //-------------------------------------------------------------------------
  68. BOOL KPlayerPK::GetNormalPKState()
  69. {
  70. return this->m_nNormalPKFlag;
  71. }
  73. //-------------------------------------------------------------------------
  74. // 功能：关闭仇杀PK
  75. //-------------------------------------------------------------------------
  76. void KPlayerPK::EnmityPKClose()
  77. {
  78. if (m_nEnmityPKState == enumPK_ENMITY_STATE_CLOSE)
  79. return;
  81. PK_ENMITY_STATE_SYNC sState;
  82. sState.ProtocolType = s2c_pksyncenmitystate;
  83. sState.m_btState = enumPK_ENMITY_STATE_CLOSE;
  84. sState.m_dwNpcID = 0;
  85. sState.m_wLength = sizeof(PK_ENMITY_STATE_SYNC) - 1 - sizeof(sState.m_szName);
  86. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, (BYTE*)&sState, sState.m_wLength + 1);
  88. if (m_nEnmityPKAim > 0 && m_nEnmityPKAim < MAX_PLAYER)
  89. {
  90. g_pServer->PackDataToClient(Player[m_nEnmityPKAim].m_nNetConnectIdx, (BYTE*)&sState, sState.m_wLength + 1);
  92. Player[m_nEnmityPKAim].m_cPK.m_nEnmityPKState = enumPK_ENMITY_STATE_CLOSE;
  93. Player[m_nEnmityPKAim].m_cPK.m_nEnmityPKAim = 0;
  94. Player[m_nEnmityPKAim].m_cPK.m_nEnmityPKTime = 0;
  95. }
  96. this->m_nEnmityPKState = enumPK_ENMITY_STATE_CLOSE;
  97. this->m_nEnmityPKAim = 0;
  98. this->m_nEnmityPKTime = 0;
  99. m_nEnmityPKLaunchFlag = 0;
  100. }
  102. //-------------------------------------------------------------------------
  103. // 功能：仇杀PK开始
  104. //-------------------------------------------------------------------------
  105. BOOL KPlayerPK::EnmityPKOpen(int nAim)
  106. {
  107. // 出错
  108. if (nAim <= 0 || nAim >= MAX_PLAYER || Player[nAim].m_nIndex < 1)
  109. return FALSE;
  110. // 非战斗模式
  111. if (!Npc[Player[m_nPlayerIndex].m_nIndex].m_FightMode)
  112. {
  113. SHOW_MSG_SYNC sMsg;
  114. sMsg.ProtocolType = s2c_msgshow;
  115. sMsg.m_wMsgID = enumMSG_ID_PK_ERROR_1;
  116. sMsg.m_wLength = sizeof(SHOW_MSG_SYNC) - 1 - sizeof(LPVOID);
  117. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, &sMsg, sMsg.m_wLength + 1);
  118. return FALSE;
  119. }
  120. if (!Npc[Player[nAim].m_nIndex].m_FightMode)
  121. {
  122. SHOW_MSG_SYNC sMsg;
  123. sMsg.ProtocolType = s2c_msgshow;
  124. sMsg.m_wMsgID = enumMSG_ID_PK_ERROR_6;
  125. sMsg.m_wLength = sizeof(SHOW_MSG_SYNC) - 1 - sizeof(LPVOID);
  126. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, &sMsg, sMsg.m_wLength + 1);
  127. return FALSE;
  128. }
  129. // 自己是新手
  130. if (Npc[Player[m_nPlayerIndex].m_nIndex].m_Camp == camp_begin)
  131. {
  132. SHOW_MSG_SYNC sMsg;
  133. sMsg.ProtocolType = s2c_msgshow;
  134. sMsg.m_wMsgID = enumMSG_ID_PK_ERROR_2;
  135. sMsg.m_wLength = sizeof(SHOW_MSG_SYNC) - 1 - sizeof(LPVOID);
  136. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, &sMsg, sMsg.m_wLength + 1);
  137. return FALSE;
  138. }
  139. // 正在切磋
  140. if (m_nExercisePKFlag == TRUE)
  141. {
  142. SHOW_MSG_SYNC sMsg;
  143. sMsg.ProtocolType = s2c_msgshow;
  144. sMsg.m_wMsgID = enumMSG_ID_PK_ERROR_3;
  145. sMsg.m_wLength = sizeof(SHOW_MSG_SYNC) - 1 - sizeof(LPVOID);
  146. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, &sMsg, sMsg.m_wLength + 1);
  147. return FALSE;
  148. }
  149. // 对方正在切磋
  150. if (Player[nAim].m_cPK.GetExercisePKState())
  151. {
  152. SHOW_MSG_SYNC sMsg;
  153. sMsg.ProtocolType = s2c_msgshow;
  154. sMsg.m_wMsgID = enumMSG_ID_PK_ERROR_7;
  155. sMsg.m_wLength = sizeof(SHOW_MSG_SYNC) - 1 - sizeof(LPVOID);
  156. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, &sMsg, sMsg.m_wLength + 1);
  157. return FALSE;
  158. }
  159. // 正在仇杀
  160. if (m_nEnmityPKState != enumPK_ENMITY_STATE_CLOSE)
  161. {
  162. SHOW_MSG_SYNC sMsg;
  163. sMsg.ProtocolType = s2c_msgshow;
  164. sMsg.m_wMsgID = enumMSG_ID_PK_ERROR_4;
  165. sMsg.m_wLength = sizeof(SHOW_MSG_SYNC) - 1 - sizeof(LPVOID);
  166. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, &sMsg, sMsg.m_wLength + 1);
  167. return FALSE;
  168. }
  169. // 对方是新手
  170. if (Npc[Player[nAim].m_nIndex].m_Camp == camp_begin)
  171. {
  172. SHOW_MSG_SYNC sMsg;
  173. sMsg.ProtocolType = s2c_msgshow;
  174. sMsg.m_wMsgID = enumMSG_ID_PK_ERROR_5;
  175. sMsg.m_wLength = sizeof(SHOW_MSG_SYNC) - 1 - sizeof(LPVOID);
  176. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, &sMsg, sMsg.m_wLength + 1);
  177. return FALSE;
  178. }
  180. Player[nAim].m_cPK.EnmityPKClose();
  181. Player[nAim].m_cPK.m_nEnmityPKState = enumPK_ENMITY_STATE_TIME;
  182. Player[nAim].m_cPK.m_nEnmityPKAim = m_nPlayerIndex;
  183. Player[nAim].m_cPK.m_nEnmityPKTime = PK_ANMITY_TIME;
  184. Player[nAim].m_cPK.m_nEnmityPKLaunchFlag = 0;
  186. m_nEnmityPKState = enumPK_ENMITY_STATE_TIME;
  187. m_nEnmityPKAim = nAim;
  188. m_nEnmityPKTime = PK_ANMITY_TIME;
  189. m_nEnmityPKLaunchFlag = 1;
  191. PK_ENMITY_STATE_SYNC sState;
  192. sState.ProtocolType = s2c_pksyncenmitystate;
  193. sState.m_btState = enumPK_ENMITY_STATE_TIME;
  195. sState.m_dwNpcID = Npc[Player[m_nPlayerIndex].m_nIndex].m_dwID;
  196. strcpy(sState.m_szName, Npc[Player[m_nPlayerIndex].m_nIndex].Name);
  197. sState.m_wLength = sizeof(PK_ENMITY_STATE_SYNC) - 1 - sizeof(sState.m_szName) + strlen(sState.m_szName);
  198. g_pServer->PackDataToClient(Player[nAim].m_nNetConnectIdx, (BYTE*)&sState, sState.m_wLength + 1);
  200. sState.m_dwNpcID = Npc[Player[nAim].m_nIndex].m_dwID;
  201. strcpy(sState.m_szName, Npc[Player[nAim].m_nIndex].Name);
  202. sState.m_wLength = sizeof(PK_ENMITY_STATE_SYNC) - 1 - sizeof(sState.m_szName) + strlen(sState.m_szName);
  203. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, (BYTE*)&sState, sState.m_wLength + 1);
  205. return TRUE;
  206. }
  208. //-------------------------------------------------------------------------
  209. // 功能：获得仇杀状态，对应 enumPK_ANMITY_STATE
  210. //-------------------------------------------------------------------------
  211. int KPlayerPK::GetEnmityPKState()
  212. {
  213. return this->m_nEnmityPKState;
  214. }
  216. //-------------------------------------------------------------------------
  217. // 功能：获得仇杀目标 if 目标==0 不在仇杀状态 else 得到仇杀目标
  218. //-------------------------------------------------------------------------
  219. int KPlayerPK::GetEnmityPKAim()
  220. {
  221. return this->m_nEnmityPKAim;
  222. }
  224. //-------------------------------------------------------------------------
  225. // 功能：关闭切磋PK
  226. //-------------------------------------------------------------------------
  227. void KPlayerPK::ExercisePKClose()
  228. {
  229. if (m_nExercisePKFlag == FALSE)
  230. return;
  232. PK_EXERCISE_STATE_SYNC sState;
  233. sState.ProtocolType = s2c_pksyncexercisestate;
  234. sState.m_btState = 0;
  235. sState.m_dwNpcID = 0;
  236. sState.m_wLength = sizeof(PK_EXERCISE_STATE_SYNC) - 1 - sizeof(sState.m_szName);
  237. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, (BYTE*)&sState, sState.m_wLength + 1);
  239. if (m_nExercisePKAim > 0 && m_nExercisePKAim < MAX_PLAYER)
  240. {
  241. g_pServer->PackDataToClient(Player[m_nExercisePKAim].m_nNetConnectIdx, (BYTE*)&sState, sState.m_wLength + 1);
  243. Player[m_nExercisePKAim].m_cPK.m_nExercisePKFlag = FALSE;
  244. Player[m_nExercisePKAim].m_cPK.m_nExercisePKAim = 0;
  245. }
  246. this->m_nExercisePKFlag = FALSE;
  247. this->m_nExercisePKAim = 0;
  248. }
  250. //-------------------------------------------------------------------------
  251. // 功能：打开切磋PK
  252. //-------------------------------------------------------------------------
  253. BOOL KPlayerPK::ExercisePKOpen(int nAim)
  254. {
  255. // 自己是新手
  256. if (Npc[Player[m_nPlayerIndex].m_nIndex].m_Camp == camp_begin)
  257. return FALSE;
  258. // 正在切磋
  259. if (m_nExercisePKFlag == TRUE)
  260. return FALSE;
  261. // 出错
  262. if (nAim <= 0 || nAim >= MAX_PLAYER || Player[nAim].m_nIndex < 1)
  263. return FALSE;
  264. // 对方是新手
  265. if (Npc[Player[nAim].m_nIndex].m_Camp == camp_begin)
  266. return FALSE;
  268. this->EnmityPKClose();
  269. Player[nAim].m_cPK.EnmityPKClose();
  270. this->m_nExercisePKFlag = TRUE;
  271. this->m_nExercisePKAim = nAim;
  272. Player[nAim].m_cPK.m_nExercisePKFlag = TRUE;
  273. Player[nAim].m_cPK.m_nExercisePKAim = this->m_nPlayerIndex;
  275. PK_EXERCISE_STATE_SYNC sState;
  276. sState.ProtocolType = s2c_pksyncexercisestate;
  277. sState.m_btState = 1;
  279. sState.m_dwNpcID = Npc[Player[m_nPlayerIndex].m_nIndex].m_dwID;
  280. strcpy(sState.m_szName, Npc[Player[m_nPlayerIndex].m_nIndex].Name);
  281. sState.m_wLength = sizeof(PK_EXERCISE_STATE_SYNC) - 1 - sizeof(sState.m_szName) + strlen(sState.m_szName);
  282. g_pServer->PackDataToClient(Player[nAim].m_nNetConnectIdx, (BYTE*)&sState, sState.m_wLength + 1);
  284. sState.m_dwNpcID = Npc[Player[nAim].m_nIndex].m_dwID;
  285. strcpy(sState.m_szName, Npc[Player[nAim].m_nIndex].Name);
  286. sState.m_wLength = sizeof(PK_EXERCISE_STATE_SYNC) - 1 - sizeof(sState.m_szName) + strlen(sState.m_szName);
  287. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, (BYTE*)&sState, sState.m_wLength + 1);
  289. return TRUE;
  290. }
  292. //-------------------------------------------------------------------------
  293. // 功能：获得切磋目标 if 目标==0 不在切磋状态 else 得到切磋目标
  294. //-------------------------------------------------------------------------
  295. int KPlayerPK::GetExercisePKAim()
  296. {
  297. return this->m_nExercisePKAim;
  298. }
  300. //-------------------------------------------------------------------------
  301. // 功能：设定PK值
  302. //-------------------------------------------------------------------------
  303. void KPlayerPK::SetPKValue(int nValue)
  304. {
  305. this->m_nPKValue = (nValue < 0 ? 0 : nValue);
  306. if (m_nPKValue > MAX_DEATH_PUNISH_PK_VALUE)
  307. m_nPKValue = MAX_DEATH_PUNISH_PK_VALUE;
  309. PK_VALUE_SYNC sValue;
  310. sValue.ProtocolType = s2c_pksyncpkvalue;
  311. sValue.m_nPKValue = m_nPKValue;
  312. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, (BYTE*)&sValue, sizeof(PK_VALUE_SYNC));
  313. }
  315. //-------------------------------------------------------------------------
  316. // 功能：获得PK值
  317. //-------------------------------------------------------------------------
  318. int KPlayerPK::GetPKValue()
  319. {
  320. return m_nPKValue;
  321. }
  323. //-------------------------------------------------------------------------
  324. // 功能：增加(或减少)PK值，PK值最多减少到0
  325. //-------------------------------------------------------------------------
  326. void KPlayerPK::AddPKValue(int nAdd)
  327. {
  328. m_nPKValue += nAdd;
  329. if (m_nPKValue < 0)
  330. m_nPKValue = 0;
  331. if (m_nPKValue > MAX_DEATH_PUNISH_PK_VALUE)
  332. m_nPKValue = MAX_DEATH_PUNISH_PK_VALUE;
  334. PK_VALUE_SYNC sValue;
  335. sValue.ProtocolType = s2c_pksyncpkvalue;
  336. sValue.m_nPKValue = m_nPKValue;
  337. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, (BYTE*)&sValue, sizeof(PK_VALUE_SYNC));
  338. }
  340. //-------------------------------------------------------------------------
  341. // 功能：关闭仇杀PK和切磋PK
  342. //-------------------------------------------------------------------------
  343. void KPlayerPK::CloseAll()
  344. {
  345. ExercisePKClose();
  346. EnmityPKClose();
  347. }
  349. //-------------------------------------------------------------------------
  350. // 功能：仇杀倒计时
  351. //-------------------------------------------------------------------------
  352. void KPlayerPK::EnmityPKCountDown()
  353. {
  354. if (m_nEnmityPKState == enumPK_ENMITY_STATE_TIME)
  355. {
  356. m_nEnmityPKTime--;
  357. if (m_nEnmityPKTime > 0)
  358. return;
  359. m_nEnmityPKTime = PK_ANMITY_CLOSE_TIME;
  360. m_nEnmityPKState = enumPK_ENMITY_STATE_PKING;
  362. if (Player[m_nEnmityPKAim].m_nIndex <= 0)
  363. return;
  364. PK_ENMITY_STATE_SYNC sState;
  365. sState.ProtocolType = s2c_pksyncenmitystate;
  366. sState.m_btState = enumPK_ENMITY_STATE_PKING;
  367. sState.m_dwNpcID = Npc[Player[m_nEnmityPKAim].m_nIndex].m_dwID;
  368. strcpy(sState.m_szName, Npc[Player[m_nEnmityPKAim].m_nIndex].Name);
  369. sState.m_wLength = sizeof(PK_ENMITY_STATE_SYNC) - 1 - sizeof(sState.m_szName) + strlen(sState.m_szName);
  370. g_pServer->PackDataToClient(Player[m_nPlayerIndex].m_nNetConnectIdx, (BYTE*)&sState, sState.m_wLength + 1);
  371. }
  372. else if (m_nEnmityPKState == enumPK_ENMITY_STATE_PKING)
  373. {
  374. m_nEnmityPKTime--;
  375. if (m_nEnmityPKTime > 0)
  376. return;
  377. m_nEnmityPKTime = 0;
  378. ExercisePKClose();
  379. }
  380. }
  382. #endif
  384. #ifndef _SERVER
  386. //-------------------------------------------------------------------------
  387. // 功能：初始化
  388. //-------------------------------------------------------------------------
  389. void KPlayerPK::Init()
  390. {
  391. // m_nNormalPKFlag = 1;
  392. m_nEnmityPKState = enumPK_ENMITY_STATE_CLOSE;
  393. m_nEnmityPKAim = 0;
  394. m_nEnmityPKTime = 0;
  395. m_szEnmityAimName[0] = 0;
  396. m_nExercisePKFlag = 0;
  397. m_nExercisePKAim = 0;
  398. m_szExerciseAimName[0] = 0;
  399. // m_nPKValue = 0;
  400. }
  402. void KPlayerPK::Active()
  403. {
  404. EnmityPKCountDown();
  405. }
  407. //-------------------------------------------------------------------------
  408. // 功能：设定正常PK状态 TRUE 打开，可以砍人  FALSE 关闭，不可以砍人
  409. //-------------------------------------------------------------------------
  410. void KPlayerPK::SetNormalPKState(BOOL bFlag, BOOL bShowMsg/* = TRUE*/)
  411. {
  412. if (m_nNormalPKFlag == bFlag)
  413. return;
  415. m_nNormalPKFlag = bFlag;
  416. CoreDataChanged(GDCNI_PK_SETTING, 0, bFlag);
  418. if (bShowMsg)
  419. {
  420. KSystemMessage sMsg;
  421. if (bFlag)
  422. sprintf(sMsg.szMessage, MSG_PK_NORMAL_FLAG_OPEN);
  423. else
  424. sprintf(sMsg.szMessage, MSG_PK_NORMAL_FLAG_CLOSE);
  425. sMsg.eType = SMT_NORMAL;
  426. sMsg.byConfirmType = SMCT_NONE;
  427. sMsg.byPriority = 0;
  428. sMsg.byParamSize = 0;
  429. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  430. }
  431. }
  433. //-------------------------------------------------------------------------
  434. // 功能：向服务器申请打开、关闭正常PK状态
  435. //-------------------------------------------------------------------------
  436. void KPlayerPK::ApplySetNormalPKState(BOOL bFlag)
  437. {
  438. // SetNormalPKState(bFlag, FALSE);
  439. PK_APPLY_NORMAL_FLAG_COMMAND sApply;
  440. sApply.ProtocolType = c2s_pkapplychangenormalflag;
  441. sApply.m_btFlag = bFlag;
  442. if (g_pClient)
  443. g_pClient->SendPackToServer(&sApply, sizeof(PK_APPLY_NORMAL_FLAG_COMMAND));
  445. }
  447. //-------------------------------------------------------------------------
  448. // 功能：获得正常PK状态 TRUE 打开，可以砍人  FALSE 关闭，不可以砍人
  449. //-------------------------------------------------------------------------
  450. BOOL KPlayerPK::GetNormalPKState()
  451. {
  452. return this->m_nNormalPKFlag;
  453. }
  455. //-------------------------------------------------------------------------
  456. // 功能：向服务器申请仇杀某人
  457. //-------------------------------------------------------------------------
  458. void KPlayerPK::ApplyEnmityPK(char *lpszName)
  459. {
  460. if (!lpszName || !lpszName[0])
  461. return;
  462. int nNpcIdx;
  463. nNpcIdx = NpcSet.SearchName(lpszName);
  464. if (nNpcIdx <= 0)
  465. return;
  466. ApplyEnmityPK(Npc[nNpcIdx].m_dwID);
  467. }
  469. //-------------------------------------------------------------------------
  470. // 功能：向服务器申请仇杀某人
  471. //-------------------------------------------------------------------------
  472. void KPlayerPK::ApplyEnmityPK(int nNpcID)
  473. {
  474. if (m_nEnmityPKState != enumPK_ENMITY_STATE_CLOSE)
  475. {
  476. KSystemMessage sMsg;
  477. sprintf(sMsg.szMessage, MSG_PK_ERROR_4);
  478. sMsg.eType = SMT_NORMAL;
  479. sMsg.byConfirmType = SMCT_NONE;
  480. sMsg.byPriority = 0;
  481. sMsg.byParamSize = 0;
  482. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  483. return;
  484. }
  485. if (!Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_FightMode)
  486. {
  487. KSystemMessage sMsg;
  488. sprintf(sMsg.szMessage, MSG_PK_ERROR_1);
  489. sMsg.eType = SMT_NORMAL;
  490. sMsg.byConfirmType = SMCT_NONE;
  491. sMsg.byPriority = 0;
  492. sMsg.byParamSize = 0;
  493. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  494. return;
  495. }
  496. int nIdx = NpcSet.SearchID(nNpcID);
  497. if (nIdx == 0 || Npc[nIdx].m_Kind != kind_player)
  498. return;
  500. PK_APPLY_ENMITY_COMMAND sApply;
  501. sApply.ProtocolType = c2s_pkapplyenmity;
  502. sApply.m_dwNpcID = nNpcID;
  503. if (g_pClient)
  504. g_pClient->SendPackToServer(&sApply, sizeof(PK_APPLY_ENMITY_COMMAND));
  505. }
  507. //-------------------------------------------------------------------------
  508. // 功能：设定仇杀PK状态
  509. //-------------------------------------------------------------------------
  510. void KPlayerPK::SetEnmityPKState(int nState, int nNpcID/* = 0*/, char *lpszName/* = NULL*/)
  511. {
  512. if (nState == enumPK_ENMITY_STATE_CLOSE)
  513. {
  514. if (m_nEnmityPKState != enumPK_ENMITY_STATE_CLOSE)
  515. {
  516. KSystemMessage sMsg;
  517. sMsg.eType = SMT_NORMAL;
  518. sMsg.byConfirmType = SMCT_NONE;
  519. sMsg.byPriority = 0;
  520. sMsg.byParamSize = 0;
  521. sprintf(sMsg.szMessage, MSG_PK_ENMITY_CLOSE);
  522. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  523. }
  525. m_nEnmityPKState = enumPK_ENMITY_STATE_CLOSE;
  526. m_nEnmityPKAim = 0;
  527. m_nEnmityPKTime = 0;
  528. m_szEnmityAimName[0] = 0;
  529. }
  530. else if (nState == enumPK_ENMITY_STATE_TIME)
  531. {
  532. m_nEnmityPKState = enumPK_ENMITY_STATE_CLOSE;
  533. m_nEnmityPKAim = nNpcID;
  534. m_nEnmityPKTime = PK_ANMITY_TIME;
  535. m_szEnmityAimName[0] = 0;
  536. if (lpszName)
  537. strcpy(m_szEnmityAimName, lpszName);
  539. KSystemMessage sMsg;
  540. sMsg.eType = SMT_NORMAL;
  541. sMsg.byConfirmType = SMCT_NONE;
  542. sMsg.byPriority = 0;
  543. sMsg.byParamSize = 0;
  544. sprintf(sMsg.szMessage, MSG_PK_ENMITY_SUCCESS_1, m_szEnmityAimName);
  545. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  546. sprintf(sMsg.szMessage, MSG_PK_ENMITY_SUCCESS_2);
  547. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  548. }
  549. else // if (nState == enumPK_ENMITY_STATE_PKING)
  550. {
  551. m_nEnmityPKState = enumPK_ENMITY_STATE_PKING;
  552. m_nEnmityPKTime = 0;
  553. if (nNpcID > 0)
  554. m_nEnmityPKAim = nNpcID;
  555. if (lpszName)
  556. strcpy(m_szEnmityAimName, lpszName);
  558. KSystemMessage sMsg;
  559. sMsg.eType = SMT_NORMAL;
  560. sMsg.byConfirmType = SMCT_NONE;
  561. sMsg.byPriority = 0;
  562. sMsg.byParamSize = 0;
  563. sprintf(sMsg.szMessage, MSG_PK_ENMITY_OPEN);
  564. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  565. }
  566. }
  568. //-------------------------------------------------------------------------
  569. // 功能：仇杀倒计时
  570. //-------------------------------------------------------------------------
  571. void KPlayerPK::EnmityPKCountDown()
  572. {
  573. if (m_nEnmityPKState == enumPK_ENMITY_STATE_TIME)
  574. {
  575. m_nEnmityPKTime--;
  576. if (m_nEnmityPKTime < 0)
  577. m_nEnmityPKTime = 0;
  578. }
  579. }
  581. //-------------------------------------------------------------------------
  582. // 功能：设定切磋状态
  583. //-------------------------------------------------------------------------
  584. void KPlayerPK::SetExercisePKState(int nState, int nNpcID/* = 0*/, char *lpszName/* = NULL*/)
  585. {
  586. SetEnmityPKState(enumPK_ENMITY_STATE_CLOSE);
  588. if (nState)
  589. {
  590. m_nExercisePKFlag = 1;
  591. m_nExercisePKAim = nNpcID;
  592. m_szExerciseAimName[0] = 0;
  593. if (lpszName)
  594. strcpy(m_szExerciseAimName, lpszName);
  595. }
  596. else
  597. {
  598. m_nExercisePKFlag = 0;
  599. m_nExercisePKAim = 0;
  600. m_szExerciseAimName[0] = 0;
  601. }
  602. }
  604. //-------------------------------------------------------------------------
  605. // 功能：设定PK值
  606. //-------------------------------------------------------------------------
  607. void KPlayerPK::SetPKValue(int nValue)
  608. {
  609. if (m_nPKValue == nValue)
  610. return;
  612. this->m_nPKValue = (nValue < 0 ? 0 : nValue);
  613. if (m_nPKValue > MAX_DEATH_PUNISH_PK_VALUE)
  614. m_nPKValue = MAX_DEATH_PUNISH_PK_VALUE;
  616. KSystemMessage sMsg;
  617. sprintf(sMsg.szMessage, MSG_PK_VALUE, m_nPKValue);
  618. sMsg.eType = SMT_NORMAL;
  619. sMsg.byConfirmType = SMCT_NONE;
  620. sMsg.byPriority = 0;
  621. sMsg.byParamSize = 0;
  622. CoreDataChanged(GDCNI_SYSTEM_MESSAGE, (unsigned int)&sMsg, 0);
  624. }
  626. #endif