1. #include "stdafx.h"
  2. #include "constants.h"
  3. #include "../../common/teen_packet.h"
  4. #include "config.h"
  5. #include "utils.h"
  6. #include "input.h"
  7. #include "desc_client.h"
  8. #include "desc_manager.h"
  9. #include "char.h"
  10. #include "char_manager.h"
  11. #include "cmd.h"
  12. #include "buffer_manager.h"
  13. #include "protocol.h"
  14. #include "pvp.h"
  15. #include "New_PetSystem.h"
  16. #include "start_position.h"
  17. #include "messenger_manager.h"
  18. #include "guild_manager.h"
  19. #include "party.h"
  20. #include "dungeon.h"
  21. #include "war_map.h"
  22. #include "questmanager.h"
  23. #include "building.h"
  24. #include "wedding.h"
  25. #include "affect.h"
  26. #include "arena.h"
  27. #include "OXEvent.h"
  28. #include "priv_manager.h"
  29. #include "block_country.h"
  30. #include "dev_log.h"
  31. #include "log.h"
  32. #include "horsename_manager.h"
  33. #include "MarkManager.h"
  34. #include "HackShield.h"
  35. #include "XTrapManager.h"
  36. #include "questlua.h"
  37. #ifdef ENABLE_ATTENDANCE_EVENT
  38. #include "minigame.h"
  39. #endif
  40. #ifdef __MELEY_LAIR_DUNGEON__
  41. #include "MeleyLair.h"
  42. #endif
  43. #include "../../common/CommonDefines.h"
  44. #include "../../common/service.h"
  46. #ifdef ENABLE_DUNGEON_INFORMATION
  47. #include "DungeonInformation.h"
  48. #endif
  50. #ifdef ENABLE_WOLFMAN_CHARACTER
  52. // #define USE_LYCAN_CREATE_POSITION
  53. #ifdef USE_LYCAN_CREATE_POSITION
  55. DWORD g_lycan_create_position[4][2] =
  56. {
  57. { 0, 0 },
  58. { 768000+38300, 896000+35500 },
  59. { 819200+38300, 896000+35500 },
  60. { 870400+38300, 896000+35500 },
  61. };
  63. inline DWORD LYCAN_CREATE_START_X(BYTE e, BYTE job)
  64. {
  65. if (1 <= e && e <= 3)
  66. return (job==JOB_WOLFMAN)?g_lycan_create_position[e][0]:g_create_position[e][0];
  67. return 0;
  68. }
  70. inline DWORD LYCAN_CREATE_START_Y(BYTE e, BYTE job)
  71. {
  72. if (1 <= e && e <= 3)
  73. return (job==JOB_WOLFMAN)?g_lycan_create_position[e][1]:g_create_position[e][1];
  74. return 0;
  75. }
  77. #endif
  80. #endif
  82. static void _send_bonus_info(LPCHARACTER ch)
  83. {
  84. int item_drop_bonus = 0;
  85. int gold_drop_bonus = 0;
  86. int gold10_drop_bonus = 0;
  87. int exp_bonus = 0;
  89. item_drop_bonus = CPrivManager::instance().GetPriv(ch, PRIV_ITEM_DROP);
  90. gold_drop_bonus = CPrivManager::instance().GetPriv(ch, PRIV_GOLD_DROP);
  91. gold10_drop_bonus = CPrivManager::instance().GetPriv(ch, PRIV_GOLD10_DROP);
  92. exp_bonus = CPrivManager::instance().GetPriv(ch, PRIV_EXP_PCT);
  94. if (item_drop_bonus)
  95. {
  96. ch->ChatPacket(CHAT_TYPE_NOTICE,
  97. LC_TEXT("아이템 드롭률 %d%% 추가 이벤트 중입니다."), item_drop_bonus);
  98. }
  99. if (gold_drop_bonus)
  100. {
  101. ch->ChatPacket(CHAT_TYPE_NOTICE,
  102. LC_TEXT("골드 드롭률 %d%% 추가 이벤트 중입니다."), gold_drop_bonus);
  103. }
  104. if (gold10_drop_bonus)
  105. {
  106. ch->ChatPacket(CHAT_TYPE_NOTICE,
  107. LC_TEXT("대박골드 드롭률 %d%% 추가 이벤트 중입니다."), gold10_drop_bonus);
  108. }
  109. if (exp_bonus)
  110. {
  111. ch->ChatPacket(CHAT_TYPE_NOTICE,
  112. LC_TEXT("경험치 %d%% 추가 획득 이벤트 중입니다."), exp_bonus);
  113. }
  114. }
  116. static bool FN_is_battle_zone(LPCHARACTER ch)
  117. {
  118. switch (ch->GetMapIndex())
  119. {
  120. case 1: // 신수 1차 마을
  121. case 2: // 신수 2차 마을
  122. case 21: // 천조 1차 마을
  123. case 23: // 천조 2차 마을
  124. case 41: // 진노 1차 마을
  125. case 43: // 진노 2차 마을
  126. case 113: // OX 맵
  127. return false;
  128. }
  130. return true;
  131. }
  133. void CInputLogin::Login(LPDESC d, const char * data)
  134. {
  135. TPacketCGLogin * pinfo = (TPacketCGLogin *) data;
  137. char login[LOGIN_MAX_LEN + 1];
  138. trim_and_lower(pinfo->login, login, sizeof(login));
  140. sys_log(0, "InputLogin::Login : %s", login);
  142. TPacketGCLoginFailure failurePacket;
  144. if (!test_server)
  145. {
  146. failurePacket.header = HEADER_GC_LOGIN_FAILURE;
  147. strlcpy(failurePacket.szStatus, "VERSION", sizeof(failurePacket.szStatus));
  148. d->Packet(&failurePacket, sizeof(TPacketGCLoginFailure));
  149. return;
  150. }
  152. if (g_bNoMoreClient)
  153. {
  154. failurePacket.header = HEADER_GC_LOGIN_FAILURE;
  155. strlcpy(failurePacket.szStatus, "SHUTDOWN", sizeof(failurePacket.szStatus));
  156. d->Packet(&failurePacket, sizeof(TPacketGCLoginFailure));
  157. return;
  158. }
  160. if (g_iUserLimit > 0)
  161. {
  162. int iTotal;
  163. int * paiEmpireUserCount;
  164. int iLocal;
  166. DESC_MANAGER::instance().GetUserCount(iTotal, &paiEmpireUserCount, iLocal);
  168. if (g_iUserLimit <= iTotal)
  169. {
  170. failurePacket.header = HEADER_GC_LOGIN_FAILURE;
  171. strlcpy(failurePacket.szStatus, "FULL", sizeof(failurePacket.szStatus));
  172. d->Packet(&failurePacket, sizeof(TPacketGCLoginFailure));
  173. return;
  174. }
  175. }
  177. TLoginPacket login_packet;
  179. strlcpy(login_packet.login, login, sizeof(login_packet.login));
  180. strlcpy(login_packet.passwd, pinfo->passwd, sizeof(login_packet.passwd));
  182. db_clientdesc->DBPacket(HEADER_GD_LOGIN, d->GetHandle(), &login_packet, sizeof(TLoginPacket));
  183. }
  185. void CInputLogin::LoginByKey(LPDESC d, const char * data)
  186. {
  187. TPacketCGLogin2 * pinfo = (TPacketCGLogin2 *) data;
  189. char login[LOGIN_MAX_LEN + 1];
  190. trim_and_lower(pinfo->login, login, sizeof(login));
  192. // is blocked ip?
  193. {
  194. dev_log(LOG_DEB0, "check_blocked_country_start");
  196. if (!is_block_exception(login) && is_blocked_country_ip(d->GetHostName()))
  197. {
  198. sys_log(0, "BLOCK_COUNTRY_IP (%s)", d->GetHostName());
  199. d->SetPhase(PHASE_CLOSE);
  200. return;
  201. }
  203. dev_log(LOG_DEB0, "check_blocked_country_end");
  204. }
  206. if (g_bNoMoreClient)
  207. {
  208. TPacketGCLoginFailure failurePacket;
  210. failurePacket.header = HEADER_GC_LOGIN_FAILURE;
  211. strlcpy(failurePacket.szStatus, "SHUTDOWN", sizeof(failurePacket.szStatus));
  212. d->Packet(&failurePacket, sizeof(TPacketGCLoginFailure));
  213. return;
  214. }
  216. if (g_iUserLimit > 0)
  217. {
  218. int iTotal;
  219. int * paiEmpireUserCount;
  220. int iLocal;
  222. DESC_MANAGER::instance().GetUserCount(iTotal, &paiEmpireUserCount, iLocal);
  224. if (g_iUserLimit <= iTotal)
  225. {
  226. TPacketGCLoginFailure failurePacket;
  228. failurePacket.header = HEADER_GC_LOGIN_FAILURE;
  229. strlcpy(failurePacket.szStatus, "FULL", sizeof(failurePacket.szStatus));
  231. d->Packet(&failurePacket, sizeof(TPacketGCLoginFailure));
  232. return;
  233. }
  234. }
  236. sys_log(0, "LOGIN_BY_KEY: %s key %u", login, pinfo->dwLoginKey);
  238. d->SetLoginKey(pinfo->dwLoginKey);
  239. #ifndef _IMPROVED_PACKET_ENCRYPTION_
  240. d->SetSecurityKey(pinfo->adwClientKey);
  241. #endif
  243. TPacketGDLoginByKey ptod;
  245. strlcpy(ptod.szLogin, login, sizeof(ptod.szLogin));
  246. ptod.dwLoginKey = pinfo->dwLoginKey;
  247. thecore_memcpy(ptod.adwClientKey, pinfo->adwClientKey, sizeof(DWORD) * 4);
  248. strlcpy(ptod.szIP, d->GetHostName(), sizeof(ptod.szIP));
  250. db_clientdesc->DBPacket(HEADER_GD_LOGIN_BY_KEY, d->GetHandle(), &ptod, sizeof(TPacketGDLoginByKey));
  251. }
  253. void CInputLogin::ChangeName(LPDESC d, const char * data)
  254. {
  255. TPacketCGChangeName * p = (TPacketCGChangeName *) data;
  256. const TAccountTable & c_r = d->GetAccountTable();
  258. if (!c_r.id)
  259. {
  260. sys_err("no account table");
  261. return;
  262. }
  264. if (!c_r.players[p->index].bChangeName)
  265. return;
  267. if (!check_name(p->name))
  268. {
  269. TPacketGCCreateFailure pack;
  270. pack.header = HEADER_GC_CHARACTER_CREATE_FAILURE;
  271. pack.bType = 0;
  272. d->Packet(&pack, sizeof(pack));
  273. return;
  274. }
  276. TPacketGDChangeName pdb;
  278. pdb.pid = c_r.players[p->index].dwID;
  279. strlcpy(pdb.name, p->name, sizeof(pdb.name));
  280. db_clientdesc->DBPacket(HEADER_GD_CHANGE_NAME, d->GetHandle(), &pdb, sizeof(TPacketGDChangeName));
  281. }
  283. void CInputLogin::CharacterSelect(LPDESC d, const char * data)
  284. {
  285. struct command_player_select * pinfo = (struct command_player_select *) data;
  286. const TAccountTable & c_r = d->GetAccountTable();
  288. sys_log(0, "player_select: login: %s index: %d", c_r.login, pinfo->index);
  290. if (!c_r.id)
  291. {
  292. sys_err("no account table");
  293. return;
  294. }
  296. if (pinfo->index >= PLAYER_PER_ACCOUNT)
  297. {
  298. sys_err("index overflow %d, login: %s", pinfo->index, c_r.login);
  299. return;
  300. }
  302. if (c_r.players[pinfo->index].bChangeName)
  303. {
  304. sys_err("name must be changed idx %d, login %s, name %s",
  305. pinfo->index, c_r.login, c_r.players[pinfo->index].szName);
  306. return;
  307. }
  309. TPlayerLoadPacket player_load_packet;
  311. player_load_packet.account_id = c_r.id;
  312. player_load_packet.player_id = c_r.players[pinfo->index].dwID;
  313. player_load_packet.account_index = pinfo->index;
  315. db_clientdesc->DBPacket(HEADER_GD_PLAYER_LOAD, d->GetHandle(), &player_load_packet, sizeof(TPlayerLoadPacket));
  316. }
  318. bool NewPlayerTable(TPlayerTable * table,
  319. const char * name,
  320. BYTE job,
  321. BYTE shape,
  322. BYTE bEmpire,
  323. BYTE bCon,
  324. BYTE bInt,
  325. BYTE bStr,
  326. BYTE bDex)
  327. {
  328. if (job >= JOB_MAX_NUM)
  329. return false;
  331. memset(table, 0, sizeof(TPlayerTable));
  333. strlcpy(table->name, name, sizeof(table->name));
  335. table->level = 1;
  336. table->job = job;
  337. table->voice = 0;
  338. table->part_base = shape;
  340. table->st = JobInitialPoints[job].st;
  341. table->dx = JobInitialPoints[job].dx;
  342. table->ht = JobInitialPoints[job].ht;
  343. table->iq = JobInitialPoints[job].iq;
  345. table->hp = JobInitialPoints[job].max_hp + table->ht * JobInitialPoints[job].hp_per_ht;
  346. table->sp = JobInitialPoints[job].max_sp + table->iq * JobInitialPoints[job].sp_per_iq;
  347. table->stamina = JobInitialPoints[job].max_stamina;
  349. #if defined(ENABLE_WOLFMAN_CHARACTER) && defined(USE_LYCAN_CREATE_POSITION)
  350. table->x = LYCAN_CREATE_START_X(bEmpire, job) + number(-300, 300);
  351. table->y = LYCAN_CREATE_START_Y(bEmpire, job) + number(-300, 300);
  352. #else
  353. table->x = CREATE_START_X(bEmpire) + number(-300, 300);
  354. table->y = CREATE_START_Y(bEmpire) + number(-300, 300);
  355. #endif
  356. table->z = 0;
  357. table->dir = 0;
  358. table->playtime = 0;
  359. table->gold = 0;
  361. table->skill_group = 0;
  363. if (china_event_server)
  364. {
  365. table->level = 35;
  367. for (int i = 1; i < 35; ++i)
  368. {
  369. int iHP = number(JobInitialPoints[job].hp_per_lv_begin, JobInitialPoints[job].hp_per_lv_end);
  370. int iSP = number(JobInitialPoints[job].sp_per_lv_begin, JobInitialPoints[job].sp_per_lv_end);
  371. table->sRandomHP += iHP;
  372. table->sRandomSP += iSP;
  373. table->stat_point += 3;
  374. }
  376. table->hp += table->sRandomHP;
  377. table->sp += table->sRandomSP;
  379. table->gold = 1000000;
  380. }
  382. return true;
  383. }
  385. bool RaceToJob(unsigned race, unsigned* ret_job)
  386. {
  387. *ret_job = 0;
  389. if (race >= MAIN_RACE_MAX_NUM)
  390. return false;
  392. switch (race)
  393. {
  394. case MAIN_RACE_WARRIOR_M:
  395. *ret_job = JOB_WARRIOR;
  396. break;
  398. case MAIN_RACE_WARRIOR_W:
  399. *ret_job = JOB_WARRIOR;
  400. break;
  402. case MAIN_RACE_ASSASSIN_M:
  403. *ret_job = JOB_ASSASSIN;
  404. break;
  406. case MAIN_RACE_ASSASSIN_W:
  407. *ret_job = JOB_ASSASSIN;
  408. break;
  410. case MAIN_RACE_SURA_M:
  411. *ret_job = JOB_SURA;
  412. break;
  414. case MAIN_RACE_SURA_W:
  415. *ret_job = JOB_SURA;
  416. break;
  418. case MAIN_RACE_SHAMAN_M:
  419. *ret_job = JOB_SHAMAN;
  420. break;
  422. case MAIN_RACE_SHAMAN_W:
  423. *ret_job = JOB_SHAMAN;
  424. break;
  425. #ifdef ENABLE_WOLFMAN_CHARACTER
  426. case MAIN_RACE_WOLFMAN_M:
  427. *ret_job = JOB_WOLFMAN;
  428. break;
  429. #endif
  430. default:
  431. return false;
  432. break;
  433. }
  434. return true;
  435. }
  437. // 신규 캐릭터 지원
  438. bool NewPlayerTable2(TPlayerTable * table, const char * name, BYTE race, BYTE shape, BYTE bEmpire)
  439. {
  440. if (race >= MAIN_RACE_MAX_NUM)
  441. {
  442. sys_err("NewPlayerTable2.OUT_OF_RACE_RANGE(%d >= max(%d))\n", race, MAIN_RACE_MAX_NUM);
  443. return false;
  444. }
  446. unsigned job;
  448. if (!RaceToJob(race, &job))
  449. {
  450. sys_err("NewPlayerTable2.RACE_TO_JOB_ERROR(%d)\n", race);
  451. return false;
  452. }
  454. sys_log(0, "NewPlayerTable2(name=%s, race=%d, job=%d)", name, race, job);
  456. memset(table, 0, sizeof(TPlayerTable));
  458. strlcpy(table->name, name, sizeof(table->name));
  460. table->level = 1;
  461. table->job = race; // 직업대신 종족을 넣는다
  462. table->voice = 0;
  463. table->part_base = shape;
  465. table->st = JobInitialPoints[job].st;
  466. table->dx = JobInitialPoints[job].dx;
  467. table->ht = JobInitialPoints[job].ht;
  468. table->iq = JobInitialPoints[job].iq;
  470. table->hp = JobInitialPoints[job].max_hp + table->ht * JobInitialPoints[job].hp_per_ht;
  471. table->sp = JobInitialPoints[job].max_sp + table->iq * JobInitialPoints[job].sp_per_iq;
  472. table->stamina = JobInitialPoints[job].max_stamina;
  474. #if defined(ENABLE_WOLFMAN_CHARACTER) && defined(USE_LYCAN_CREATE_POSITION)
  475. table->x = LYCAN_CREATE_START_X(bEmpire, job) + number(-300, 300);
  476. table->y = LYCAN_CREATE_START_Y(bEmpire, job) + number(-300, 300);
  477. #else
  478. table->x = CREATE_START_X(bEmpire) + number(-300, 300);
  479. table->y = CREATE_START_Y(bEmpire) + number(-300, 300);
  480. #endif
  481. table->z = 0;
  482. table->dir = 0;
  483. table->playtime = 0;
  484. table->gold = 0;
  485. #ifdef ENABLE_GEM_SYSTEM
  486. table->gem = 0;
  487. #endif
  489. table->skill_group = 0;
  491. return true;
  492. }
  494. void CInputLogin::CharacterCreate(LPDESC d, const char * data)
  495. {
  496. struct command_player_create * pinfo = (struct command_player_create *) data;
  497. TPlayerCreatePacket player_create_packet;
  499. sys_log(0, "PlayerCreate: name %s pos %d job %d shape %d",
  500. pinfo->name,
  501. pinfo->index,
  502. pinfo->job,
  503. pinfo->shape);
  505. TPacketGCLoginFailure packFailure;
  506. memset(&packFailure, 0, sizeof(packFailure));
  507. packFailure.header = HEADER_GC_CHARACTER_CREATE_FAILURE;
  509. if (true == g_BlockCharCreation)
  510. {
  511. d->Packet(&packFailure, sizeof(packFailure));
  512. return;
  513. }
  515. // 사용할 수 없는 이름이거나, 잘못된 평상복이면 생설 실패
  516. if (!check_name(pinfo->name) || pinfo->shape > 1)
  517. {
  518. d->Packet(&packFailure, sizeof(packFailure));
  519. return;
  520. }
  522. const TAccountTable & c_rAccountTable = d->GetAccountTable();
  524. if (0 == strcmp(c_rAccountTable.login, pinfo->name))
  525. {
  526. TPacketGCCreateFailure pack;
  527. pack.header = HEADER_GC_CHARACTER_CREATE_FAILURE;
  528. pack.bType = 1;
  530. d->Packet(&pack, sizeof(pack));
  531. return;
  532. }
  534. memset(&player_create_packet, 0, sizeof(TPlayerCreatePacket));
  536. if (!NewPlayerTable2(&player_create_packet.player_table, pinfo->name, pinfo->job, pinfo->shape, d->GetEmpire()))
  537. {
  538. sys_err("player_prototype error: job %d face %d ", pinfo->job);
  539. d->Packet(&packFailure, sizeof(packFailure));
  540. return;
  541. }
  543. trim_and_lower(c_rAccountTable.login, player_create_packet.login, sizeof(player_create_packet.login));
  544. strlcpy(player_create_packet.passwd, c_rAccountTable.passwd, sizeof(player_create_packet.passwd));
  546. player_create_packet.account_id = c_rAccountTable.id;
  547. player_create_packet.account_index = pinfo->index;
  549. sys_log(0, "PlayerCreate: name %s account_id %d, TPlayerCreatePacketSize(%d), Packet->Gold %d",
  550. pinfo->name,
  551. pinfo->index,
  552. sizeof(TPlayerCreatePacket),
  553. player_create_packet.player_table.gold);
  555. db_clientdesc->DBPacket(HEADER_GD_PLAYER_CREATE, d->GetHandle(), &player_create_packet, sizeof(TPlayerCreatePacket));
  556. }
  558. void CInputLogin::CharacterDelete(LPDESC d, const char * data)
  559. {
  560. struct command_player_delete * pinfo = (struct command_player_delete *) data;
  561. const TAccountTable & c_rAccountTable = d->GetAccountTable();
  563. if (!c_rAccountTable.id)
  564. {
  565. sys_err("PlayerDelete: no login data");
  566. return;
  567. }
  569. sys_log(0, "PlayerDelete: login: %s index: %d, social_id %s", c_rAccountTable.login, pinfo->index, pinfo->private_code);
  571. if (pinfo->index >= PLAYER_PER_ACCOUNT)
  572. {
  573. sys_err("PlayerDelete: index overflow %d, login: %s", pinfo->index, c_rAccountTable.login);
  574. return;
  575. }
  577. if (!c_rAccountTable.players[pinfo->index].dwID)
  578. {
  579. sys_err("PlayerDelete: Wrong Social ID index %d, login: %s", pinfo->index, c_rAccountTable.login);
  580. d->Packet(encode_byte(HEADER_GC_CHARACTER_DELETE_WRONG_SOCIAL_ID), 1);
  581. return;
  582. }
  584. TPlayerDeletePacket player_delete_packet;
  586. trim_and_lower(c_rAccountTable.login, player_delete_packet.login, sizeof(player_delete_packet.login));
  587. player_delete_packet.player_id = c_rAccountTable.players[pinfo->index].dwID;
  588. player_delete_packet.account_index = pinfo->index;
  589. strlcpy(player_delete_packet.private_code, pinfo->private_code, sizeof(player_delete_packet.private_code));
  591. db_clientdesc->DBPacket(HEADER_GD_PLAYER_DELETE, d->GetHandle(), &player_delete_packet, sizeof(TPlayerDeletePacket));
  592. }
  594. #pragma pack(1)
  595. typedef struct SPacketGTLogin
  596. {
  597. BYTE header;
  598. WORD empty;
  599. DWORD id;
  600. } TPacketGTLogin;
  601. #pragma pack()
  603. void newPetSystem(LPCHARACTER ch)
  604. {
  605. LPITEM item;
  606. for (int i = 0; i < INVENTORY_MAX_NUM; ++i){
  608. item = ch->GetInventoryItem(i);
  609. if (!item) continue;
  610. if (item->GetVnum() > 55709 || item->GetVnum() < 55701) continue;
  612. if (item->GetSocket(0) != 0){
  613. item->SetSocket(0, 0);
  614. }
  616. }
  617. }
  619. void CInputLogin::Entergame(LPDESC d, const char * data)
  620. {
  621. LPCHARACTER ch;
  623. if (!(ch = d->GetCharacter()))
  624. {
  625. d->SetPhase(PHASE_CLOSE);
  626. return;
  627. }
  629. PIXEL_POSITION pos = ch->GetXYZ();
  631. if (!SECTREE_MANAGER::instance().GetMovablePosition(ch->GetMapIndex(), pos.x, pos.y, pos))
  632. {
  633. PIXEL_POSITION pos2;
  634. SECTREE_MANAGER::instance().GetRecallPositionByEmpire(ch->GetMapIndex(), ch->GetEmpire(), pos2);
  636. sys_err("!GetMovablePosition (name %s %dx%d map %d changed to %dx%d)",
  637. ch->GetName(),
  638. pos.x, pos.y,
  639. ch->GetMapIndex(),
  640. pos2.x, pos2.y);
  641. pos = pos2;
  642. }
  644. CGuildManager::instance().LoginMember(ch);
  646. // 캐릭터를 맵에 추가
  647. ch->Show(ch->GetMapIndex(), pos.x, pos.y, pos.z);
  649. SECTREE_MANAGER::instance().SendNPCPosition(ch);
  650. ch->ReviveInvisible(5);
  652. d->SetPhase(PHASE_GAME);
  654. if(ch->GetItemAward_cmd()) //게임페이즈 들어가면
  655. quest::CQuestManager::instance().ItemInformer(ch->GetPlayerID(),ch->GetItemAward_vnum()); //questmanager 호출
  657. sys_log(0, "ENTERGAME: %s %dx%dx%d %s map_index %d",
  658. ch->GetName(), ch->GetX(), ch->GetY(), ch->GetZ(), d->GetHostName(), ch->GetMapIndex());
  660. if (ch->GetHorseLevel() > 0)
  661. {
  662. ch->EnterHorse();
  663. }
  665. // 플레이시간 레코딩 시작
  666. ch->ResetPlayTime();
  668. // 자동 저장 이벤트 추가
  669. ch->StartSaveEvent();
  670. ch->StartRecoveryEvent();
  671. ch->StartCheckSpeedHackEvent();
  673. CPVPManager::instance().Connect(ch);
  674. CPVPManager::instance().SendList(d);
  676. MessengerManager::instance().Login(ch->GetName());
  678. CPartyManager::instance().SetParty(ch);
  679. CGuildManager::instance().SendGuildWar(ch);
  681. building::CManager::instance().SendLandList(d, ch->GetMapIndex());
  683. marriage::CManager::instance().Login(ch);
  685. TPacketGCTime p;
  686. p.bHeader = HEADER_GC_TIME;
  687. p.time = get_global_time();
  688. d->Packet(&p, sizeof(p));
  690. TPacketGCChannel p2;
  691. p2.header = HEADER_GC_CHANNEL;
  692. p2.channel = g_bChannel;
  693. d->Packet(&p2, sizeof(p2));
  695. ch->SendGreetMessage();
  697. _send_bonus_info(ch);
  699. #ifdef ENABLE_DUNGEON_INFORMATION
  700. CDungeonInformationManager::instance().Login(ch);
  701. #endif
  703. newPetSystem(ch);
  705. for (int i = 0; i <= PREMIUM_MAX_NUM; ++i)
  706. {
  707. int remain = ch->GetPremiumRemainSeconds(i);
  709. if (remain <= 0)
  710. continue;
  712. ch->AddAffect(AFFECT_PREMIUM_START + i, POINT_NONE, 0, 0, remain, 0, true);
  713. sys_log(0, "PREMIUM: %s type %d %dmin", ch->GetName(), i, remain);
  714. }
  716. if (g_bCheckClientVersion)
  717. {
  718. sys_log(0, "VERSION CHECK %s %s", g_stClientVersion.c_str(), d->GetClientVersion());
  720. if (!d->GetClientVersion())
  721. {
  722. d->DelayedDisconnect(10);
  723. }
  724. else
  725. {
  726. if (0 != g_stClientVersion.compare(d->GetClientVersion())) // @fixme103 (version > date)
  727. {
  728. ch->ChatPacket(CHAT_TYPE_NOTICE, LC_TEXT("클라이언트 버전이 틀려 로그아웃 됩니다. 정상적으로 패치 후 접속하세요."));
  729. d->DelayedDisconnect(0); // @fixme103 (10);
  730. LogManager::instance().HackLog("VERSION_CONFLICT", ch);
  732. sys_log(0, "VERSION : WRONG VERSION USER : account:%s name:%s hostName:%s server_version:%s client_version:%s",
  733. d->GetAccountTable().login,
  734. ch->GetName(),
  735. d->GetHostName(),
  736. g_stClientVersion.c_str(),
  737. d->GetClientVersion());
  738. }
  739. }
  740. }
  741. else
  742. {
  743. sys_log(0, "VERSION : NO CHECK");
  744. }
  746. if (ch->IsGM() == true)
  747. ch->ChatPacket(CHAT_TYPE_COMMAND, "ConsoleEnable");
  749. if (ch->GetMapIndex() >= 10000)
  750. {
  751. if (CWarMapManager::instance().IsWarMap(ch->GetMapIndex()))
  752. ch->SetWarMap(CWarMapManager::instance().Find(ch->GetMapIndex()));
  753. else if (marriage::WeddingManager::instance().IsWeddingMap(ch->GetMapIndex()))
  754. ch->SetWeddingMap(marriage::WeddingManager::instance().Find(ch->GetMapIndex()));
  755. #ifdef __MELEY_LAIR_DUNGEON__
  756. else if (MeleyLair::CMgr::instance().IsMeleyMap(ch->GetMapIndex()))
  757. MeleyLair::CMgr::instance().Leave(ch->GetGuild(), ch, true);
  758. #endif
  759. else {
  760. ch->SetDungeon(CDungeonManager::instance().FindByMapIndex(ch->GetMapIndex()));
  761. }
  762. }
  763. else if (CArenaManager::instance().IsArenaMap(ch->GetMapIndex()) == true)
  764. {
  765. int memberFlag = CArenaManager::instance().IsMember(ch->GetMapIndex(), ch->GetPlayerID());
  766. if (memberFlag == MEMBER_OBSERVER)
  767. {
  768. ch->SetObserverMode(true);
  769. ch->SetArenaObserverMode(true);
  770. if (CArenaManager::instance().RegisterObserverPtr(ch, ch->GetMapIndex(), ch->GetX()/100, ch->GetY()/100))
  771. {
  772. sys_log(0, "ARENA : Observer add failed");
  773. }
  775. if (ch->IsHorseRiding() == true)
  776. {
  777. ch->StopRiding();
  778. ch->HorseSummon(false);
  779. }
  780. }
  781. else if (memberFlag == MEMBER_DUELIST)
  782. {
  783. TPacketGCDuelStart duelStart;
  784. duelStart.header = HEADER_GC_DUEL_START;
  785. duelStart.wSize = sizeof(TPacketGCDuelStart);
  787. ch->GetDesc()->Packet(&duelStart, sizeof(TPacketGCDuelStart));
  789. if (ch->IsHorseRiding() == true)
  790. {
  791. ch->StopRiding();
  792. ch->HorseSummon(false);
  793. }
  795. LPPARTY pParty = ch->GetParty();
  796. if (pParty != NULL)
  797. {
  798. if (pParty->GetMemberCount() == 2)
  799. {
  800. CPartyManager::instance().DeleteParty(pParty);
  801. }
  802. else
  803. {
  804. pParty->Quit(ch->GetPlayerID());
  805. }
  806. }
  807. }
  808. else if (memberFlag == MEMBER_NO)
  809. {
  810. if (ch->GetGMLevel() == GM_PLAYER)
  811. ch->WarpSet(EMPIRE_START_X(ch->GetEmpire()), EMPIRE_START_Y(ch->GetEmpire()));
  812. }
  813. else
  814. {
  815. // wtf
  816. }
  817. }
  818. else if (ch->GetMapIndex() == 113)
  819. {
  820. // ox 이벤트 맵
  821. if (COXEventManager::instance().Enter(ch) == false)
  822. {
  823. // ox 맵 진입 허가가 나지 않음. 플레이어면 마을로 보내자
  824. if (ch->GetGMLevel() == GM_PLAYER)
  825. ch->WarpSet(EMPIRE_START_X(ch->GetEmpire()), EMPIRE_START_Y(ch->GetEmpire()));
  826. }
  827. }
  828. else
  829. {
  830. if (CWarMapManager::instance().IsWarMap(ch->GetMapIndex()) ||
  831. marriage::WeddingManager::instance().IsWeddingMap(ch->GetMapIndex()))
  832. {
  833. if (!test_server)
  834. ch->WarpSet(EMPIRE_START_X(ch->GetEmpire()), EMPIRE_START_Y(ch->GetEmpire()));
  835. }
  836. }
  838. ch->ChatPacket(CHAT_TYPE_COMMAND, "PetInventoryInfo");
  840. // 청소년 보호
  841. if (g_TeenDesc) // BufferedPacket 사용 금지
  842. {
  843. TPacketGTLogin p;
  845. p.header = HEADER_GT_LOGIN;
  846. p.empty = 0;
  847. p.id = d->GetAccountTable().id;
  849. g_TeenDesc->Packet(&p, sizeof(p));
  850. sys_log(0, "TEEN_SEND: (%u, %s)", d->GetAccountTable().id, ch->GetName());
  851. }
  853. if (ch->GetHorseLevel() > 0)
  854. {
  855. DWORD pid = ch->GetPlayerID();
  857. if (pid != 0 && CHorseNameManager::instance().GetHorseName(pid) == NULL)
  858. db_clientdesc->DBPacket(HEADER_GD_REQ_HORSE_NAME, 0, &pid, sizeof(DWORD));
  859. }
  860. ch->FishEventGeneralInfo();
  861. // 중립맵에 들어갔을때 안내하기
  862. if (g_noticeBattleZone)
  863. {
  864. if (FN_is_battle_zone(ch))
  865. {
  866. ch->ChatPacket(CHAT_TYPE_NOTICE, LC_TEXT("이 맵에선 강제적인 대전이 있을수 도 있습니다."));
  867. ch->ChatPacket(CHAT_TYPE_NOTICE, LC_TEXT("이 조항에 동의하지 않을시"));
  868. ch->ChatPacket(CHAT_TYPE_NOTICE, LC_TEXT("본인의 주성 및 부성으로 돌아가시기 바랍니다."));
  869. }
  870. }
  872. #ifdef ENABLE_MINI_GAME_CATCH_KING
  873. CMiniGame::instance().MiniGameCatchKingEventInfo(ch);
  874. #endif
  876. #ifdef ENABLE_FISH_EVENT
  877. ch->FishEventGeneralInfo();
  878. #endif
  880. #ifdef ENABLE_ATTENDANCE_EVENT
  881. CMiniGame::instance().AttendanceEventInfo(ch);
  882. #endif
  884. }
  886. void CInputLogin::Empire(LPDESC d, const char * c_pData)
  887. {
  888. const TPacketCGEmpire* p = reinterpret_cast<const TPacketCGEmpire*>(c_pData);
  890. if (EMPIRE_MAX_NUM <= p->bEmpire)
  891. {
  892. d->SetPhase(PHASE_CLOSE);
  893. return;
  894. }
  896. const TAccountTable& r = d->GetAccountTable();
  898. if (r.bEmpire != 0)
  899. {
  900. for (int i = 0; i < PLAYER_PER_ACCOUNT; ++i)
  901. {
  902. if (0 != r.players[i].dwID)
  903. {
  904. sys_err("EmpireSelectFailed %d", r.players[i].dwID);
  905. return;
  906. }
  907. }
  908. }
  910. TEmpireSelectPacket pd;
  912. pd.dwAccountID = r.id;
  913. pd.bEmpire = p->bEmpire;
  915. db_clientdesc->DBPacket(HEADER_GD_EMPIRE_SELECT, d->GetHandle(), &pd, sizeof(pd));
  916. }
  918. int CInputLogin::GuildSymbolUpload(LPDESC d, const char* c_pData, size_t uiBytes)
  919. {
  920. if (uiBytes < sizeof(TPacketCGGuildSymbolUpload))
  921. return -1;
  923. sys_log(0, "GuildSymbolUpload uiBytes %u", uiBytes);
  925. TPacketCGGuildSymbolUpload* p = (TPacketCGGuildSymbolUpload*) c_pData;
  927. if (uiBytes < p->size)
  928. return -1;
  930. int iSymbolSize = p->size - sizeof(TPacketCGGuildSymbolUpload);
  932. if (iSymbolSize <= 0 || iSymbolSize > 64 * 1024)
  933. {
  934. // 64k 보다 큰 길드 심볼은 올릴수없다
  935. // 접속을 끊고 무시
  936. d->SetPhase(PHASE_CLOSE);
  937. return 0;
  938. }
  940. // 땅을 소유하지 않은 길드인 경우.
  941. if (!test_server)
  942. if (!building::CManager::instance().FindLandByGuild(p->guild_id))
  943. {
  944. d->SetPhase(PHASE_CLOSE);
  945. return 0;
  946. }
  948. sys_log(0, "GuildSymbolUpload Do Upload %02X%02X%02X%02X %d", c_pData[7], c_pData[8], c_pData[9], c_pData[10], sizeof(*p));
  950. CGuildMarkManager::instance().UploadSymbol(p->guild_id, iSymbolSize, (const BYTE*)(c_pData + sizeof(*p)));
  951. CGuildMarkManager::instance().SaveSymbol(GUILD_SYMBOL_FILENAME);
  952. return iSymbolSize;
  953. }
  955. void CInputLogin::GuildSymbolCRC(LPDESC d, const char* c_pData)
  956. {
  957. const TPacketCGSymbolCRC & CGPacket = *((TPacketCGSymbolCRC *) c_pData);
  959. sys_log(0, "GuildSymbolCRC %u %u %u", CGPacket.guild_id, CGPacket.crc, CGPacket.size);
  961. const CGuildMarkManager::TGuildSymbol * pkGS = CGuildMarkManager::instance().GetGuildSymbol(CGPacket.guild_id);
  963. if (!pkGS)
  964. return;
  966. sys_log(0, " Server %u %u", pkGS->crc, pkGS->raw.size());
  968. if (pkGS->raw.size() != CGPacket.size || pkGS->crc != CGPacket.crc)
  969. {
  970. TPacketGCGuildSymbolData GCPacket;
  972. GCPacket.header = HEADER_GC_SYMBOL_DATA;
  973. GCPacket.size = sizeof(GCPacket) + pkGS->raw.size();
  974. GCPacket.guild_id = CGPacket.guild_id;
  976. d->BufferedPacket(&GCPacket, sizeof(GCPacket));
  977. d->Packet(&pkGS->raw[0], pkGS->raw.size());
  979. sys_log(0, "SendGuildSymbolHead %02X%02X%02X%02X Size %d",
  980. pkGS->raw[0], pkGS->raw[1], pkGS->raw[2], pkGS->raw[3], pkGS->raw.size());
  981. }
  982. }
  984. void CInputLogin::GuildMarkUpload(LPDESC d, const char* c_pData)
  985. {
  986. TPacketCGMarkUpload * p = (TPacketCGMarkUpload *) c_pData;
  987. CGuildManager& rkGuildMgr = CGuildManager::instance();
  988. CGuild * pkGuild;
  990. if (!(pkGuild = rkGuildMgr.FindGuild(p->gid)))
  991. {
  992. sys_err("MARK_SERVER: GuildMarkUpload: no guild. gid %u", p->gid);
  993. return;
  994. }
  996. if (pkGuild->GetLevel() < guild_mark_min_level)
  997. {
  998. sys_log(0, "MARK_SERVER: GuildMarkUpload: level < %u (%u)", guild_mark_min_level, pkGuild->GetLevel());
  999. return;
  1000. }
  1002. CGuildMarkManager & rkMarkMgr = CGuildMarkManager::instance();
  1004. sys_log(0, "MARK_SERVER: GuildMarkUpload: gid %u", p->gid);
  1006. bool isEmpty = true;
  1008. for (DWORD iPixel = 0; iPixel < SGuildMark::SIZE; ++iPixel)
  1009. if (*((DWORD *) p->image + iPixel) != 0x00000000)
  1010. isEmpty = false;
  1012. if (isEmpty)
  1013. rkMarkMgr.DeleteMark(p->gid);
  1014. else
  1015. rkMarkMgr.SaveMark(p->gid, p->image);
  1016. }
  1018. void CInputLogin::GuildMarkIDXList(LPDESC d, const char* c_pData)
  1019. {
  1020. CGuildMarkManager & rkMarkMgr = CGuildMarkManager::instance();
  1022. DWORD bufSize = sizeof(WORD) * 2 * rkMarkMgr.GetMarkCount();
  1023. char * buf = NULL;
  1025. if (bufSize > 0)
  1026. {
  1027. buf = (char *) malloc(bufSize);
  1028. rkMarkMgr.CopyMarkIdx(buf);
  1029. }
  1031. TPacketGCMarkIDXList p;
  1032. p.header = HEADER_GC_MARK_IDXLIST;
  1033. p.bufSize = sizeof(p) + bufSize;
  1034. p.count = rkMarkMgr.GetMarkCount();
  1036. if (buf)
  1037. {
  1038. d->BufferedPacket(&p, sizeof(p));
  1039. d->LargePacket(buf, bufSize);
  1040. free(buf);
  1041. }
  1042. else
  1043. d->Packet(&p, sizeof(p));
  1045. sys_log(0, "MARK_SERVER: GuildMarkIDXList %d bytes sent.", p.bufSize);
  1046. }
  1048. void CInputLogin::GuildMarkCRCList(LPDESC d, const char* c_pData)
  1049. {
  1050. TPacketCGMarkCRCList * pCG = (TPacketCGMarkCRCList *) c_pData;
  1052. std::map<BYTE, const SGuildMarkBlock *> mapDiffBlocks;
  1053. CGuildMarkManager::instance().GetDiffBlocks(pCG->imgIdx, pCG->crclist, mapDiffBlocks);
  1055. DWORD blockCount = 0;
  1056. TEMP_BUFFER buf(1024 * 1024); // 1M 버퍼
  1058. for (itertype(mapDiffBlocks) it = mapDiffBlocks.begin(); it != mapDiffBlocks.end(); ++it)
  1059. {
  1060. BYTE posBlock = it->first;
  1061. const SGuildMarkBlock & rkBlock = *it->second;
  1063. buf.write(&posBlock, sizeof(BYTE));
  1064. buf.write(&rkBlock.m_sizeCompBuf, sizeof(DWORD));
  1065. buf.write(rkBlock.m_abCompBuf, rkBlock.m_sizeCompBuf);
  1067. ++blockCount;
  1068. }
  1070. TPacketGCMarkBlock pGC;
  1072. pGC.header = HEADER_GC_MARK_BLOCK;
  1073. pGC.imgIdx = pCG->imgIdx;
  1074. pGC.bufSize = buf.size() + sizeof(TPacketGCMarkBlock);
  1075. pGC.count = blockCount;
  1077. sys_log(0, "MARK_SERVER: Sending blocks. (imgIdx %u diff %u size %u)", pCG->imgIdx, mapDiffBlocks.size(), pGC.bufSize);
  1079. if (buf.size() > 0)
  1080. {
  1081. d->BufferedPacket(&pGC, sizeof(TPacketGCMarkBlock));
  1082. d->LargePacket(buf.read_peek(), buf.size());
  1083. }
  1084. else
  1085. d->Packet(&pGC, sizeof(TPacketGCMarkBlock));
  1086. }
  1088. int CInputLogin::Analyze(LPDESC d, BYTE bHeader, const char * c_pData)
  1089. {
  1090. int iExtraLen = 0;
  1092. switch (bHeader)
  1093. {
  1094. case HEADER_CG_PONG:
  1095. Pong(d);
  1096. break;
  1098. case HEADER_CG_TIME_SYNC:
  1099. Handshake(d, c_pData);
  1100. break;
  1102. case HEADER_CG_LOGIN:
  1103. Login(d, c_pData);
  1104. break;
  1106. case HEADER_CG_LOGIN2:
  1107. LoginByKey(d, c_pData);
  1108. break;
  1110. case HEADER_CG_CHARACTER_SELECT:
  1111. CharacterSelect(d, c_pData);
  1112. break;
  1114. case HEADER_CG_CHARACTER_CREATE:
  1115. CharacterCreate(d, c_pData);
  1116. break;
  1118. case HEADER_CG_CHARACTER_DELETE:
  1119. CharacterDelete(d, c_pData);
  1120. break;
  1122. case HEADER_CG_ENTERGAME:
  1123. Entergame(d, c_pData);
  1124. break;
  1126. case HEADER_CG_EMPIRE:
  1127. Empire(d, c_pData);
  1128. break;
  1130. case HEADER_CG_MOVE:
  1131. break;
  1133. ///////////////////////////////////////
  1134. // Guild Mark
  1135. /////////////////////////////////////
  1136. case HEADER_CG_MARK_CRCLIST:
  1137. GuildMarkCRCList(d, c_pData);
  1138. break;
  1140. case HEADER_CG_MARK_IDXLIST:
  1141. GuildMarkIDXList(d, c_pData);
  1142. break;
  1144. case HEADER_CG_MARK_UPLOAD:
  1145. GuildMarkUpload(d, c_pData);
  1146. break;
  1148. //////////////////////////////////////
  1149. // Guild Symbol
  1150. /////////////////////////////////////
  1151. case HEADER_CG_GUILD_SYMBOL_UPLOAD:
  1152. if ((iExtraLen = GuildSymbolUpload(d, c_pData, m_iBufferLeft)) < 0)
  1153. return -1;
  1154. break;
  1156. case HEADER_CG_SYMBOL_CRC:
  1157. GuildSymbolCRC(d, c_pData);
  1158. break;
  1160. case HEADER_CG_MARK_LOGIN:
  1161. break;
  1162. /////////////////////////////////////
  1164. case HEADER_CG_HACK:
  1165. break;
  1167. case HEADER_CG_CHANGE_NAME:
  1168. ChangeName(d, c_pData);
  1169. break;
  1171. case HEADER_CG_CLIENT_VERSION:
  1172. Version(d->GetCharacter(), c_pData);
  1173. break;
  1175. case HEADER_CG_CLIENT_VERSION2:
  1176. Version(d->GetCharacter(), c_pData);
  1177. break;
  1179. case HEADER_CG_HS_ACK:
  1180. if (isHackShieldEnable)
  1181. {
  1182. CHackShieldManager::instance().VerifyAck(d->GetCharacter(), c_pData);
  1183. }
  1184. break;
  1186. // @fixme120
  1187. case HEADER_CG_ITEM_USE:
  1188. case HEADER_CG_TARGET:
  1189. break;
  1191. case HEADER_CG_XTRAP_ACK:
  1192. {
  1193. TPacketXTrapCSVerify* p = reinterpret_cast<TPacketXTrapCSVerify*>((void*)c_pData);
  1194. CXTrapManager::instance().Verify_CSStep3(d->GetCharacter(), p->bPacketData);
  1195. }
  1196. break;
  1198. default:
  1199. sys_err("login phase does not handle this packet! header %d", bHeader);
  1200. //d->SetPhase(PHASE_CLOSE);
  1201. return (0);
  1202. }
  1204. return (iExtraLen);
  1205. }