1. #include "stdafx.h"
  2. #include "dungeon.h"
  3. #include "char.h"
  4. #include "char_manager.h"
  5. #include "party.h"
  6. #ifdef ENABLE_D_NJGUILD
  7. #include "guild.h"
  8. #endif
  9. #include "affect.h"
  10. #include "packet.h"
  11. #include "desc.h"
  12. #include "config.h"
  13. #include "regen.h"
  14. #include "start_position.h"
  15. #include "item.h"
  16. #include "item_manager.h"
  17. #include "utils.h"
  18. #include "questmanager.h"
  20. CDungeon::CDungeon(IdType id, long lOriginalMapIndex, long lMapIndex)
  21. : m_id(id),
  22. m_lOrigMapIndex(lOriginalMapIndex),
  23. m_lMapIndex(lMapIndex),
  24. m_map_Area(SECTREE_MANAGER::instance().GetDungeonArea(lOriginalMapIndex))
  25. {
  26. Initialize();
  27. //sys_log(0,"DUNGEON create orig %d real %d", lOriginalMapIndex, lMapIndex);
  28. }
  30. CDungeon::~CDungeon()
  31. {
  32. if (m_pParty != NULL)
  33. {
  34. m_pParty->SetDungeon_for_Only_party (NULL);
  35. }
  36. //sys_log(0,"DUNGEON destroy orig %d real %d", m_lOrigMapIndex, m_lMapIndex );
  37. ClearRegen();
  38. event_cancel(&deadEvent);
  39. // <Factor>
  40. event_cancel(&exit_all_event_);
  41. event_cancel(&jump_to_event_);
  42. }
  44. void CDungeon::Initialize()
  45. {
  46. deadEvent = NULL;
  47. // <Factor>
  48. exit_all_event_ = NULL;
  49. jump_to_event_ = NULL;
  50. regen_id_ = 0;
  52. m_iMobKill = 0;
  53. m_iStoneKill = 0;
  54. m_bUsePotion = false;
  55. m_bUseRevive = false;
  57. m_iMonsterCount = 0;
  59. m_bExitAllAtEliminate = false;
  60. m_bWarpAtEliminate = false;
  62. m_iWarpDelay = 0;
  63. m_lWarpMapIndex = 0;
  64. m_lWarpX = 0;
  65. m_lWarpY = 0;
  67. m_stRegenFile = "";
  69. m_pParty = NULL;
  70. }
  72. void CDungeon::SetFlag(std::string name, int value)
  73. {
  74. itertype(m_map_Flag) it = m_map_Flag.find(name);
  75. if (it != m_map_Flag.end())
  76. it->second = value;
  77. else
  78. m_map_Flag.insert(make_pair(name, value));
  79. }
  81. int CDungeon::GetFlag(std::string name)
  82. {
  83. itertype(m_map_Flag) it = m_map_Flag.find(name);
  84. if (it != m_map_Flag.end())
  85. return it->second;
  86. else
  87. return 0;
  88. }
  90. struct FSendDestPosition
  91. {
  92. FSendDestPosition(long x, long y)
  93. {
  94. p1.bHeader = HEADER_GC_DUNGEON;
  95. p1.subheader = DUNGEON_SUBHEADER_GC_DESTINATION_POSITION;
  96. p2.x = x;
  97. p2.y = y;
  98. p1.size = sizeof(p1)+sizeof(p2);
  99. }
  101. void operator()(LPCHARACTER ch)
  102. {
  103. ch->GetDesc()->BufferedPacket(&p1, sizeof(TPacketGCDungeon));
  104. ch->GetDesc()->Packet(&p2, sizeof(TPacketGCDungeonDestPosition));
  105. }
  107. TPacketGCDungeon p1;
  108. TPacketGCDungeonDestPosition p2;
  109. };
  111. void CDungeon::SendDestPositionToParty(LPPARTY pParty, long x, long y)
  112. {
  113. if (m_map_pkParty.find(pParty) == m_map_pkParty.end())
  114. {
  115. sys_err("PARTY %u not in DUNGEON %d", pParty->GetLeaderPID(), m_lMapIndex);
  116. return;
  117. }
  119. FSendDestPosition f(x, y);
  120. pParty->ForEachNearMember(f);
  121. }
  123. struct FWarpToDungeon
  124. {
  125. FWarpToDungeon(long lMapIndex, LPDUNGEON d)
  126. : m_lMapIndex(lMapIndex), m_pkDungeon(d)
  127. {
  128. LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(lMapIndex);
  129. m_x = pkSectreeMap->m_setting.posSpawn.x;
  130. m_y = pkSectreeMap->m_setting.posSpawn.y;
  131. }
  133. void operator () (LPCHARACTER ch)
  134. {
  135. ch->SaveExitLocation();
  136. ch->WarpSet(m_x, m_y, m_lMapIndex);
  137. //m_pkDungeon->IncPartyMember(ch->GetParty());
  138. }
  140. long m_lMapIndex;
  141. long m_x;
  142. long m_y;
  143. LPDUNGEON m_pkDungeon;
  144. };
  146. void CDungeon::Join(LPCHARACTER ch)
  147. {
  148. if (SECTREE_MANAGER::instance().GetMap(m_lMapIndex) == NULL) {
  149. sys_err("CDungeon: SECTREE_MAP not found for #%ld", m_lMapIndex);
  150. return;
  151. }
  152. FWarpToDungeon(m_lMapIndex, this) (ch);
  153. }
  155. void CDungeon::JoinParty(LPPARTY pParty)
  156. {
  157. pParty->SetDungeon(this); // @warme011 the begin of the nightmare
  158. m_map_pkParty.insert(std::make_pair(pParty,0));
  160. if (SECTREE_MANAGER::instance().GetMap(m_lMapIndex) == NULL) {
  161. sys_err("CDungeon: SECTREE_MAP not found for #%ld", m_lMapIndex);
  162. return;
  163. }
  164. FWarpToDungeon f(m_lMapIndex, this);
  165. pParty->ForEachOnlineMember(f);
  166. //sys_log(0, "DUNGEON-PARTY join %p %p", this, pParty);
  167. }
  169. void CDungeon::QuitParty(LPPARTY pParty)
  170. {
  171. pParty->SetDungeon(NULL);
  172. //sys_log(0, "DUNGEON-PARTY quit %p %p", this, pParty);
  173. TPartyMap::iterator it = m_map_pkParty.find(pParty); // @warme011 boom! crash!
  175. if (it != m_map_pkParty.end())
  176. m_map_pkParty.erase(it);
  177. }
  179. EVENTINFO(dungeon_id_info)
  180. {
  181. CDungeon::IdType dungeon_id;
  183. dungeon_id_info()
  184. : dungeon_id(0)
  185. {
  186. }
  187. };
  189. EVENTFUNC(dungeon_dead_event)
  190. {
  191. dungeon_id_info* info = dynamic_cast<dungeon_id_info*>( event->info );
  193. if ( info == NULL )
  194. {
  195. sys_err( "dungeon_dead_event> <Factor> Null pointer" );
  196. return 0;
  197. }
  199. LPDUNGEON pDungeon = CDungeonManager::instance().Find(info->dungeon_id);
  200. if (pDungeon == NULL) {
  201. return 0;
  202. }
  204. pDungeon->deadEvent = NULL;
  206. CDungeonManager::instance().Destroy(info->dungeon_id);
  207. return 0;
  208. }
  210. void CDungeon::IncMember(LPCHARACTER ch)
  211. {
  212. if (m_set_pkCharacter.find(ch) == m_set_pkCharacter.end())
  213. m_set_pkCharacter.insert(ch);
  215. event_cancel(&deadEvent);
  216. }
  218. void CDungeon::DecMember(LPCHARACTER ch)
  219. {
  220. itertype(m_set_pkCharacter) it = m_set_pkCharacter.find(ch);
  222. if (it == m_set_pkCharacter.end()) {
  223. return;
  224. }
  226. m_set_pkCharacter.erase(it);
  228. if (m_set_pkCharacter.empty())
  229. {
  230. dungeon_id_info* info = AllocEventInfo<dungeon_id_info>();
  231. info->dungeon_id = m_id;
  233. event_cancel(&deadEvent);
  234. deadEvent = event_create(dungeon_dead_event, info, PASSES_PER_SEC(10));
  235. }
  236. }
  238. void CDungeon::IncPartyMember(LPPARTY pParty, LPCHARACTER ch)
  239. {
  240. //sys_log(0, "DUNGEON-PARTY inc %p %p", this, pParty);
  241. TPartyMap::iterator it = m_map_pkParty.find(pParty);
  243. if (it != m_map_pkParty.end())
  244. it->second++;
  245. else
  246. m_map_pkParty.insert(std::make_pair(pParty,1));
  248. IncMember(ch);
  249. }
  251. void CDungeon::DecPartyMember(LPPARTY pParty, LPCHARACTER ch)
  252. {
  253. //sys_log(0, "DUNGEON-PARTY dec %p %p", this, pParty);
  254. TPartyMap::iterator it = m_map_pkParty.find(pParty);
  256. if (it == m_map_pkParty.end())
  257. sys_err("cannot find party");
  258. else
  259. {
  260. it->second--;
  262. if (it->second == 0)
  263. QuitParty(pParty);
  264. }
  266. DecMember(ch);
  267. }
  269. struct FWarpToPosition
  270. {
  271. long lMapIndex;
  272. long x;
  273. long y;
  274. FWarpToPosition(long lMapIndex, long x, long y)
  275. : lMapIndex(lMapIndex), x(x), y(y)
  276. {}
  278. void operator()(LPENTITY ent)
  279. {
  280. if (!ent->IsType(ENTITY_CHARACTER)) {
  281. return;
  282. }
  283. LPCHARACTER ch = (LPCHARACTER)ent;
  284. if (!ch->IsPC()) {
  285. return;
  286. }
  287. if (ch->GetMapIndex() == lMapIndex)
  288. {
  289. ch->Show(lMapIndex, x, y, 0);
  290. ch->Stop();
  291. }
  292. else
  293. {
  294. ch->WarpSet(x,y,lMapIndex);
  295. }
  296. }
  297. };
  299. struct FWarpToPositionForce
  300. {
  301. long lMapIndex;
  302. long x;
  303. long y;
  304. FWarpToPositionForce(long lMapIndex, long x, long y)
  305. : lMapIndex(lMapIndex), x(x), y(y)
  306. {}
  308. void operator()(LPENTITY ent)
  309. {
  310. if (!ent->IsType(ENTITY_CHARACTER)) {
  311. return;
  312. }
  313. LPCHARACTER ch = (LPCHARACTER)ent;
  314. if (!ch->IsPC()) {
  315. return;
  316. }
  317. ch->WarpSet(x,y,lMapIndex);
  318. }
  319. };
  321. void CDungeon::JumpAll(long lFromMapIndex, int x, int y)
  322. {
  323. x *= 100;
  324. y *= 100;
  326. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(lFromMapIndex);
  328. if (!pMap)
  329. {
  330. sys_err("cannot find map by index %d", lFromMapIndex);
  331. return;
  332. }
  334. FWarpToPosition f(m_lMapIndex, x, y);
  336. // <Factor> SECTREE::for_each -> SECTREE::for_each_entity
  337. pMap->for_each(f);
  338. }
  340. void CDungeon::WarpAll(long lFromMapIndex, int x, int y)
  341. {
  342. x *= 100;
  343. y *= 100;
  345. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(lFromMapIndex);
  347. if (!pMap)
  348. {
  349. sys_err("cannot find map by index %d", lFromMapIndex);
  350. return;
  351. }
  353. FWarpToPositionForce f(m_lMapIndex, x, y);
  355. // <Factor> SECTREE::for_each -> SECTREE::for_each_entity
  356. pMap->for_each(f);
  357. }
  359. #ifdef ENABLE_D_NJGUILD
  360. void CDungeon::JumpGuild(CGuild* pGuild, long lFromMapIndex, int x, int y)
  361. {
  362. x *= 100;
  363. y *= 100;
  365. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(lFromMapIndex);
  367. if (!pMap)
  368. {
  369. sys_err("cannot find map by index %d", lFromMapIndex);
  370. return;
  371. }
  373. if (pGuild->GetDungeon_for_Only_guild() == NULL)
  374. {
  375. if (m_pGuild == NULL)
  376. {
  377. m_pGuild = pGuild;
  378. }
  379. else if (m_pGuild != pGuild)
  380. {
  381. sys_err ("Dungeon already has guild. Another guild cannot jump in dungeon : index %d", GetMapIndex());
  382. return;
  383. }
  384. pGuild->SetDungeon_for_Only_guild (this);
  385. }
  387. FWarpToPosition f(m_lMapIndex, x, y);
  389. pGuild->ForEachOnMapMember(f, lFromMapIndex);
  390. }
  391. #endif
  393. void CDungeon::JumpParty(LPPARTY pParty, long lFromMapIndex, int x, int y)
  394. {
  395. x *= 100;
  396. y *= 100;
  398. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(lFromMapIndex);
  400. if (!pMap)
  401. {
  402. sys_err("cannot find map by index %d", lFromMapIndex);
  403. return;
  404. }
  406. if (pParty->GetDungeon_for_Only_party() == NULL)
  407. {
  408. if (m_pParty == NULL)
  409. {
  410. m_pParty = pParty;
  411. }
  412. else if (m_pParty != pParty)
  413. {
  414. sys_err ("Dungeon already has party. Another party cannot jump in dungeon : index %d", GetMapIndex());
  415. return;
  416. }
  417. pParty->SetDungeon_for_Only_party (this);
  418. }
  420. FWarpToPosition f(m_lMapIndex, x, y);
  422. pParty->ForEachOnMapMember(f, lFromMapIndex);
  423. }
  425. void CDungeon::SetPartyNull()
  426. {
  427. m_pParty = NULL;
  428. }
  431. void CDungeonManager::Destroy(CDungeon::IdType dungeon_id)
  432. {
  433. sys_log(0, "DUNGEON destroy : map index %u", dungeon_id);
  434. LPDUNGEON pDungeon = Find(dungeon_id);
  435. if (pDungeon == NULL) {
  436. return;
  437. }
  438. m_map_pkDungeon.erase(dungeon_id);
  440. long lMapIndex = pDungeon->m_lMapIndex;
  441. m_map_pkMapDungeon.erase(lMapIndex);
  443. DWORD server_timer_arg = lMapIndex;
  444. quest::CQuestManager::instance().CancelServerTimers(server_timer_arg);
  446. SECTREE_MANAGER::instance().DestroyPrivateMap(lMapIndex);
  447. M2_DELETE(pDungeon);
  448. }
  450. LPDUNGEON CDungeonManager::Find(CDungeon::IdType dungeon_id)
  451. {
  452. itertype(m_map_pkDungeon) it = m_map_pkDungeon.find(dungeon_id);
  453. if (it != m_map_pkDungeon.end())
  454. return it->second;
  455. return NULL;
  456. }
  458. LPDUNGEON CDungeonManager::FindByMapIndex(long lMapIndex)
  459. {
  460. itertype(m_map_pkMapDungeon) it = m_map_pkMapDungeon.find(lMapIndex);
  461. if (it != m_map_pkMapDungeon.end()) {
  462. return it->second;
  463. }
  464. return NULL;
  465. }
  467. LPDUNGEON CDungeonManager::Create(long lOriginalMapIndex)
  468. {
  469. DWORD lMapIndex = SECTREE_MANAGER::instance().CreatePrivateMap(lOriginalMapIndex);
  471. if (!lMapIndex)
  472. {
  473. sys_log( 0, "Fail to Create Dungeon : OrginalMapindex %d NewMapindex %d", lOriginalMapIndex, lMapIndex );
  474. return NULL;
  475. }
  477. // <Factor> TODO: Change id assignment, or drop it
  478. CDungeon::IdType id = next_id_++;
  479. while (Find(id) != NULL) {
  480. id = next_id_++;
  481. }
  483. LPDUNGEON pDungeon = M2_NEW CDungeon(id, lOriginalMapIndex, lMapIndex);
  485. m_map_pkDungeon.insert(std::make_pair(id, pDungeon));
  486. m_map_pkMapDungeon.insert(std::make_pair(lMapIndex, pDungeon));
  488. return pDungeon;
  489. }
  491. CDungeonManager::CDungeonManager()
  492. : next_id_(0)
  493. {
  494. }
  496. CDungeonManager::~CDungeonManager()
  497. {
  498. }
  500. void CDungeon::UniqueSetMaxHP(const std::string& key, int iMaxHP)
  501. {
  502. TUniqueMobMap::iterator it = m_map_UniqueMob.find(key);
  503. if (it == m_map_UniqueMob.end())
  504. {
  505. sys_err("Unknown Key : %s", key.c_str());
  506. return;
  507. }
  508. it->second->SetMaxHP(iMaxHP);
  509. }
  511. void CDungeon::UniqueSetHP(const std::string& key, int iHP)
  512. {
  513. TUniqueMobMap::iterator it = m_map_UniqueMob.find(key);
  514. if (it == m_map_UniqueMob.end())
  515. {
  516. sys_err("Unknown Key : %s", key.c_str());
  517. return;
  518. }
  519. it->second->SetHP(iHP);
  520. }
  522. void CDungeon::UniqueSetDefGrade(const std::string& key, int iGrade)
  523. {
  524. TUniqueMobMap::iterator it = m_map_UniqueMob.find(key);
  525. if (it == m_map_UniqueMob.end())
  526. {
  527. sys_err("Unknown Key : %s", key.c_str());
  528. return;
  529. }
  530. it->second->PointChange(POINT_DEF_GRADE,iGrade - it->second->GetPoint(POINT_DEF_GRADE));
  531. }
  533. void CDungeon::SpawnMoveUnique(const char* key, DWORD vnum, const char* pos_from, const char* pos_to)
  534. {
  535. TAreaMap::iterator it_to = m_map_Area.find(pos_to);
  536. if (it_to == m_map_Area.end())
  537. {
  538. sys_err("Wrong position string : %s", pos_to);
  539. return;
  540. }
  542. TAreaMap::iterator it_from = m_map_Area.find(pos_from);
  543. if (it_from == m_map_Area.end())
  544. {
  545. sys_err("Wrong position string : %s", pos_from);
  546. return;
  547. }
  549. TAreaInfo & ai = it_from->second;
  550. TAreaInfo & ai_to = it_to->second;
  551. int dir = ai.dir;
  552. if (dir==-1)
  553. dir = number(0,359);
  555. LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  556. if (pkSectreeMap == NULL) {
  557. sys_err("CDungeon: SECTREE_MAP not found for #%ld", m_lMapIndex);
  558. return;
  559. }
  560. for (int i=0;i<100;i++)
  561. {
  562. int dx = number(ai.sx, ai.ex);
  563. int dy = number(ai.sy, ai.ey);
  564. int tx = number(ai_to.sx, ai_to.ex);
  565. int ty = number(ai_to.sy, ai_to.ey);
  567. LPCHARACTER ch = CHARACTER_MANAGER::instance().SpawnMob(vnum, m_lMapIndex, pkSectreeMap->m_setting.iBaseX+dx, pkSectreeMap->m_setting.iBaseY+dy, 0, false, dir);
  569. if (ch)
  570. {
  571. m_map_UniqueMob.insert(make_pair(std::string(key), ch));
  572. ch->AddAffect(AFFECT_DUNGEON_UNIQUE, POINT_NONE, 0, AFF_DUNGEON_UNIQUE, 65535, 0, true);
  573. ch->SetDungeon(this);
  575. if (ch->Goto(pkSectreeMap->m_setting.iBaseX+tx, pkSectreeMap->m_setting.iBaseY+ty))
  576. ch->SendMovePacket(FUNC_WAIT, 0, 0, 0, 0);
  577. }
  578. else
  579. {
  580. sys_err("Cannot spawn at %d %d", pkSectreeMap->m_setting.iBaseX+((ai.sx+ai.ex)>>1), pkSectreeMap->m_setting.iBaseY+((ai.sy+ai.ey)>>1));
  581. }
  582. }
  584. }
  586. void CDungeon::SpawnUnique(const char* key, DWORD vnum, const char* pos)
  587. {
  588. TAreaMap::iterator it = m_map_Area.find(pos);
  589. if (it == m_map_Area.end())
  590. {
  591. sys_err("Wrong position string : %s", pos);
  592. return;
  593. }
  595. TAreaInfo & ai = it->second;
  596. int dir = ai.dir;
  597. if (dir==-1)
  598. dir = number(0,359);
  600. LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  601. if (pkSectreeMap == NULL) {
  602. sys_err("CDungeon: SECTREE_MAP not found for #%ld", m_lMapIndex);
  603. return;
  604. }
  605. for (int i=0;i<100;i++)
  606. {
  607. int dx = number(ai.sx, ai.ex);
  608. int dy = number(ai.sy, ai.ey);
  610. LPCHARACTER ch = CHARACTER_MANAGER::instance().SpawnMob(vnum, m_lMapIndex, pkSectreeMap->m_setting.iBaseX+dx, pkSectreeMap->m_setting.iBaseY+dy, 0, false, dir);
  612. if (ch)
  613. {
  614. m_map_UniqueMob.insert(make_pair(std::string(key), ch));
  615. ch->SetDungeon(this);
  616. ch->AddAffect(AFFECT_DUNGEON_UNIQUE, POINT_NONE, 0, AFF_DUNGEON_UNIQUE, 65535, 0, true);
  617. break;
  618. }
  619. else
  620. {
  621. sys_err("Cannot spawn at %d %d", pkSectreeMap->m_setting.iBaseX+((ai.sx+ai.ex)>>1), pkSectreeMap->m_setting.iBaseY+((ai.sy+ai.ey)>>1));
  622. }
  623. }
  624. }
  626. void CDungeon::SetUnique(const char* key, DWORD vid)
  627. {
  628. LPCHARACTER ch = CHARACTER_MANAGER::instance().Find(vid);
  629. if (ch)
  630. {
  631. m_map_UniqueMob.insert(make_pair(std::string(key), ch));
  632. ch->AddAffect(AFFECT_DUNGEON_UNIQUE, POINT_NONE, 0, AFF_DUNGEON_UNIQUE, 65535, 0, true);
  633. }
  634. }
  636. void CDungeon::SpawnStoneDoor(const char* key, const char* pos)
  637. {
  638. SpawnUnique(key, 13001, pos);
  639. }
  641. void CDungeon::SpawnWoodenDoor(const char* key, const char* pos)
  642. {
  643. SpawnUnique(key, 13000, pos);
  644. UniqueSetMaxHP(key, 10000);
  645. UniqueSetHP(key, 10000);
  646. UniqueSetDefGrade(key, 300);
  647. }
  649. void CDungeon::PurgeUnique(const std::string& key)
  650. {
  651. TUniqueMobMap::iterator it = m_map_UniqueMob.find(key);
  652. if (it == m_map_UniqueMob.end())
  653. {
  654. sys_err("Unknown Key or Dead: %s", key.c_str());
  655. return;
  656. }
  657. LPCHARACTER ch = it->second;
  658. m_map_UniqueMob.erase(it);
  659. M2_DESTROY_CHARACTER(ch);
  660. }
  662. void CDungeon::KillUnique(const std::string& key)
  663. {
  664. TUniqueMobMap::iterator it = m_map_UniqueMob.find(key);
  665. if (it == m_map_UniqueMob.end())
  666. {
  667. sys_err("Unknown Key or Dead: %s", key.c_str());
  668. return;
  669. }
  670. LPCHARACTER ch = it->second;
  671. m_map_UniqueMob.erase(it);
  672. ch->Dead();
  673. }
  675. DWORD CDungeon::GetUniqueVid(const std::string& key)
  676. {
  677. TUniqueMobMap::iterator it = m_map_UniqueMob.find(key);
  678. if (it == m_map_UniqueMob.end())
  679. {
  680. sys_err("Unknown Key or Dead: %s", key.c_str());
  681. return 0;
  682. }
  683. LPCHARACTER ch = it->second;
  684. return ch->GetVID();
  685. }
  687. float CDungeon::GetUniqueHpPerc(const std::string& key)
  688. {
  689. TUniqueMobMap::iterator it = m_map_UniqueMob.find(key);
  690. if (it == m_map_UniqueMob.end())
  691. {
  692. sys_err("Unknown Key : %s", key.c_str());
  693. return false;
  694. }
  695. return (100.f*it->second->GetHP())/it->second->GetMaxHP();
  696. }
  698. void CDungeon::DeadCharacter(LPCHARACTER ch)
  699. {
  700. if (!ch->IsPC())
  701. {
  702. TUniqueMobMap::iterator it = m_map_UniqueMob.begin();
  703. while (it!=m_map_UniqueMob.end())
  704. {
  705. if (it->second == ch)
  706. {
  707. //sys_log(0,"Dead unique %s", it->first.c_str());
  708. m_map_UniqueMob.erase(it);
  709. break;
  710. }
  711. ++it;
  712. }
  713. }
  714. }
  716. bool CDungeon::IsUniqueDead(const std::string& key)
  717. {
  718. TUniqueMobMap::iterator it = m_map_UniqueMob.find(key);
  720. if (it == m_map_UniqueMob.end())
  721. {
  722. sys_err("Unknown Key or Dead : %s", key.c_str());
  723. return true;
  724. }
  726. return it->second->IsDead();
  727. }
  729. void CDungeon::Spawn(DWORD vnum, const char* pos)
  730. {
  731. //sys_log(0,"DUNGEON Spawn %u %s", vnum, pos);
  732. TAreaMap::iterator it = m_map_Area.find(pos);
  734. if (it == m_map_Area.end())
  735. {
  736. sys_err("Wrong position string : %s", pos);
  737. return;
  738. }
  740. TAreaInfo & ai = it->second;
  741. int dir = ai.dir;
  742. if (dir==-1)
  743. dir = number(0,359);
  745. LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  746. if (pkSectreeMap == NULL)
  747. {
  748. sys_err("cannot find map by index %d", m_lMapIndex);
  749. return;
  750. }
  751. int dx = number(ai.sx, ai.ex);
  752. int dy = number(ai.sy, ai.ey);
  754. LPCHARACTER ch = CHARACTER_MANAGER::instance().SpawnMob(vnum, m_lMapIndex, pkSectreeMap->m_setting.iBaseX+dx, pkSectreeMap->m_setting.iBaseY+dy, 0, false, dir);
  755. if (ch)
  756. ch->SetDungeon(this);
  757. }
  759. LPCHARACTER CDungeon::SpawnMob(DWORD vnum, int x, int y, int dir)
  760. {
  761. LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  762. if (pkSectreeMap == NULL) {
  763. sys_err("CDungeon: SECTREE_MAP not found for #%ld", m_lMapIndex);
  764. return NULL;
  765. }
  766. sys_log(0, "CDungeon::SpawnMob %u %d %d", vnum, x, y);
  768. LPCHARACTER ch = CHARACTER_MANAGER::instance().SpawnMob(vnum, m_lMapIndex, pkSectreeMap->m_setting.iBaseX+x*100, pkSectreeMap->m_setting.iBaseY+y*100, 0, false, dir == 0 ? -1 : (dir - 1) * 45);
  770. if (ch)
  771. {
  772. ch->SetDungeon(this);
  773. sys_log(0, "CDungeon::SpawnMob name %s", ch->GetName());
  774. }
  776. return ch;
  777. }
  779. LPCHARACTER CDungeon::SpawnMob_ac_dir(DWORD vnum, int x, int y, int dir)
  780. {
  781. LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  782. if (pkSectreeMap == NULL) {
  783. sys_err("CDungeon: SECTREE_MAP not found for #%ld", m_lMapIndex);
  784. return NULL;
  785. }
  786. sys_log(0, "CDungeon::SpawnMob %u %d %d", vnum, x, y);
  788. LPCHARACTER ch = CHARACTER_MANAGER::instance().SpawnMob(vnum, m_lMapIndex, pkSectreeMap->m_setting.iBaseX+x*100, pkSectreeMap->m_setting.iBaseY+y*100, 0, false, dir);
  790. if (ch)
  791. {
  792. ch->SetDungeon(this);
  793. sys_log(0, "CDungeon::SpawnMob name %s", ch->GetName());
  794. }
  796. return ch;
  797. }
  799. void CDungeon::SpawnNameMob(DWORD vnum, int x, int y, const char* name)
  800. {
  801. LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  802. if (pkSectreeMap == NULL) {
  803. sys_err("CDungeon: SECTREE_MAP not found for #%ld", m_lMapIndex);
  804. return;
  805. }
  807. LPCHARACTER ch = CHARACTER_MANAGER::instance().SpawnMob(vnum, m_lMapIndex, pkSectreeMap->m_setting.iBaseX+x, pkSectreeMap->m_setting.iBaseY+y, 0, false, -1);
  808. if (ch)
  809. {
  810. ch->SetName(name);
  811. ch->SetDungeon(this);
  812. }
  813. }
  815. void CDungeon::SpawnGotoMob(long lFromX, long lFromY, long lToX, long lToY)
  816. {
  817. const int MOB_GOTO_VNUM = 20039;
  819. LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  820. if (pkSectreeMap == NULL) {
  821. sys_err("CDungeon: SECTREE_MAP not found for #%ld", m_lMapIndex);
  822. return;
  823. }
  825. sys_log(0, "SpawnGotoMob %d %d to %d %d", lFromX, lFromY, lToX, lToY);
  827. lFromX = pkSectreeMap->m_setting.iBaseX+lFromX*100;
  828. lFromY = pkSectreeMap->m_setting.iBaseY+lFromY*100;
  830. LPCHARACTER ch = CHARACTER_MANAGER::instance().SpawnMob(MOB_GOTO_VNUM, m_lMapIndex, lFromX, lFromY, 0, false, -1);
  832. if (ch)
  833. {
  834. char buf[30+1];
  835. snprintf(buf, sizeof(buf), ". %ld %ld", lToX, lToY);
  837. ch->SetName(buf);
  838. ch->SetDungeon(this);
  839. }
  840. }
  842. LPCHARACTER CDungeon::SpawnGroup(DWORD vnum, long x, long y, float radius, bool bAggressive, int count)
  843. {
  844. LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  845. if (pkSectreeMap == NULL) {
  846. sys_err("CDungeon: SECTREE_MAP not found for #%ld", m_lMapIndex);
  847. return NULL;
  848. }
  850. int iRadius = (int) radius;
  852. int sx = pkSectreeMap->m_setting.iBaseX + x - iRadius;
  853. int sy = pkSectreeMap->m_setting.iBaseY + y - iRadius;
  854. int ex = sx + iRadius;
  855. int ey = sy + iRadius;
  857. LPCHARACTER ch = NULL;
  859. while (count--)
  860. {
  861. LPCHARACTER chLeader = CHARACTER_MANAGER::instance().SpawnGroup(vnum, m_lMapIndex, sx, sy, ex, ey, NULL, bAggressive, this);
  862. if (chLeader && !ch)
  863. ch = chLeader;
  864. }
  866. return ch;
  867. }
  869. void CDungeon::SpawnRegen(const char* filename, bool bOnce)
  870. {
  871. if (!filename)
  872. {
  873. sys_err("CDungeon::SpawnRegen(filename=NULL, bOnce=%d) - m_lMapIndex[%d]", bOnce, m_lMapIndex);
  874. return;
  875. }
  877. LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  878. if (!pkSectreeMap)
  879. {
  880. sys_err("CDungeon::SpawnRegen(filename=%s, bOnce=%d) - m_lMapIndex[%d]", filename, bOnce, m_lMapIndex);
  881. return;
  882. }
  883. regen_do(filename, m_lMapIndex, pkSectreeMap->m_setting.iBaseX, pkSectreeMap->m_setting.iBaseY, this, bOnce);
  884. }
  886. void CDungeon::AddRegen(LPREGEN regen)
  887. {
  888. regen->id = regen_id_++;
  889. m_regen.push_back(regen);
  890. }
  892. void CDungeon::ClearRegen()
  893. {
  894. for (itertype(m_regen) it = m_regen.begin(); it != m_regen.end(); ++it)
  895. {
  896. LPREGEN regen = *it;
  898. event_cancel(&regen->event);
  899. M2_DELETE(regen);
  900. }
  901. m_regen.clear();
  902. }
  904. bool CDungeon::IsValidRegen(LPREGEN regen, size_t regen_id) {
  905. itertype(m_regen) it = std::find(m_regen.begin(), m_regen.end(), regen);
  906. if (it == m_regen.end()) {
  907. return false;
  908. }
  909. LPREGEN found = *it;
  910. return (found->id == regen_id);
  911. }
  913. void CDungeon::SpawnMoveGroup(DWORD vnum, const char* pos_from, const char* pos_to, int count)
  914. {
  915. TAreaMap::iterator it_to = m_map_Area.find(pos_to);
  917. if (it_to == m_map_Area.end())
  918. {
  919. sys_err("Wrong position string : %s", pos_to);
  920. return;
  921. }
  923. TAreaMap::iterator it_from = m_map_Area.find(pos_from);
  925. if (it_from == m_map_Area.end())
  926. {
  927. sys_err("Wrong position string : %s", pos_from);
  928. return;
  929. }
  931. TAreaInfo & ai = it_from->second;
  932. TAreaInfo & ai_to = it_to->second;
  933. int dir = ai.dir;
  935. if (dir == -1)
  936. dir = number(0,359);
  938. LPSECTREE_MAP pkSectreeMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  939. if (pkSectreeMap == NULL) {
  940. sys_err("CDungeon: SECTREE_MAP not found for #%ld", m_lMapIndex);
  941. return;
  942. }
  944. while (count--)
  945. {
  946. int tx = number(ai_to.sx, ai_to.ex)+pkSectreeMap->m_setting.iBaseX;
  947. int ty = number(ai_to.sy, ai_to.ey)+pkSectreeMap->m_setting.iBaseY;
  948. CHARACTER_MANAGER::instance().SpawnMoveGroup(vnum, m_lMapIndex, pkSectreeMap->m_setting.iBaseX+ai.sx, pkSectreeMap->m_setting.iBaseY+ai.sy, pkSectreeMap->m_setting.iBaseX+ai.ex, pkSectreeMap->m_setting.iBaseY+ai.ey, tx, ty, NULL, true);
  949. }
  950. }
  952. namespace
  953. {
  954. // DUNGEON_KILL_ALL_BUG_FIX
  955. struct FKillSectree
  956. {
  957. void operator () (LPENTITY ent)
  958. {
  959. if (ent->IsType(ENTITY_CHARACTER))
  960. {
  961. LPCHARACTER ch = (LPCHARACTER) ent;
  963. if (!ch->IsPC() && !ch->IsPet())
  964. ch->Dead();
  965. }
  966. }
  967. };
  968. // END_OF_DUNGEON_KILL_ALL_BUG_FIX
  970. struct FPurgeSectree
  971. {
  972. void operator () (LPENTITY ent)
  973. {
  974. if (ent->IsType(ENTITY_CHARACTER))
  975. {
  976. LPCHARACTER ch = (LPCHARACTER) ent;
  978. if (!ch->IsPC() && !ch->IsPet()) {
  979. M2_DESTROY_CHARACTER(ch);
  980. }
  981. }
  982. else if (ent->IsType(ENTITY_ITEM))
  983. {
  984. LPITEM item = (LPITEM) ent;
  985. M2_DESTROY_ITEM(item);
  986. }
  987. else
  988. sys_err("unknown entity type %d is in dungeon", ent->GetType());
  989. }
  990. };
  991. }
  993. // DUNGEON_KILL_ALL_BUG_FIX
  994. void CDungeon::KillAll()
  995. {
  996. LPSECTREE_MAP pkMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  997. if (pkMap == NULL) {
  998. sys_err("CDungeon: SECTREE_MAP not found for #%ld", m_lMapIndex);
  999. return;
  1000. }
  1001. FKillSectree f;
  1002. pkMap->for_each(f);
  1003. }
  1004. // END_OF_DUNGEON_KILL_ALL_BUG_FIX
  1006. void CDungeon::Purge()
  1007. {
  1008. LPSECTREE_MAP pkMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  1009. if (pkMap == NULL) {
  1010. sys_err("CDungeon: SECTREE_MAP not found for #%ld", m_lMapIndex);
  1011. return;
  1012. }
  1013. FPurgeSectree f;
  1014. pkMap->for_each(f);
  1015. }
  1017. void CDungeon::IncKillCount(LPCHARACTER pkKiller, LPCHARACTER pkVictim)
  1018. {
  1019. if (pkVictim->IsStone())
  1020. m_iStoneKill ++;
  1021. else
  1022. m_iMobKill ++;
  1023. }
  1025. void CDungeon::UsePotion(LPCHARACTER ch)
  1026. {
  1027. m_bUsePotion = true;
  1028. }
  1030. void CDungeon::UseRevive(LPCHARACTER ch)
  1031. {
  1032. m_bUseRevive = true;
  1033. }
  1035. bool CDungeon::IsUsePotion()
  1036. {
  1037. return m_bUsePotion;
  1038. }
  1040. bool CDungeon::IsUseRevive()
  1041. {
  1042. return m_bUseRevive;
  1043. }
  1045. int CDungeon::GetKillMobCount()
  1046. {
  1047. return m_iMobKill;
  1048. }
  1049. int CDungeon::GetKillStoneCount()
  1050. {
  1051. return m_iStoneKill;
  1052. }
  1054. struct FCountMonster
  1055. {
  1056. int n;
  1057. FCountMonster() : n(0) {};
  1058. void operator()(LPENTITY ent)
  1059. {
  1060. if (ent->IsType(ENTITY_CHARACTER))
  1061. {
  1062. LPCHARACTER ch = (LPCHARACTER) ent;
  1063. if (!ch->IsPC())
  1064. n++;
  1065. }
  1066. }
  1067. };
  1069. int CDungeon::CountRealMonster()
  1070. {
  1071. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(m_lOrigMapIndex);
  1073. if (!pMap)
  1074. {
  1075. sys_err("cannot find map by index %d", m_lOrigMapIndex);
  1076. return 0;
  1077. }
  1079. FCountMonster f;
  1081. // <Factor> SECTREE::for_each -> SECTREE::for_each_entity
  1082. pMap->for_each(f);
  1083. return f.n;
  1084. }
  1086. struct FExitDungeon
  1087. {
  1088. void operator()(LPENTITY ent)
  1089. {
  1090. if (ent->IsType(ENTITY_CHARACTER))
  1091. {
  1092. LPCHARACTER ch = (LPCHARACTER) ent;
  1094. if (ch->IsPC())
  1095. ch->ExitToSavedLocation();
  1096. }
  1097. }
  1098. };
  1100. void CDungeon::ExitAll()
  1101. {
  1102. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  1104. if (!pMap)
  1105. {
  1106. sys_err("cannot find map by index %d", m_lMapIndex);
  1107. return;
  1108. }
  1110. FExitDungeon f;
  1112. // <Factor> SECTREE::for_each -> SECTREE::for_each_entity
  1113. pMap->for_each(f);
  1114. }
  1116. // DUNGEON_NOTICE
  1117. namespace
  1118. {
  1119. struct FNotice
  1120. {
  1121. FNotice(const char * psz) : m_psz(psz)
  1122. {
  1123. }
  1125. void operator() (LPENTITY ent)
  1126. {
  1127. if (ent->IsType(ENTITY_CHARACTER))
  1128. {
  1129. LPCHARACTER ch = (LPCHARACTER) ent;
  1130. ch->ChatPacket(CHAT_TYPE_NOTICE, "%s", m_psz);
  1131. }
  1132. }
  1134. const char * m_psz;
  1135. };
  1136. }
  1138. void CDungeon::Notice(const char* msg)
  1139. {
  1140. sys_log(0, "XXX Dungeon Notice %p %s", this, msg);
  1141. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  1143. if (!pMap)
  1144. {
  1145. sys_err("cannot find map by index %d", m_lMapIndex);
  1146. return;
  1147. }
  1149. FNotice f(msg);
  1150. pMap->for_each(f);
  1151. }
  1152. // END_OF_DUNGEON_NOTICE
  1154. struct FExitDungeonToStartPosition
  1155. {
  1156. void operator () (LPENTITY ent)
  1157. {
  1158. if (ent->IsType(ENTITY_CHARACTER))
  1159. {
  1160. LPCHARACTER ch = (LPCHARACTER) ent;
  1162. if (ch->IsPC())
  1163. {
  1164. PIXEL_POSITION posWarp;
  1166. // 현재 맵 인덱스를 넣는 것이 아니라 시작하는 맵 인덱스를 넣는다.
  1167. if (SECTREE_MANAGER::instance().GetRecallPositionByEmpire(g_start_map[ch->GetEmpire()], ch->GetEmpire(), posWarp))
  1168. ch->WarpSet(posWarp.x, posWarp.y);
  1169. else
  1170. ch->ExitToSavedLocation();
  1171. }
  1172. }
  1173. }
  1174. };
  1176. void CDungeon::ExitAllToStartPosition()
  1177. {
  1178. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  1180. if (!pMap)
  1181. {
  1182. sys_err("cannot find map by index %d", m_lMapIndex);
  1183. return;
  1184. }
  1186. FExitDungeonToStartPosition f;
  1188. // <Factor> SECTREE::for_each -> SECTREE::for_each_entity
  1189. pMap->for_each(f);
  1190. }
  1192. EVENTFUNC(dungeon_jump_to_event)
  1193. {
  1194. dungeon_id_info * info = dynamic_cast<dungeon_id_info *>(event->info);
  1196. if ( info == NULL )
  1197. {
  1198. sys_err( "dungeon_jump_to_event> <Factor> Null pointer" );
  1199. return 0;
  1200. }
  1202. LPDUNGEON pDungeon = CDungeonManager::instance().Find(info->dungeon_id);
  1203. pDungeon->jump_to_event_ = NULL;
  1205. if (pDungeon)
  1206. pDungeon->JumpToEliminateLocation();
  1207. else
  1208. sys_err("cannot find dungeon with map index %u", info->dungeon_id);
  1210. return 0;
  1211. }
  1213. EVENTFUNC(dungeon_exit_all_event)
  1214. {
  1215. dungeon_id_info * info = dynamic_cast<dungeon_id_info *>(event->info);
  1217. if ( info == NULL )
  1218. {
  1219. sys_err( "dungeon_exit_all_event> <Factor> Null pointer" );
  1220. return 0;
  1221. }
  1223. LPDUNGEON pDungeon = CDungeonManager::instance().Find(info->dungeon_id);
  1224. pDungeon->exit_all_event_ = NULL;
  1226. if (pDungeon)
  1227. pDungeon->ExitAll();
  1229. return 0;
  1230. }
  1232. void CDungeon::CheckEliminated()
  1233. {
  1234. if (m_iMonsterCount > 0)
  1235. return;
  1237. if (m_bExitAllAtEliminate)
  1238. {
  1239. sys_log(0, "CheckEliminated: exit");
  1240. m_bExitAllAtEliminate = false;
  1242. if (m_iWarpDelay)
  1243. {
  1244. dungeon_id_info* info = AllocEventInfo<dungeon_id_info>();
  1245. info->dungeon_id = m_id;
  1247. event_cancel(&exit_all_event_);
  1248. exit_all_event_ = event_create(dungeon_exit_all_event, info, PASSES_PER_SEC(m_iWarpDelay));
  1249. }
  1250. else
  1251. {
  1252. ExitAll();
  1253. }
  1254. }
  1255. else if (m_bWarpAtEliminate)
  1256. {
  1257. sys_log(0, "CheckEliminated: warp");
  1258. m_bWarpAtEliminate = false;
  1260. if (m_iWarpDelay)
  1261. {
  1262. dungeon_id_info* info = AllocEventInfo<dungeon_id_info>();
  1263. info->dungeon_id = m_id;
  1265. event_cancel(&jump_to_event_);
  1266. jump_to_event_ = event_create(dungeon_jump_to_event, info, PASSES_PER_SEC(m_iWarpDelay));
  1267. }
  1268. else
  1269. {
  1270. JumpToEliminateLocation();
  1271. }
  1272. }
  1273. else
  1274. sys_log(0, "CheckEliminated: none");
  1275. }
  1277. void CDungeon::SetExitAllAtEliminate(long time)
  1278. {
  1279. sys_log(0, "SetExitAllAtEliminate: time %d", time);
  1280. m_bExitAllAtEliminate = true;
  1281. m_iWarpDelay = time;
  1282. }
  1284. void CDungeon::SetWarpAtEliminate(long time, long lMapIndex, int x, int y, const char* regen_file)
  1285. {
  1286. m_bWarpAtEliminate = true;
  1287. m_iWarpDelay = time;
  1288. m_lWarpMapIndex = lMapIndex;
  1289. m_lWarpX = x;
  1290. m_lWarpY = y;
  1292. if (!regen_file || !*regen_file)
  1293. m_stRegenFile.clear();
  1294. else
  1295. m_stRegenFile = regen_file;
  1297. sys_log(0, "SetWarpAtEliminate: time %d map %d %dx%d regenfile %s", time, lMapIndex, x, y, m_stRegenFile.c_str());
  1298. }
  1300. void CDungeon::JumpToEliminateLocation()
  1301. {
  1302. LPDUNGEON pDungeon = CDungeonManager::instance().FindByMapIndex(m_lWarpMapIndex);
  1304. if (pDungeon)
  1305. {
  1306. pDungeon->JumpAll(m_lMapIndex, m_lWarpX, m_lWarpY);
  1308. if (!m_stRegenFile.empty())
  1309. {
  1310. pDungeon->SpawnRegen(m_stRegenFile.c_str());
  1311. m_stRegenFile.clear();
  1312. }
  1313. }
  1314. else
  1315. {
  1316. // 일반 맵으로 워프
  1317. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  1319. if (!pMap)
  1320. {
  1321. sys_err("no map by index %d", m_lMapIndex);
  1322. return;
  1323. }
  1325. FWarpToPosition f(m_lWarpMapIndex, m_lWarpX * 100, m_lWarpY * 100);
  1327. // <Factor> SECTREE::for_each -> SECTREE::for_each_entity
  1328. pMap->for_each(f);
  1329. }
  1330. }
  1332. struct FNearPosition
  1333. {
  1334. long x;
  1335. long y;
  1336. int dist;
  1337. bool ret;
  1339. FNearPosition(long x, long y, int d) :
  1340. x(x), y(y), dist(d), ret(true)
  1341. {
  1342. }
  1344. void operator()(LPENTITY ent)
  1345. {
  1346. if (ret == false)
  1347. return;
  1349. if (ent->IsType(ENTITY_CHARACTER))
  1350. {
  1351. LPCHARACTER ch = (LPCHARACTER) ent;
  1353. if (ch->IsPC())
  1354. {
  1355. if (DISTANCE_APPROX(ch->GetX() - x * 100, ch->GetY() - y * 100) > dist * 100)
  1356. ret = false;
  1357. }
  1358. }
  1359. }
  1360. };
  1362. bool CDungeon::IsAllPCNearTo(int x, int y, int dist)
  1363. {
  1364. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(m_lMapIndex);
  1366. if (!pMap)
  1367. {
  1368. sys_err("cannot find map by index %d", m_lMapIndex);
  1369. return false;
  1370. }
  1372. FNearPosition f(x, y, dist);
  1374. // <Factor> SECTREE::for_each -> SECTREE::for_each_entity
  1375. pMap->for_each(f);
  1377. return f.ret;
  1378. }
  1380. void CDungeon::CreateItemGroup (std::string& group_name, ItemGroup& item_group)
  1381. {
  1382. m_map_ItemGroup.insert (ItemGroupMap::value_type (group_name, item_group));
  1383. }
  1385. const CDungeon::ItemGroup* CDungeon::GetItemGroup (std::string& group_name)
  1386. {
  1387. ItemGroupMap::iterator it = m_map_ItemGroup.find (group_name);
  1388. if (it != m_map_ItemGroup.end())
  1389. return &(it->second);
  1390. else
  1391. return NULL;
  1392. }