Guest User

Untitled

a guest
Jun 1st, 2017
214
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 11.41 KB | None | 0 0
  1. #ifndef __INC_GUILD_H
  2. #define __INC_GUILD_H
  3.  
  4. #include "skill.h"
  5.  
  6. typedef struct _SQLMsg SQLMsg;
  7.  
  8. enum
  9. {
  10. GUILD_GRADE_NAME_MAX_LEN = 8,
  11. GUILD_GRADE_COUNT = 15,
  12. GUILD_COMMENT_MAX_COUNT = 12,
  13. GUILD_COMMENT_MAX_LEN = 50,
  14. GUILD_LEADER_GRADE = 1,
  15. GUILD_BASE_POWER = 400,
  16. GUILD_POWER_PER_SKILL_LEVEL = 200,
  17. GUILD_POWER_PER_LEVEL = 100,
  18. GUILD_MINIMUM_LEADERSHIP = 40,
  19. GUILD_WAR_MIN_MEMBER_COUNT = 8,
  20. GUILD_LADDER_POINT_PER_LEVEL = 1000,
  21. GUILD_CREATE_ITEM_VNUM = 70101,
  22. };
  23.  
  24. struct SGuildMaster
  25. {
  26. DWORD pid;
  27. };
  28.  
  29.  
  30. typedef struct SGuildMember
  31. {
  32. DWORD pid; // player 테이블의 id; primary key
  33. BYTE grade; // 길드상의 플레이어의 계급 1 to 15 (1이 짱)
  34. BYTE is_general;
  35. BYTE job;
  36. BYTE level;
  37. DWORD offer_exp; // 공헌한 경험치
  38. BYTE _dummy;
  39.  
  40. std::string name;
  41.  
  42. SGuildMember(LPCHARACTER ch, BYTE grade, DWORD offer_exp);
  43. SGuildMember(DWORD pid, BYTE grade, BYTE is_general, BYTE job, BYTE level, DWORD offer_exp, char* name);
  44.  
  45. } TGuildMember;
  46.  
  47. #pragma pack(1)
  48. typedef struct SGuildMemberPacketData
  49. {
  50. DWORD pid;
  51. BYTE grade;
  52. BYTE is_general;
  53. BYTE job;
  54. BYTE level;
  55. DWORD offer;
  56. BYTE name_flag;
  57. char name[CHARACTER_NAME_MAX_LEN+1];
  58. } TGuildMemberPacketData;
  59.  
  60. typedef struct packet_guild_sub_info
  61. {
  62. WORD member_count;
  63. WORD max_member_count;
  64. DWORD guild_id;
  65. DWORD master_pid;
  66. DWORD exp;
  67. BYTE level;
  68. char name[GUILD_NAME_MAX_LEN+1];
  69. DWORD gold;
  70. BYTE has_land;
  71. } TPacketGCGuildInfo;
  72.  
  73. typedef struct SGuildGrade
  74. {
  75. char grade_name[GUILD_GRADE_NAME_MAX_LEN+1]; // 8+1 길드장, 길드원 등의 이름
  76. BYTE auth_flag;
  77. } TGuildGrade;
  78.  
  79. struct TOneGradeNamePacket
  80. {
  81. BYTE grade;
  82. char grade_name[GUILD_GRADE_NAME_MAX_LEN+1];
  83. };
  84.  
  85. struct TOneGradeAuthPacket
  86. {
  87. BYTE grade;
  88. BYTE auth;
  89. };
  90. #pragma pack()
  91.  
  92. enum
  93. {
  94. GUILD_AUTH_ADD_MEMBER = (1 << 0),
  95. GUILD_AUTH_REMOVE_MEMBER = (1 << 1),
  96. GUILD_AUTH_NOTICE = (1 << 2),
  97. GUILD_AUTH_USE_SKILL = (1 << 3),
  98. };
  99.  
  100. typedef struct SGuildData
  101. {
  102. DWORD guild_id;
  103. DWORD master_pid;
  104. DWORD exp;
  105. BYTE level;
  106. char name[GUILD_NAME_MAX_LEN+1];
  107.  
  108. TGuildGrade grade_array[GUILD_GRADE_COUNT];
  109.  
  110. BYTE skill_point;
  111. BYTE abySkill[GUILD_SKILL_COUNT];
  112.  
  113. int power;
  114. int max_power;
  115.  
  116. int ladder_point;
  117.  
  118. int win;
  119. int draw;
  120. int loss;
  121.  
  122. int gold;
  123. #ifdef __DUNGEON_FOR_GUILD__
  124. BYTE dungeon_ch;
  125. long dungeon_map;
  126. DWORD dungeon_cooldown;
  127. #endif
  128. } TGuildData;
  129.  
  130. struct TGuildCreateParameter
  131. {
  132. LPCHARACTER master;
  133. char name[GUILD_NAME_MAX_LEN+1];
  134. };
  135.  
  136. typedef struct SGuildWar
  137. {
  138. DWORD war_start_time;
  139. DWORD score;
  140. DWORD state;
  141. BYTE type;
  142. DWORD map_index;
  143.  
  144. SGuildWar(BYTE type)
  145. : war_start_time(0),
  146. score(0),
  147. state(GUILD_WAR_RECV_DECLARE),
  148. type(type),
  149. map_index(0)
  150. {
  151. }
  152. bool IsWarBegin() const
  153. {
  154. return state == GUILD_WAR_ON_WAR;
  155. }
  156. } TGuildWar;
  157.  
  158. class CGuild
  159. {
  160. public:
  161. CGuild(TGuildCreateParameter& cp);
  162. explicit CGuild(DWORD guild_id) { Load(guild_id); }
  163. ~CGuild();
  164.  
  165. DWORD GetID() const { return m_data.guild_id; }
  166. const char* GetName() const { return m_data.name; }
  167. int GetSP() const { return m_data.power; }
  168. int GetMaxSP() { return m_data.max_power; }
  169. DWORD GetMasterPID() const { return m_data.master_pid; }
  170. LPCHARACTER GetMasterCharacter();
  171. BYTE GetLevel() const { return m_data.level; }
  172.  
  173. void Reset() { m_data.power = m_data.max_power; }
  174.  
  175. void RequestDisband(DWORD pid);
  176. void Disband();
  177.  
  178. void RequestAddMember(LPCHARACTER ch, int grade = 15);
  179. void AddMember(TPacketDGGuildMember * p);
  180.  
  181. bool RequestRemoveMember(DWORD pid);
  182. bool RemoveMember(DWORD pid);
  183.  
  184. void LoginMember(LPCHARACTER ch);
  185. void P2PLoginMember(DWORD pid);
  186.  
  187. void LogoutMember(LPCHARACTER ch);
  188. void P2PLogoutMember(DWORD pid);
  189.  
  190. void ChangeMemberGrade(DWORD pid, BYTE grade);
  191. bool OfferExp(LPCHARACTER ch, int amount);
  192. void LevelChange(DWORD pid, BYTE level);
  193. void ChangeMemberData(DWORD pid, DWORD offer, BYTE level, BYTE grade);
  194.  
  195. void ChangeGradeName(BYTE grade, const char* grade_name);
  196. void ChangeGradeAuth(BYTE grade, BYTE auth);
  197. void P2PChangeGrade(BYTE grade);
  198.  
  199. bool ChangeMemberGeneral(DWORD pid, BYTE is_general);
  200.  
  201. bool ChangeMasterTo(DWORD dwPID);
  202.  
  203. void Packet(const void* buf, int size);
  204.  
  205. void SendOnlineRemoveOnePacket(DWORD pid);
  206. void SendAllGradePacket(LPCHARACTER ch);
  207. void SendListPacket(LPCHARACTER ch);
  208. void SendListOneToAll(DWORD pid);
  209. void SendListOneToAll(LPCHARACTER ch);
  210. void SendLoginPacket(LPCHARACTER ch, LPCHARACTER chLogin);
  211. void SendLogoutPacket(LPCHARACTER ch, LPCHARACTER chLogout);
  212. void SendLoginPacket(LPCHARACTER ch, DWORD pid);
  213. void SendLogoutPacket(LPCHARACTER ch, DWORD pid);
  214. void SendGuildInfoPacket(LPCHARACTER ch);
  215. void SendGuildDataUpdateToAllMember(SQLMsg* pmsg);
  216.  
  217. void Load(DWORD guild_id);
  218. void SaveLevel();
  219. void SaveSkill();
  220. void SaveMember(DWORD pid);
  221.  
  222. int GetMaxMemberCount();
  223. int GetMemberCount() { return m_member.size(); }
  224. int GetTotalLevel() const;
  225.  
  226. // GUILD_MEMBER_COUNT_BONUS
  227. void SetMemberCountBonus(int iBonus);
  228. void BroadcastMemberCountBonus();
  229. // END_OF_GUILD_MEMBER_COUNT_BONUS
  230.  
  231. int GetMaxGeneralCount() const { return 1 /*+ GetSkillLevel(GUILD_SKILL_DEUNGYONG)/3*/;}
  232. int GetGeneralCount() const { return m_general_count; }
  233.  
  234. TGuildMember* GetMember(DWORD pid);
  235. DWORD GetMemberPID(const std::string& strName);
  236.  
  237. bool HasGradeAuth(int grade, int auth_flag) const { return (bool)(m_data.grade_array[grade-1].auth_flag & auth_flag);}
  238.  
  239. void AddComment(LPCHARACTER ch, const std::string& str);
  240. void DeleteComment(LPCHARACTER ch, DWORD comment_id);
  241.  
  242. void RefreshComment(LPCHARACTER ch);
  243. void RefreshCommentForce(DWORD player_id);
  244.  
  245. int GetSkillLevel(DWORD vnum);
  246. void SkillLevelUp(DWORD dwVnum);
  247. void UseSkill(DWORD dwVnum, LPCHARACTER ch, DWORD pid);
  248.  
  249. void SendSkillInfoPacket(LPCHARACTER ch) const;
  250. void ComputeGuildPoints();
  251.  
  252. void GuildPointChange( BYTE type, int amount, bool save = false );
  253.  
  254. //void GuildUpdateAffect(LPCHARACTER ch);
  255. //void GuildRemoveAffect(LPCHARACTER ch);
  256.  
  257. void UpdateSkill(BYTE grade, BYTE* skill_levels);
  258. void SendDBSkillUpdate(int amount = 0);
  259.  
  260. void SkillRecharge();
  261. bool ChargeSP(LPCHARACTER ch, int iSP);
  262.  
  263. void Chat(const char* c_pszText);
  264. void P2PChat(const char* c_pszText); // 길드 채팅
  265.  
  266. void SkillUsableChange(DWORD dwSkillVnum, bool bUsable);
  267. void AdvanceLevel(int iLevel);
  268.  
  269. // Guild Money
  270. void RequestDepositMoney(LPCHARACTER ch, int iGold);
  271. void RequestWithdrawMoney(LPCHARACTER ch, int iGold);
  272.  
  273. void RecvMoneyChange(int iGold);
  274. void RecvWithdrawMoneyGive(int iChangeGold); // bGive==1 이면 길드장에게 주는 걸 시도하고 성공실패를 디비에게 보낸다
  275.  
  276. int GetGuildMoney() const { return m_data.gold; }
  277.  
  278. // War general
  279. void GuildWarPacket(DWORD guild_id, BYTE bWarType, BYTE bWarState);
  280. void SendEnemyGuild(LPCHARACTER ch);
  281.  
  282. int GetGuildWarState(DWORD guild_id);
  283. bool CanStartWar(BYTE bGuildWarType);
  284. DWORD GetWarStartTime(DWORD guild_id);
  285. bool UnderWar(DWORD guild_id); // 전쟁중인가?
  286. DWORD UnderAnyWar(BYTE bType = GUILD_WAR_TYPE_MAX_NUM);
  287.  
  288. // War map relative
  289. void SetGuildWarMapIndex(DWORD dwGuildID, long lMapIndex);
  290. int GetGuildWarType(DWORD dwGuildOpponent);
  291. DWORD GetGuildWarMapIndex(DWORD dwGuildOpponent);
  292.  
  293. // War entry question
  294. void GuildWarEntryAsk(DWORD guild_opp);
  295. void GuildWarEntryAccept(DWORD guild_opp, LPCHARACTER ch);
  296.  
  297. // War state relative
  298. void NotifyGuildMaster(const char* msg);
  299. void RequestDeclareWar(DWORD guild_id, BYTE type);
  300. void RequestRefuseWar(DWORD guild_id);
  301.  
  302. bool DeclareWar(DWORD guild_id, BYTE type, BYTE state);
  303. void RefuseWar(DWORD guild_id);
  304. bool WaitStartWar(DWORD guild_id);
  305. bool CheckStartWar(DWORD guild_id); // check if StartWar method fails (call it before StartWar)
  306. void StartWar(DWORD guild_id);
  307. void EndWar(DWORD guild_id);
  308. void ReserveWar(DWORD guild_id, BYTE type);
  309.  
  310. // War points relative
  311. void SetWarScoreAgainstTo(DWORD guild_opponent, int newpoint);
  312. int GetWarScoreAgainstTo(DWORD guild_opponent);
  313.  
  314. int GetLadderPoint() const { return m_data.ladder_point; }
  315. void SetLadderPoint(int point);
  316.  
  317. void SetWarData(int iWin, int iDraw, int iLoss) { m_data.win = iWin, m_data.draw = iDraw, m_data.loss = iLoss; }
  318.  
  319. void ChangeLadderPoint(int iChange);
  320.  
  321. int GetGuildWarWinCount() const { return m_data.win; }
  322. int GetGuildWarDrawCount() const { return m_data.draw; }
  323. int GetGuildWarLossCount() const { return m_data.loss; }
  324.  
  325. bool HasLand();
  326.  
  327. // GUILD_JOIN_BUG_FIX
  328. /// character 에게 길드가입 초대를 한다.
  329. /**
  330. * @param pchInviter 초대한 character.
  331. * @param pchInvitee 초대할 character.
  332. *
  333. * 초대하거나 받을수 없는 상태라면 해당하는 채팅 메세지를 전송한다.
  334. */
  335. void Invite( LPCHARACTER pchInviter, LPCHARACTER pchInvitee );
  336.  
  337. /// 길드초대에 대한 상대 character 의 수락을 처리한다.
  338. /**
  339. * @param pchInvitee 초대받은 character
  340. *
  341. * 길드에 가입가능한 상태가 아니라면 해당하는 채팅 메세지를 전송한다.
  342. */
  343. void InviteAccept( LPCHARACTER pchInvitee );
  344.  
  345. /// 길드초대에 대한 상대 character 의 거부를 처리한다.
  346. /**
  347. * @param dwPID 초대받은 character 의 PID
  348. */
  349. void InviteDeny( DWORD dwPID );
  350. // END_OF_GUILD_JOIN_BUG_FIX
  351.  
  352. private:
  353. void Initialize();
  354.  
  355. TGuildData m_data;
  356. int m_general_count;
  357.  
  358. // GUILD_MEMBER_COUNT_BONUS
  359. int m_iMemberCountBonus;
  360. // END_OF_GUILD_MEMBER_COUNT_BONUS
  361.  
  362. typedef std::map<DWORD, TGuildMember> TGuildMemberContainer;
  363. TGuildMemberContainer m_member;
  364.  
  365. typedef CHARACTER_SET TGuildMemberOnlineContainer;
  366. TGuildMemberOnlineContainer m_memberOnline;
  367.  
  368. typedef std::set<DWORD> TGuildMemberP2POnlineContainer;
  369. TGuildMemberP2POnlineContainer m_memberP2POnline;
  370.  
  371. void LoadGuildData(SQLMsg* pmsg);
  372. void LoadGuildGradeData(SQLMsg* pmsg);
  373. void LoadGuildMemberData(SQLMsg* pmsg);
  374.  
  375. void __P2PUpdateGrade(SQLMsg* pmsg);
  376.  
  377. typedef std::map<DWORD, TGuildWar> TEnemyGuildContainer;
  378. TEnemyGuildContainer m_EnemyGuild;
  379.  
  380. std::map<DWORD, DWORD> m_mapGuildWarEndTime;
  381.  
  382. bool abSkillUsable[GUILD_SKILL_COUNT];
  383.  
  384. // GUILD_JOIN_BUG_FIX
  385. /// 길드 가입을 할 수 없을 경우의 에러코드.
  386. enum GuildJoinErrCode {
  387. GERR_NONE = 0, ///< 처리성공
  388. GERR_WITHDRAWPENALTY, ///< 탈퇴후 가입가능한 시간이 지나지 않음
  389. GERR_COMMISSIONPENALTY, ///< 해산후 가입가능한 시간이 지나지 않음
  390. GERR_ALREADYJOIN, ///< 길드가입 대상 캐릭터가 이미 길드에 가입해 있음
  391. GERR_GUILDISFULL, ///< 길드인원 제한 초과
  392. GERR_GUILD_IS_IN_WAR, ///< 길드가 현재 전쟁중
  393. GERR_INVITE_LIMIT, ///< 길드원 가입 제한 상태
  394. GERR_MAX ///< Error code 최고치. 이 앞에 Error code 를 추가한다.
  395. };
  396.  
  397. /// 길드에 가입 가능한 조건을 검사한다.
  398. /**
  399. * @param [in] pchInvitee 초대받는 character
  400. * @return GuildJoinErrCode
  401. */
  402. GuildJoinErrCode VerifyGuildJoinableCondition( const LPCHARACTER pchInvitee );
  403.  
  404. typedef std::map< DWORD, LPEVENT > EventMap;
  405. EventMap m_GuildInviteEventMap; ///< 길드 초청 Event map. key: 초대받은 캐릭터의 PID
  406. // END_OF_GUILD_JOIN_BUG_FIX
  407. };
  408.  
  409. #endif
Advertisement
Add Comment
Please, Sign In to add comment