1. #include "StdAfx.h"
  2. #include "InstanceBase.h"
  3. #include "PythonBackground.h"
  4. #include "PythonNonPlayer.h"
  5. #include "PythonPlayer.h"
  6. #include "PythonCharacterManager.h"
  7. #include "AbstractPlayer.h"
  8. #include "AbstractApplication.h"
  9. #include "packet.h"
  11. #include "../eterlib/StateManager.h"
  12. #include "../gamelib/ItemManager.h"
  14. BOOL HAIR_COLOR_ENABLE=FALSE;
  15. BOOL USE_ARMOR_SPECULAR=FALSE;
  16. BOOL RIDE_HORSE_ENABLE=TRUE;
  17. const float c_fDefaultRotationSpeed = 1200.0f;
  18. const float c_fDefaultHorseRotationSpeed = 1500.0f;
  21. bool IsWall(unsigned race)
  22. {
  23. switch (race)
  24. {
  25. case 14201:
  26. case 14202:
  27. case 14203:
  28. case 14204:
  29. return true;
  30. break;
  31. }
  32. return false;
  33. }
  35. //////////////////////////////////////////////////////////////////////////////////////
  38. CInstanceBase::SHORSE::SHORSE()
  39. {
  40. __Initialize();
  41. }
  43. CInstanceBase::SHORSE::~SHORSE()
  44. {
  45. assert(m_pkActor==NULL);
  46. }
  48. void CInstanceBase::SHORSE::__Initialize()
  49. {
  50. m_isMounting=false;
  51. m_pkActor=NULL;
  52. }
  54. void CInstanceBase::SHORSE::SetAttackSpeed(UINT uAtkSpd)
  55. {
  56. if (!IsMounting())
  57. return;
  59. CActorInstance& rkActor=GetActorRef();
  60. rkActor.SetAttackSpeed(uAtkSpd/100.0f);
  61. }
  63. void CInstanceBase::SHORSE::SetMoveSpeed(UINT uMovSpd)
  64. {
  65. if (!IsMounting())
  66. return;
  68. CActorInstance& rkActor=GetActorRef();
  69. rkActor.SetMoveSpeed(uMovSpd/100.0f);
  70. }
  72. void CInstanceBase::SHORSE::Create(const TPixelPosition& c_rkPPos, UINT eRace, UINT eHitEffect)
  73. {
  74. assert(NULL==m_pkActor && "CInstanceBase::SHORSE::Create - ALREADY MOUNT");
  76. m_pkActor=new CActorInstance;
  78. CActorInstance& rkActor=GetActorRef();
  79. rkActor.SetEventHandler(CActorInstance::IEventHandler::GetEmptyPtr());
  80. if (!rkActor.SetRace(eRace))
  81. {
  82. delete m_pkActor;
  83. m_pkActor=NULL;
  84. return;
  85. }
  87. rkActor.SetShape(0);
  88. rkActor.SetBattleHitEffect(eHitEffect);
  89. rkActor.SetAlphaValue(0.0f);
  90. rkActor.BlendAlphaValue(1.0f, 0.5f);
  91. rkActor.SetMoveSpeed(1.0f);
  92. rkActor.SetAttackSpeed(1.0f);
  93. rkActor.SetMotionMode(CRaceMotionData::MODE_GENERAL);
  94. rkActor.Stop();
  95. rkActor.RefreshActorInstance();
  97. rkActor.SetCurPixelPosition(c_rkPPos);
  99. m_isMounting=true;
  100. }
  102. void CInstanceBase::SHORSE::Destroy()
  103. {
  104. if (m_pkActor)
  105. {
  106. m_pkActor->Destroy();
  107. delete m_pkActor;
  108. }
  110. __Initialize();
  111. }
  113. CActorInstance& CInstanceBase::SHORSE::GetActorRef()
  114. {
  115. assert(NULL!=m_pkActor && "CInstanceBase::SHORSE::GetActorRef");
  116. return *m_pkActor;
  117. }
  119. CActorInstance* CInstanceBase::SHORSE::GetActorPtr()
  120. {
  121. return m_pkActor;
  122. }
  124. UINT CInstanceBase::SHORSE::GetLevel()
  125. {
  126. if (m_pkActor)
  127. {
  128. DWORD mount = m_pkActor->GetRace();
  129. switch (mount)
  130. {
  131. case 20101:
  132. case 20102:
  133. case 20103:
  134. return 1;
  135. case 20104:
  136. case 20105:
  137. case 20106:
  138. return 2;
  139. case 20107:
  140. case 20108:
  141. case 20109:
  142. case 20110: // #0000673: [M2EU] »õ·Î¿î Å»°Í Ÿ°í °ø°İ ¾ÈµÊ
  143. case 20111: // #0000673: [M2EU] »õ·Î¿î Å»°Í Ÿ°í °ø°İ ¾ÈµÊ
  144. case 20112: // #0000673: [M2EU] »õ·Î¿î Å»°Í Ÿ°í °ø°İ ¾ÈµÊ
  145. case 20113: // #0000673: [M2EU] »õ·Î¿î Å»°Í Ÿ°í °ø°İ ¾ÈµÊ
  146. case 20114:
  147. case 20115:
  148. case 20116:
  149. case 20117:
  150. case 20118:
  151. case 20120:
  152. case 20121:
  153. case 20122:
  154. case 20123:
  155. case 20124:
  156. case 20125:
  157. return 3;
  158. case 20119: // ¶ó¸¶´Ü À̺¥Æ®¿ë È渶´Â ½ºÅ³ºÒ°¡, °ø°İ°¡´ÉÇÑ ·¹º§2·Î ¼³Á¤
  159. case 20219: // ÇÒ·ÎÀ© À̺¥Æ®¿ë È渶´Â ½ºÅ³ºÒ°¡, °ø°İ°¡´ÉÇÑ ·¹º§2·Î ¼³Á¤ (=¶ó¸¶´Ü È渶 Ŭ·Ğ)
  160. case 20220:
  161. case 20221:
  162. case 20222:
  163. return 2;
  164. }
  166. // ¸¶¿îÆ® È®Àå ½Ã½ºÅÛ¿ë Ư¼ö ó¸® (20201 ~ 20212 ´ë¿ªÀ» »ç¿ëÇÏ°í ¼ø¼­´ë·Î 4°³¾¿ ³ª´²¼­ ÃʱŞ, Áß±Ş, °í±ŞÀÓ)
  167. // -- Å»°Í ·¹º§À» Ŭ¶ó¿¡¼­ ÃøÁ¤ÇÏ°í °ø°İ/½ºÅ³ »ç¿ë°¡´É ¿©ºÎµµ Ŭ¶ó¿¡¼­ ó¸®ÇÏ´Â °Í ÀÚü¿¡ ¹®Á¦°¡ ÀÖ´Â µí.. [hyo]
  168. {
  169. // Áß±Ş Å»°ÍÀº ·¹º§2 (°ø°İ °¡´É, ½ºÅ³ ºÒ°¡)
  170. if ((20205 <= mount && 20208 >= mount) ||
  171. (20214 == mount) || (20217 == mount) // ³­ÆøÇÑ Àü°©¼ø¼ø·Ï, ³­ÆøÇÑ Àü°©¾Ï¼ø·Ï
  172. )
  173. return 2;
  175. // °í±Ş Å»°ÍÀº ·¹º§3 (°ø°İ °¡´É, ½ºÅ³ °¡´É)
  176. if ((20209 <= mount && 20212 >= mount) ||
  177. (20215 == mount) || (20218 == mount) || // ¿ë¸ÍÇÑ Àü°©¼ø¼ø·Ï, ¿ë¸ÍÇÑ Àü°©¾Ï¼ø·Ï
  178. (20220 == mount)
  179. )
  180. return 3;
  181. }
  182. }
  183. return 0;
  184. }
  186. bool CInstanceBase::SHORSE::IsNewMount()
  187. {
  188. if (!m_pkActor)
  189. return false;
  190. DWORD mount = m_pkActor->GetRace();
  192. if ((20205 <= mount && 20208 >= mount) ||
  193. (20214 == mount) || (20217 == mount) // ³­ÆøÇÑ Àü°©¼ø¼ø·Ï, ³­ÆøÇÑ Àü°©¾Ï¼ø·Ï
  194. )
  195. return true;
  197. // °í±Ş Å»°Í
  198. if ((20209 <= mount && 20212 >= mount) ||
  199. (20215 == mount) || (20218 == mount) || // ¿ë¸ÍÇÑ Àü°©¼ø¼ø·Ï, ¿ë¸ÍÇÑ Àü°©¾Ï¼ø·Ï
  200. (20220 == mount)
  201. )
  202. return true;
  204. return false;
  205. }
  206. bool CInstanceBase::SHORSE::CanUseSkill()
  207. {
  208. // ¸¶»ó½ºÅ³Àº ¸»ÀÇ ·¹º§ÀÌ 3 ÀÌ»óÀ̾î¾ß¸¸ ÇÔ.
  209. if (IsMounting())
  210. return 2 < GetLevel();
  212. return true;
  213. }
  215. bool CInstanceBase::SHORSE::CanAttack()
  216. {
  217. if (IsMounting())
  218. if (GetLevel()<=1)
  219. return false;
  221. return true;
  222. }
  224. bool CInstanceBase::SHORSE::IsMounting()
  225. {
  226. return m_isMounting;
  227. }
  229. void CInstanceBase::SHORSE::Deform()
  230. {
  231. if (!IsMounting())
  232. return;
  234. CActorInstance& rkActor=GetActorRef();
  235. rkActor.INSTANCEBASE_Deform();
  236. }
  238. void CInstanceBase::SHORSE::Render()
  239. {
  240. if (!IsMounting())
  241. return;
  243. CActorInstance& rkActor=GetActorRef();
  244. rkActor.Render();
  245. }
  247. void CInstanceBase::__AttachHorseSaddle()
  248. {
  249. if (!IsMountingHorse())
  250. return;
  251. m_kHorse.m_pkActor->AttachModelInstance(CRaceData::PART_MAIN, "saddle", m_GraphicThingInstance, CRaceData::PART_MAIN);
  252. }
  254. void CInstanceBase::__DetachHorseSaddle()
  255. {
  256. if (!IsMountingHorse())
  257. return;
  258. m_kHorse.m_pkActor->DetachModelInstance(CRaceData::PART_MAIN, m_GraphicThingInstance, CRaceData::PART_MAIN);
  259. }
  261. //////////////////////////////////////////////////////////////////////////////////////
  263. void CInstanceBase::BlockMovement()
  264. {
  265. m_GraphicThingInstance.BlockMovement();
  266. }
  268. bool CInstanceBase::IsBlockObject(const CGraphicObjectInstance& c_rkBGObj)
  269. {
  270. return m_GraphicThingInstance.IsBlockObject(c_rkBGObj);
  271. }
  273. bool CInstanceBase::AvoidObject(const CGraphicObjectInstance& c_rkBGObj)
  274. {
  275. return m_GraphicThingInstance.AvoidObject(c_rkBGObj);
  276. }
  278. ///////////////////////////////////////////////////////////////////////////////////
  280. bool __ArmorVnumToShape(int iVnum, DWORD * pdwShape)
  281. {
  282. *pdwShape = iVnum;
  284. /////////////////////////////////////////
  286. if (0 == iVnum || 1 == iVnum)
  287. return false;
  289. if (!USE_ARMOR_SPECULAR)
  290. return false;
  292. CItemData * pItemData;
  293. if (!CItemManager::Instance().GetItemDataPointer(iVnum, &pItemData))
  294. return false;
  296. enum
  297. {
  298. SHAPE_VALUE_SLOT_INDEX = 3,
  299. };
  301. *pdwShape = pItemData->GetValue(SHAPE_VALUE_SLOT_INDEX);
  303. return true;
  304. }
  306. // 2004.07.05.myevan.±Ã½Åź¿µ ³¢ÀÌ´Â ¹®Á¦
  307. class CActorInstanceBackground : public IBackground
  308. {
  309. public:
  310. CActorInstanceBackground() {}
  311. virtual ~CActorInstanceBackground() {}
  312. bool IsBlock(int x, int y)
  313. {
  314. CPythonBackground& rkBG=CPythonBackground::Instance();
  315. return rkBG.isAttrOn(x, y, CTerrainImpl::ATTRIBUTE_BLOCK);
  316. }
  317. };
  319. static CActorInstanceBackground gs_kActorInstBG;
  321. bool CInstanceBase::LessRenderOrder(CInstanceBase* pkInst)
  322. {
  323. int nMainAlpha=(__GetAlphaValue() < 1.0f) ? 1 : 0;
  324. int nTestAlpha=(pkInst->__GetAlphaValue() < 1.0f) ? 1 : 0;
  325. if (nMainAlpha < nTestAlpha)
  326. return true;
  327. if (nMainAlpha > nTestAlpha)
  328. return false;
  330. if (GetRace()<pkInst->GetRace())
  331. return true;
  332. if (GetRace()>pkInst->GetRace())
  333. return false;
  335. if (GetShape()<pkInst->GetShape())
  336. return true;
  338. if (GetShape()>pkInst->GetShape())
  339. return false;
  341. UINT uLeftLODLevel=__LessRenderOrder_GetLODLevel();
  342. UINT uRightLODLevel=pkInst->__LessRenderOrder_GetLODLevel();
  343. if (uLeftLODLevel<uRightLODLevel)
  344. return true;
  345. if (uLeftLODLevel>uRightLODLevel)
  346. return false;
  348. if (m_awPart[CRaceData::PART_WEAPON]<pkInst->m_awPart[CRaceData::PART_WEAPON])
  349. return true;
  351. return false;
  352. }
  354. UINT CInstanceBase::__LessRenderOrder_GetLODLevel()
  355. {
  356. CGrannyLODController* pLODCtrl=m_GraphicThingInstance.GetLODControllerPointer(0);
  357. if (!pLODCtrl)
  358. return 0;
  360. return pLODCtrl->GetLODLevel();
  361. }
  363. bool CInstanceBase::__Background_GetWaterHeight(const TPixelPosition& c_rkPPos, float* pfHeight)
  364. {
  365. long lHeight;
  366. if (!CPythonBackground::Instance().GetWaterHeight(int(c_rkPPos.x), int(c_rkPPos.y), &lHeight))
  367. return false;
  369. *pfHeight = float(lHeight);
  371. return true;
  372. }
  374. bool CInstanceBase::__Background_IsWaterPixelPosition(const TPixelPosition& c_rkPPos)
  375. {
  376. return CPythonBackground::Instance().isAttrOn(c_rkPPos.x, c_rkPPos.y, CTerrainImpl::ATTRIBUTE_WATER);
  377. }
  379. const float PC_DUST_RANGE = 2000.0f;
  380. const float NPC_DUST_RANGE = 1000.0f;
  382. DWORD CInstanceBase::ms_dwUpdateCounter=0;
  383. DWORD CInstanceBase::ms_dwRenderCounter=0;
  384. DWORD CInstanceBase::ms_dwDeformCounter=0;
  386. CDynamicPool<CInstanceBase> CInstanceBase::ms_kPool;
  388. bool CInstanceBase::__IsInDustRange()
  389. {
  390. if (!__IsExistMainInstance())
  391. return false;
  393. CInstanceBase* pkInstMain=__GetMainInstancePtr();
  395. float fDistance=NEW_GetDistanceFromDestInstance(*pkInstMain);
  397. if (IsPC())
  398. {
  399. if (fDistance<=PC_DUST_RANGE)
  400. return true;
  401. }
  403. if (fDistance<=NPC_DUST_RANGE)
  404. return true;
  406. return false;
  407. }
  409. void CInstanceBase::__EnableSkipCollision()
  410. {
  411. if (__IsMainInstance())
  412. {
  413. TraceError("CInstanceBase::__EnableSkipCollision - ÀÚ½ÅÀº Ãæµ¹°Ë»ç½ºÅµÀÌ µÇ¸é ¾ÈµÈ´Ù!!");
  414. return;
  415. }
  416. m_GraphicThingInstance.EnableSkipCollision();
  417. }
  419. void CInstanceBase::__DisableSkipCollision()
  420. {
  421. m_GraphicThingInstance.DisableSkipCollision();
  422. }
  424. DWORD CInstanceBase::__GetShadowMapColor(float x, float y)
  425. {
  426. CPythonBackground& rkBG=CPythonBackground::Instance();
  427. return rkBG.GetShadowMapColor(x, y);
  428. }
  430. float CInstanceBase::__GetBackgroundHeight(float x, float y)
  431. {
  432. CPythonBackground& rkBG=CPythonBackground::Instance();
  433. return rkBG.GetHeight(x, y);
  434. }
  436. #ifdef __MOVIE_MODE__
  438. BOOL CInstanceBase::IsMovieMode()
  439. {
  440. if (IsAffect(AFFECT_INVISIBILITY))
  441. return true;
  443. return false;
  444. }
  446. #endif
  448. BOOL CInstanceBase::IsInvisibility()
  449. {
  450. if (IsAffect(AFFECT_INVISIBILITY))
  451. return true;
  453. return false;
  454. }
  456. BOOL CInstanceBase::IsParalysis()
  457. {
  458. return m_GraphicThingInstance.IsParalysis();
  459. }
  461. BOOL CInstanceBase::IsGameMaster()
  462. {
  463. if (m_kAffectFlagContainer.IsSet(AFFECT_YMIR))
  464. return true;
  465. return false;
  466. }
  469. BOOL CInstanceBase::IsSameEmpire(CInstanceBase& rkInstDst)
  470. {
  471. if (0 == rkInstDst.m_dwEmpireID)
  472. return TRUE;
  474. if (IsGameMaster())
  475. return TRUE;
  477. if (rkInstDst.IsGameMaster())
  478. return TRUE;
  480. if (rkInstDst.m_dwEmpireID==m_dwEmpireID)
  481. return TRUE;
  483. return FALSE;
  484. }
  486. DWORD CInstanceBase::GetEmpireID()
  487. {
  488. return m_dwEmpireID;
  489. }
  491. DWORD CInstanceBase::GetGuildID()
  492. {
  493. return m_dwGuildID;
  494. }
  496. int CInstanceBase::GetAlignment()
  497. {
  498. return m_sAlignment;
  499. }
  501. UINT CInstanceBase::GetAlignmentGrade()
  502. {
  503. if (m_sAlignment >= 12000)
  504. return 0;
  505. else if (m_sAlignment >= 8000)
  506. return 1;
  507. else if (m_sAlignment >= 4000)
  508. return 2;
  509. else if (m_sAlignment >= 1000)
  510. return 3;
  511. else if (m_sAlignment >= 0)
  512. return 4;
  513. else if (m_sAlignment > -4000)
  514. return 5;
  515. else if (m_sAlignment > -8000)
  516. return 6;
  517. else if (m_sAlignment > -12000)
  518. return 7;
  520. return 8;
  521. }
  523. int CInstanceBase::GetAlignmentType()
  524. {
  525. switch (GetAlignmentGrade())
  526. {
  527. case 0:
  528. case 1:
  529. case 2:
  530. case 3:
  531. {
  532. return ALIGNMENT_TYPE_WHITE;
  533. break;
  534. }
  536. case 5:
  537. case 6:
  538. case 7:
  539. case 8:
  540. {
  541. return ALIGNMENT_TYPE_DARK;
  542. break;
  543. }
  544. }
  546. return ALIGNMENT_TYPE_NORMAL;
  547. }
  549. BYTE CInstanceBase::GetPKMode()
  550. {
  551. return m_byPKMode;
  552. }
  554. bool CInstanceBase::IsKiller()
  555. {
  556. return m_isKiller;
  557. }
  559. bool CInstanceBase::IsPartyMember()
  560. {
  561. return m_isPartyMember;
  562. }
  564. BOOL CInstanceBase::IsInSafe()
  565. {
  566. const TPixelPosition& c_rkPPosCur=m_GraphicThingInstance.NEW_GetCurPixelPositionRef();
  567. if (CPythonBackground::Instance().isAttrOn(c_rkPPosCur.x, c_rkPPosCur.y, CTerrainImpl::ATTRIBUTE_BANPK))
  568. return TRUE;
  570. return FALSE;
  571. }
  573. float CInstanceBase::CalculateDistanceSq3d(const TPixelPosition& c_rkPPosDst)
  574. {
  575. const TPixelPosition& c_rkPPosSrc=m_GraphicThingInstance.NEW_GetCurPixelPositionRef();
  576. return SPixelPosition_CalculateDistanceSq3d(c_rkPPosSrc, c_rkPPosDst);
  577. }
  579. void CInstanceBase::OnSelected()
  580. {
  581. #ifdef __MOVIE_MODE__
  582. if (!__IsExistMainInstance())
  583. return;
  584. #endif
  586. if (IsStoneDoor())
  587. return;
  589. if (IsDead())
  590. return;
  592. __AttachSelectEffect();
  593. }
  595. void CInstanceBase::OnUnselected()
  596. {
  597. __DetachSelectEffect();
  598. }
  600. void CInstanceBase::OnTargeted()
  601. {
  602. #ifdef __MOVIE_MODE__
  603. if (!__IsExistMainInstance())
  604. return;
  605. #endif
  607. if (IsStoneDoor())
  608. return;
  610. if (IsDead())
  611. return;
  613. __AttachTargetEffect();
  614. }
  616. void CInstanceBase::OnUntargeted()
  617. {
  618. __DetachTargetEffect();
  619. }
  621. void CInstanceBase::DestroySystem()
  622. {
  623. ms_kPool.Clear();
  624. }
  626. void CInstanceBase::CreateSystem(UINT uCapacity)
  627. {
  628. ms_kPool.Create(uCapacity);
  630. memset(ms_adwCRCAffectEffect, 0, sizeof(ms_adwCRCAffectEffect));
  632. ms_fDustGap=250.0f;
  633. ms_fHorseDustGap=500.0f;
  634. }
  636. CInstanceBase* CInstanceBase::New()
  637. {
  638. return ms_kPool.Alloc();
  639. }
  641. void CInstanceBase::Delete(CInstanceBase* pkInst)
  642. {
  643. pkInst->Destroy();
  644. ms_kPool.Free(pkInst);
  645. }
  647. void CInstanceBase::SetMainInstance()
  648. {
  649. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  651. DWORD dwVID=GetVirtualID();
  652. rkChrMgr.SetMainInstance(dwVID);
  654. m_GraphicThingInstance.SetMainInstance();
  655. }
  657. CInstanceBase* CInstanceBase::__GetMainInstancePtr()
  658. {
  659. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  660. return rkChrMgr.GetMainInstancePtr();
  661. }
  663. void CInstanceBase::__ClearMainInstance()
  664. {
  665. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  666. rkChrMgr.ClearMainInstance();
  667. }
  669. /* ½ÇÁ¦ Ç÷¹À̾î ij¸¯ÅÍÀÎÁö Á¶»ç.*/
  670. bool CInstanceBase::__IsMainInstance()
  671. {
  672. if (this==__GetMainInstancePtr())
  673. return true;
  675. return false;
  676. }
  678. bool CInstanceBase::__IsExistMainInstance()
  679. {
  680. if(__GetMainInstancePtr())
  681. return true;
  682. else
  683. return false;
  684. }
  686. bool CInstanceBase::__MainCanSeeHiddenThing()
  687. {
  688. return false;
  689. // CInstanceBase * pInstance = __GetMainInstancePtr();
  690. // return pInstance->IsAffect(AFFECT_GAMJI);
  691. }
  693. float CInstanceBase::__GetBowRange()
  694. {
  695. float fRange = 2500.0f - 100.0f;
  697. if (__IsMainInstance())
  698. {
  699. IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
  700. fRange += float(rPlayer.GetStatus(POINT_BOW_DISTANCE));
  701. }
  703. return fRange;
  704. }
  706. CInstanceBase* CInstanceBase::__FindInstancePtr(DWORD dwVID)
  707. {
  708. CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
  709. return rkChrMgr.GetInstancePtr(dwVID);
  710. }
  712. bool CInstanceBase::__FindRaceType(DWORD dwRace, BYTE* pbType)
  713. {
  714. CPythonNonPlayer& rkNonPlayer=CPythonNonPlayer::Instance();
  715. return rkNonPlayer.GetInstanceType(dwRace, pbType);
  716. }
  718. bool CInstanceBase::Create(const SCreateData& c_rkCreateData)
  719. {
  720. IAbstractApplication::GetSingleton().SkipRenderBuffering(300);
  722. SetInstanceType(c_rkCreateData.m_bType);
  725. if (!SetRace(c_rkCreateData.m_dwRace))
  726. return false;
  728. #ifdef ENABLE_SUPPORT_SYSTEM
  729. int i=0;
  730. if (c_rkCreateData.m_dwRace == 34077)
  731. {
  732. SetInstanceType(CActorInstance::TYPE_NPC);
  733. SetRace(3);
  734. i=1;
  735. }
  736. #endif
  738. SetVirtualID(c_rkCreateData.m_dwVID);
  740. if (c_rkCreateData.m_isMain)
  741. SetMainInstance();
  743. if (IsGuildWall())
  744. {
  745. unsigned center_x;
  746. unsigned center_y;
  748. c_rkCreateData.m_kAffectFlags.ConvertToPosition(&center_x, &center_y);
  750. float center_z = __GetBackgroundHeight(center_x, center_y);
  751. NEW_SetPixelPosition(TPixelPosition(float(c_rkCreateData.m_lPosX), float(c_rkCreateData.m_lPosY), center_z));
  752. }
  753. else
  754. {
  755. SCRIPT_SetPixelPosition(float(c_rkCreateData.m_lPosX), float(c_rkCreateData.m_lPosY));
  756. }
  758. if (0 != c_rkCreateData.m_dwMountVnum)
  759. MountHorse(c_rkCreateData.m_dwMountVnum);
  761. SetArmor(c_rkCreateData.m_dwArmor);
  763. if (IsPC())
  764. {
  765. SetHair(c_rkCreateData.m_dwHair);
  766. SetWeapon(c_rkCreateData.m_dwWeapon);
  767. }
  769. __Create_SetName(c_rkCreateData);
  771. m_dwLevel = c_rkCreateData.m_dwLevel;
  772. m_dwGuildID = c_rkCreateData.m_dwGuildID;
  773. m_dwEmpireID = c_rkCreateData.m_dwEmpireID;
  775. SetVirtualNumber(c_rkCreateData.m_dwRace);
  776. SetRotation(c_rkCreateData.m_fRot);
  778. #ifdef ENABLE_SUPPORT_SYSTEM
  779. SetLevelText(c_rkCreateData.m_dwLevel);
  780. #endif
  782. SetAlignment(c_rkCreateData.m_sAlignment);
  783. SetPKMode(c_rkCreateData.m_byPKMode);
  785. SetMoveSpeed(c_rkCreateData.m_dwMovSpd);
  786. SetAttackSpeed(c_rkCreateData.m_dwAtkSpd);
  788. // NOTE : Dress ¸¦ ÀÔ°í ÀÖÀ¸¸é Alpha ¸¦ ³ÖÁö ¾Ê´Â´Ù.
  789. if (!IsWearingDress())
  790. {
  791. // NOTE : ¹İµå½Ã Affect ¼ÂÆà À­ÂÊ¿¡ ÀÖ¾î¾ß ÇÔ
  792. m_GraphicThingInstance.SetAlphaValue(0.0f);
  793. m_GraphicThingInstance.BlendAlphaValue(1.0f, 0.5f);
  794. }
  796. if (!IsGuildWall())
  797. {
  798. SetAffectFlagContainer(c_rkCreateData.m_kAffectFlags);
  799. }
  801. // NOTE : ¹İµå½Ã Affect ¼ÂÆà ÈÄ¿¡ ÇØ¾ß ÇÔ
  802. AttachTextTail();
  803. RefreshTextTail();
  805. if (c_rkCreateData.m_dwStateFlags & ADD_CHARACTER_STATE_SPAWN)
  806. {
  807. if (IsAffect(AFFECT_SPAWN))
  808. __AttachEffect(EFFECT_SPAWN_APPEAR);
  810. if (IsPC())
  811. {
  812. Refresh(CRaceMotionData::NAME_WAIT, true);
  813. }
  814. else
  815. {
  816. Refresh(CRaceMotionData::NAME_SPAWN, false);
  817. }
  818. }
  819. else
  820. {
  821. Refresh(CRaceMotionData::NAME_WAIT, true);
  822. }
  824. __AttachEmpireEffect(c_rkCreateData.m_dwEmpireID);
  826. RegisterBoundingSphere();
  828. if (c_rkCreateData.m_dwStateFlags & ADD_CHARACTER_STATE_DEAD)
  829. m_GraphicThingInstance.DieEnd();
  831. SetStateFlags(c_rkCreateData.m_dwStateFlags);
  833. m_GraphicThingInstance.SetBattleHitEffect(ms_adwCRCAffectEffect[EFFECT_HIT]);
  835. if (!IsPC())
  836. {
  837. DWORD dwBodyColor = CPythonNonPlayer::Instance().GetMonsterColor(c_rkCreateData.m_dwRace);
  838. if (0 != dwBodyColor)
  839. {
  840. SetModulateRenderMode();
  841. SetAddColor(dwBodyColor);
  842. }
  843. }
  845. __AttachHorseSaddle();
  847. // ±æµå ½Éº¼À» À§ÇÑ Àӽà ÄÚµå, ÀûÁ¤ À§Ä¡¸¦ ã´Â Áß
  848. const int c_iGuildSymbolRace = 14200;
  849. if (c_iGuildSymbolRace == GetRace())
  850. {
  851. std::string strFileName = GetGuildSymbolFileName(m_dwGuildID);
  852. if (IsFile(strFileName.c_str()))
  853. m_GraphicThingInstance.ChangeMaterial(strFileName.c_str());
  854. }
  856. return true;
  857. }
  860. void CInstanceBase::__Create_SetName(const SCreateData& c_rkCreateData)
  861. {
  862. if (IsGoto())
  863. {
  864. SetNameString("", 0);
  865. return;
  866. }
  867. if (IsWarp())
  868. {
  869. __Create_SetWarpName(c_rkCreateData);
  870. return;
  871. }
  873. SetNameString(c_rkCreateData.m_stName.c_str(), c_rkCreateData.m_stName.length());
  874. }
  876. void CInstanceBase::__Create_SetWarpName(const SCreateData& c_rkCreateData)
  877. {
  878. const char * c_szName;
  879. if (CPythonNonPlayer::Instance().GetName(c_rkCreateData.m_dwRace, &c_szName))
  880. {
  881. std::string strName = c_szName;
  882. int iFindingPos = strName.find_first_of(" ", 0);
  883. if (iFindingPos > 0)
  884. {
  885. strName.resize(iFindingPos);
  886. }
  887. SetNameString(strName.c_str(), strName.length());
  888. }
  889. else
  890. {
  891. SetNameString(c_rkCreateData.m_stName.c_str(), c_rkCreateData.m_stName.length());
  892. }
  893. }
  895. void CInstanceBase::SetNameString(const char* c_szName, int len)
  896. {
  897. m_stName.assign(c_szName, len);
  898. }
  901. bool CInstanceBase::SetRace(DWORD eRace)
  902. {
  903. m_dwRace = eRace;
  905. if (!m_GraphicThingInstance.SetRace(eRace))
  906. return false;
  908. if (!__FindRaceType(m_dwRace, &m_eRaceType))
  909. m_eRaceType=CActorInstance::TYPE_PC;
  911. return true;
  912. }
  914. BOOL CInstanceBase::__IsChangableWeapon(int iWeaponID)
  915. {
  916. // µå·¹½º ÀÔ°í ÀÖÀ»¶§´Â ºÎÄÉ¿ÜÀÇ Àåºñ´Â ³ª¿ÀÁö ¾Ê°Ô..
  917. if (IsWearingDress())
  918. {
  919. const int c_iBouquets[] =
  920. {
  921. 50201, // Bouquet for Assassin
  922. 50202, // Bouquet for Shaman
  923. 50203,
  924. 50204,
  925. 0, // #0000545: [M2CN] ¿şµù µå·¹½º¿Í Àåºñ Âø¿ë ¹®Á¦
  926. };
  928. for (int i = 0; c_iBouquets[i] != 0; ++i)
  929. if (iWeaponID == c_iBouquets[i])
  930. return true;
  932. return false;
  933. }
  934. else
  935. return true;
  936. }
  938. BOOL CInstanceBase::IsWearingDress()
  939. {
  940. const int c_iWeddingDressShape = 201;
  941. return c_iWeddingDressShape == m_eShape;
  942. }
  944. BOOL CInstanceBase::IsHoldingPickAxe()
  945. {
  946. const int c_iPickAxeStart = 29101;
  947. const int c_iPickAxeEnd = 29110;
  948. return m_awPart[CRaceData::PART_WEAPON] >= c_iPickAxeStart && m_awPart[CRaceData::PART_WEAPON] <= c_iPickAxeEnd;
  949. }
  951. BOOL CInstanceBase::IsNewMount()
  952. {
  953. return m_kHorse.IsNewMount();
  954. }
  956. BOOL CInstanceBase::IsMountingHorse()
  957. {
  958. return m_kHorse.IsMounting();
  959. }
  961. void CInstanceBase::MountHorse(UINT eRace)
  962. {
  963. m_kHorse.Destroy();
  964. m_kHorse.Create(m_GraphicThingInstance.NEW_GetCurPixelPositionRef(), eRace, ms_adwCRCAffectEffect[EFFECT_HIT]);
  966. SetMotionMode(CRaceMotionData::MODE_HORSE);
  967. SetRotationSpeed(c_fDefaultHorseRotationSpeed);
  969. m_GraphicThingInstance.MountHorse(m_kHorse.GetActorPtr());
  970. m_GraphicThingInstance.Stop();
  971. m_GraphicThingInstance.RefreshActorInstance();
  972. }
  974. void CInstanceBase::DismountHorse()
  975. {
  976. m_kHorse.Destroy();
  977. }
  979. void CInstanceBase::GetInfo(std::string* pstInfo)
  980. {
  981. char szInfo[256];
  982. sprintf(szInfo, "Inst - UC %d, RC %d Pool - %d ",
  983. ms_dwUpdateCounter,
  984. ms_dwRenderCounter,
  985. ms_kPool.GetCapacity()
  986. );
  988. pstInfo->append(szInfo);
  989. }
  991. void CInstanceBase::ResetPerformanceCounter()
  992. {
  993. ms_dwUpdateCounter=0;
  994. ms_dwRenderCounter=0;
  995. ms_dwDeformCounter=0;
  996. }
  998. bool CInstanceBase::NEW_IsLastPixelPosition()
  999. {
  1000. return m_GraphicThingInstance.IsPushing();
  1001. }
  1003. const TPixelPosition& CInstanceBase::NEW_GetLastPixelPositionRef()
  1004. {
  1005. return m_GraphicThingInstance.NEW_GetLastPixelPositionRef();
  1006. }
  1008. void CInstanceBase::NEW_SetDstPixelPositionZ(FLOAT z)
  1009. {
  1010. m_GraphicThingInstance.NEW_SetDstPixelPositionZ(z);
  1011. }
  1013. void CInstanceBase::NEW_SetDstPixelPosition(const TPixelPosition& c_rkPPosDst)
  1014. {
  1015. m_GraphicThingInstance.NEW_SetDstPixelPosition(c_rkPPosDst);
  1016. }
  1018. void CInstanceBase::NEW_SetSrcPixelPosition(const TPixelPosition& c_rkPPosSrc)
  1019. {
  1020. m_GraphicThingInstance.NEW_SetSrcPixelPosition(c_rkPPosSrc);
  1021. }
  1023. const TPixelPosition& CInstanceBase::NEW_GetCurPixelPositionRef()
  1024. {
  1025. return m_GraphicThingInstance.NEW_GetCurPixelPositionRef();
  1026. }
  1028. const TPixelPosition& CInstanceBase::NEW_GetDstPixelPositionRef()
  1029. {
  1030. return m_GraphicThingInstance.NEW_GetDstPixelPositionRef();
  1031. }
  1033. const TPixelPosition& CInstanceBase::NEW_GetSrcPixelPositionRef()
  1034. {
  1035. return m_GraphicThingInstance.NEW_GetSrcPixelPositionRef();
  1036. }
  1038. /////////////////////////////////////////////////////////////////////////////////////////////////
  1039. void CInstanceBase::OnSyncing()
  1040. {
  1041. m_GraphicThingInstance.__OnSyncing();
  1042. }
  1044. void CInstanceBase::OnWaiting()
  1045. {
  1046. m_GraphicThingInstance.__OnWaiting();
  1047. }
  1049. void CInstanceBase::OnMoving()
  1050. {
  1051. m_GraphicThingInstance.__OnMoving();
  1052. }
  1054. void CInstanceBase::ChangeGuild(DWORD dwGuildID)
  1055. {
  1056. m_dwGuildID=dwGuildID;
  1058. DetachTextTail();
  1059. AttachTextTail();
  1060. RefreshTextTail();
  1061. }
  1063. DWORD CInstanceBase::GetPart(CRaceData::EParts part)
  1064. {
  1065. assert(part >= 0 && part < CRaceData::PART_MAX_NUM);
  1066. return m_awPart[part];
  1067. }
  1069. DWORD CInstanceBase::GetShape()
  1070. {
  1071. return m_eShape;
  1072. }
  1074. bool CInstanceBase::CanAct()
  1075. {
  1076. return m_GraphicThingInstance.CanAct();
  1077. }
  1079. bool CInstanceBase::CanMove()
  1080. {
  1081. return m_GraphicThingInstance.CanMove();
  1082. }
  1084. bool CInstanceBase::CanUseSkill()
  1085. {
  1086. if (IsPoly())
  1087. return false;
  1089. if (IsWearingDress())
  1090. return false;
  1092. if (IsHoldingPickAxe())
  1093. return false;
  1095. if (!m_kHorse.CanUseSkill())
  1096. return false;
  1098. if (!m_GraphicThingInstance.CanUseSkill())
  1099. return false;
  1101. return true;
  1102. }
  1104. bool CInstanceBase::CanAttack()
  1105. {
  1106. if (!m_kHorse.CanAttack())
  1107. return false;
  1109. if (IsWearingDress())
  1110. return false;
  1112. if (IsHoldingPickAxe())
  1113. return false;
  1115. return m_GraphicThingInstance.CanAttack();
  1116. }
  1120. bool CInstanceBase::CanFishing()
  1121. {
  1122. return m_GraphicThingInstance.CanFishing();
  1123. }
  1126. BOOL CInstanceBase::IsBowMode()
  1127. {
  1128. return m_GraphicThingInstance.IsBowMode();
  1129. }
  1131. BOOL CInstanceBase::IsHandMode()
  1132. {
  1133. return m_GraphicThingInstance.IsHandMode();
  1134. }
  1136. BOOL CInstanceBase::IsFishingMode()
  1137. {
  1138. if (CRaceMotionData::MODE_FISHING == m_GraphicThingInstance.GetMotionMode())
  1139. return true;
  1141. return false;
  1142. }
  1144. BOOL CInstanceBase::IsFishing()
  1145. {
  1146. return m_GraphicThingInstance.IsFishing();
  1147. }
  1149. BOOL CInstanceBase::IsDead()
  1150. {
  1151. return m_GraphicThingInstance.IsDead();
  1152. }
  1154. BOOL CInstanceBase::IsStun()
  1155. {
  1156. return m_GraphicThingInstance.IsStun();
  1157. }
  1159. BOOL CInstanceBase::IsSleep()
  1160. {
  1161. return m_GraphicThingInstance.IsSleep();
  1162. }
  1165. BOOL CInstanceBase::__IsSyncing()
  1166. {
  1167. return m_GraphicThingInstance.__IsSyncing();
  1168. }
  1172. void CInstanceBase::NEW_SetOwner(DWORD dwVIDOwner)
  1173. {
  1174. m_GraphicThingInstance.SetOwner(dwVIDOwner);
  1175. }
  1177. float CInstanceBase::GetLocalTime()
  1178. {
  1179. return m_GraphicThingInstance.GetLocalTime();
  1180. }
  1183. void CInstanceBase::PushUDPState(DWORD dwCmdTime, const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
  1184. {
  1185. }
  1187. DWORD ELTimer_GetServerFrameMSec();
  1189. void CInstanceBase::PushTCPStateExpanded(DWORD dwCmdTime, const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg, UINT uTargetVID)
  1190. {
  1191. SCommand kCmdNew;
  1192. kCmdNew.m_kPPosDst = c_rkPPosDst;
  1193. kCmdNew.m_dwChkTime = dwCmdTime+100;
  1194. kCmdNew.m_dwCmdTime = dwCmdTime;
  1195. kCmdNew.m_fDstRot = fDstRot;
  1196. kCmdNew.m_eFunc = eFunc;
  1197. kCmdNew.m_uArg = uArg;
  1198. kCmdNew.m_uTargetVID = uTargetVID;
  1199. m_kQue_kCmdNew.push_back(kCmdNew);
  1200. }
  1202. void CInstanceBase::PushTCPState(DWORD dwCmdTime, const TPixelPosition& c_rkPPosDst, float fDstRot, UINT eFunc, UINT uArg)
  1203. {
  1204. if (__IsMainInstance())
  1205. {
  1206. //assert(!"CInstanceBase::PushTCPState Ç÷¹À̾î Àڽſ¡°Ô À̵¿ÆĞŶÀº ¿À¸é ¾ÈµÈ´Ù!");
  1207. TraceError("CInstanceBase::PushTCPState Ç÷¹À̾î Àڽſ¡°Ô À̵¿ÆĞŶÀº ¿À¸é ¾ÈµÈ´Ù!");
  1208. return;
  1209. }
  1211. int nNetworkGap=ELTimer_GetServerFrameMSec()-dwCmdTime;
  1213. m_nAverageNetworkGap=(m_nAverageNetworkGap*70+nNetworkGap*30)/100;
  1215. /*
  1216. if (m_dwBaseCmdTime == 0)
  1217. {
  1218. m_dwBaseChkTime = ELTimer_GetFrameMSec()-nNetworkGap;
  1219. m_dwBaseCmdTime = dwCmdTime;
  1221. Tracenf("VID[%d] ³×Æ®¿÷°¸ [%d]", GetVirtualID(), nNetworkGap);
  1222. }
  1223. */
  1225. //m_dwBaseChkTime-m_dwBaseCmdTime+ELTimer_GetServerMSec();
  1227. SCommand kCmdNew;
  1228. kCmdNew.m_kPPosDst = c_rkPPosDst;
  1229. kCmdNew.m_dwChkTime = dwCmdTime+m_nAverageNetworkGap;//m_dwBaseChkTime + (dwCmdTime - m_dwBaseCmdTime);// + nNetworkGap;
  1230. kCmdNew.m_dwCmdTime = dwCmdTime;
  1231. kCmdNew.m_fDstRot = fDstRot;
  1232. kCmdNew.m_eFunc = eFunc;
  1233. kCmdNew.m_uArg = uArg;
  1234. m_kQue_kCmdNew.push_back(kCmdNew);
  1236. //int nApplyGap=kCmdNew.m_dwChkTime-ELTimer_GetServerFrameMSec();
  1238. //if (nApplyGap<-500 || nApplyGap>500)
  1239. // Tracenf("VID[%d] NAME[%s] ³×Æ®¿÷°¸ [cur:%d ave:%d] ÀÛµ¿½Ã°£ (%d)", GetVirtualID(), GetNameString(), nNetworkGap, m_nAverageNetworkGap, nApplyGap);
  1240. }
  1242. /*
  1243. CInstanceBase::TStateQueue::iterator CInstanceBase::FindSameState(TStateQueue& rkQuekStt, DWORD dwCmdTime, UINT eFunc, UINT uArg)
  1244. {
  1245. TStateQueue::iterator i=rkQuekStt.begin();
  1246. while (rkQuekStt.end()!=i)
  1247. {
  1248. SState& rkSttEach=*i;
  1249. if (rkSttEach.m_dwCmdTime==dwCmdTime)
  1250. if (rkSttEach.m_eFunc==eFunc)
  1251. if (rkSttEach.m_uArg==uArg)
  1252. break;
  1253. ++i;
  1254. }
  1256. return i;
  1257. }
  1258. */
  1260. BOOL CInstanceBase::__CanProcessNetworkStatePacket()
  1261. {
  1262. if (m_GraphicThingInstance.IsDead())
  1263. return FALSE;
  1264. if (m_GraphicThingInstance.IsKnockDown())
  1265. return FALSE;
  1266. if (m_GraphicThingInstance.IsUsingSkill())
  1267. if (!m_GraphicThingInstance.CanCancelSkill())
  1268. return FALSE;
  1270. return TRUE;
  1271. }
  1273. BOOL CInstanceBase::__IsEnableTCPProcess(UINT eCurFunc)
  1274. {
  1275. if (m_GraphicThingInstance.IsActEmotion())
  1276. {
  1277. return FALSE;
  1278. }
  1280. if (!m_bEnableTCPState)
  1281. {
  1282. if (FUNC_EMOTION != eCurFunc)
  1283. {
  1284. return FALSE;
  1285. }
  1286. }
  1288. return TRUE;
  1289. }
  1291. void CInstanceBase::StateProcess()
  1292. {
  1293. while (1)
  1294. {
  1295. if (m_kQue_kCmdNew.empty())
  1296. return;
  1298. DWORD dwDstChkTime = m_kQue_kCmdNew.front().m_dwChkTime;
  1299. DWORD dwCurChkTime = ELTimer_GetServerFrameMSec();
  1301. if (dwCurChkTime < dwDstChkTime)
  1302. return;
  1304. SCommand kCmdTop = m_kQue_kCmdNew.front();
  1305. m_kQue_kCmdNew.pop_front();
  1307. TPixelPosition kPPosDst = kCmdTop.m_kPPosDst;
  1308. //DWORD dwCmdTime = kCmdTop.m_dwCmdTime;
  1309. FLOAT fRotDst = kCmdTop.m_fDstRot;
  1310. UINT eFunc = kCmdTop.m_eFunc;
  1311. UINT uArg = kCmdTop.m_uArg;
  1312. UINT uVID = GetVirtualID();
  1313. UINT uTargetVID = kCmdTop.m_uTargetVID;
  1315. TPixelPosition kPPosCur;
  1316. NEW_GetPixelPosition(&kPPosCur);
  1318. /*
  1319. if (IsPC())
  1320. Tracenf("%d cmd: vid=%d[%s] func=%d arg=%d curPos=(%f, %f) dstPos=(%f, %f) rot=%f (time %d)",
  1321. ELTimer_GetMSec(),
  1322. uVID, m_stName.c_str(), eFunc, uArg,
  1323. kPPosCur.x, kPPosCur.y,
  1324. kPPosDst.x, kPPosDst.y, fRotDst, dwCmdTime-m_dwBaseCmdTime);
  1325. */
  1327. TPixelPosition kPPosDir = kPPosDst - kPPosCur;
  1328. float fDirLen = (float)sqrt(kPPosDir.x * kPPosDir.x + kPPosDir.y * kPPosDir.y);
  1330. //Tracenf("°Å¸® %f", fDirLen);
  1332. if (!__CanProcessNetworkStatePacket())
  1333. {
  1334. Lognf(0, "vid=%d ¿òÁ÷ÀÏ ¼ö ¾ø´Â »óÅÂ¶ó ½ºÅµ IsDead=%d, IsKnockDown=%d", uVID, m_GraphicThingInstance.IsDead(), m_GraphicThingInstance.IsKnockDown());
  1335. return;
  1336. }
  1338. if (!__IsEnableTCPProcess(eFunc))
  1339. {
  1340. return;
  1341. }
  1343. switch (eFunc)
  1344. {
  1345. case FUNC_WAIT:
  1346. {
  1347. //Tracenf("%s (%f, %f) -> (%f, %f) ³²Àº°Å¸® %f", GetNameString(), kPPosCur.x, kPPosCur.y, kPPosDst.x, kPPosDst.y, fDirLen);
  1348. if (fDirLen > 1.0f)
  1349. {
  1350. //NEW_GetSrcPixelPositionRef() = kPPosCur;
  1351. //NEW_GetDstPixelPositionRef() = kPPosDst;
  1352. NEW_SetSrcPixelPosition(kPPosCur);
  1353. NEW_SetDstPixelPosition(kPPosDst);
  1355. __EnableSkipCollision();
  1357. m_fDstRot = fRotDst;
  1358. m_isGoing = TRUE;
  1360. m_kMovAfterFunc.eFunc = FUNC_WAIT;
  1362. if (!IsWalking())
  1363. StartWalking();
  1365. //Tracen("¸ñÇ¥Á¤Áö");
  1366. }
  1367. else
  1368. {
  1369. //Tracen("ÇöÀç Á¤Áö");
  1371. m_isGoing = FALSE;
  1373. if (!IsWaiting())
  1374. EndWalking();
  1376. SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
  1377. SetAdvancingRotation(fRotDst);
  1378. SetRotation(fRotDst);
  1379. }
  1380. break;
  1381. }
  1383. case FUNC_MOVE:
  1384. {
  1385. //NEW_GetSrcPixelPositionRef() = kPPosCur;
  1386. //NEW_GetDstPixelPositionRef() = kPPosDst;
  1387. NEW_SetSrcPixelPosition(kPPosCur);
  1388. NEW_SetDstPixelPosition(kPPosDst);
  1389. m_fDstRot = fRotDst;
  1390. m_isGoing = TRUE;
  1391. __EnableSkipCollision();
  1392. //m_isSyncMov = TRUE;
  1394. m_kMovAfterFunc.eFunc = FUNC_MOVE;
  1396. if (!IsWalking())
  1397. {
  1398. //Tracen("°È°í ÀÖÁö ¾Ê¾Æ °È±â ½ÃÀÛ");
  1399. StartWalking();
  1400. }
  1401. else
  1402. {
  1403. //Tracen("ÀÌ¹Ì °È´ÂÁß ");
  1404. }
  1405. break;
  1406. }
  1408. case FUNC_COMBO:
  1409. {
  1410. if (fDirLen >= 50.0f)
  1411. {
  1412. NEW_SetSrcPixelPosition(kPPosCur);
  1413. NEW_SetDstPixelPosition(kPPosDst);
  1414. m_fDstRot=fRotDst;
  1415. m_isGoing = TRUE;
  1416. __EnableSkipCollision();
  1418. m_kMovAfterFunc.eFunc = FUNC_COMBO;
  1419. m_kMovAfterFunc.uArg = uArg;
  1421. if (!IsWalking())
  1422. StartWalking();
  1423. }
  1424. else
  1425. {
  1426. //Tracen("´ë±â °ø°İ Á¤Áö");
  1428. m_isGoing = FALSE;
  1430. if (IsWalking())
  1431. EndWalking();
  1433. SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
  1434. RunComboAttack(fRotDst, uArg);
  1435. }
  1436. break;
  1437. }
  1439. case FUNC_ATTACK:
  1440. {
  1441. if (fDirLen>=50.0f)
  1442. {
  1443. //NEW_GetSrcPixelPositionRef() = kPPosCur;
  1444. //NEW_GetDstPixelPositionRef() = kPPosDst;
  1445. NEW_SetSrcPixelPosition(kPPosCur);
  1446. NEW_SetDstPixelPosition(kPPosDst);
  1447. m_fDstRot = fRotDst;
  1448. m_isGoing = TRUE;
  1449. __EnableSkipCollision();
  1450. //m_isSyncMov = TRUE;
  1452. m_kMovAfterFunc.eFunc = FUNC_ATTACK;
  1454. if (!IsWalking())
  1455. StartWalking();
  1457. //Tracen("³Ê¹« ¸Ö¾î¼­ À̵¿ ÈÄ °ø°İ");
  1458. }
  1459. else
  1460. {
  1461. //Tracen("³ë¸» °ø°İ Á¤Áö");
  1463. m_isGoing = FALSE;
  1465. if (IsWalking())
  1466. EndWalking();
  1468. SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
  1469. BlendRotation(fRotDst);
  1471. RunNormalAttack(fRotDst);
  1473. //Tracen("°¡±õ±â ¶§¹®¿¡ ¿öÇÁ °ø°İ");
  1474. }
  1475. break;
  1476. }
  1478. case FUNC_MOB_SKILL:
  1479. {
  1480. if (fDirLen >= 50.0f)
  1481. {
  1482. NEW_SetSrcPixelPosition(kPPosCur);
  1483. NEW_SetDstPixelPosition(kPPosDst);
  1484. m_fDstRot = fRotDst;
  1485. m_isGoing = TRUE;
  1486. __EnableSkipCollision();
  1488. m_kMovAfterFunc.eFunc = FUNC_MOB_SKILL;
  1489. m_kMovAfterFunc.uArg = uArg;
  1491. if (!IsWalking())
  1492. StartWalking();
  1493. }
  1494. else
  1495. {
  1496. m_isGoing = FALSE;
  1498. if (IsWalking())
  1499. EndWalking();
  1501. SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
  1502. BlendRotation(fRotDst);
  1504. m_GraphicThingInstance.InterceptOnceMotion(CRaceMotionData::NAME_SPECIAL_1 + uArg);
  1505. }
  1506. break;
  1507. }
  1509. case FUNC_EMOTION:
  1510. {
  1511. if (fDirLen>100.0f)
  1512. {
  1513. NEW_SetSrcPixelPosition(kPPosCur);
  1514. NEW_SetDstPixelPosition(kPPosDst);
  1515. m_fDstRot = fRotDst;
  1516. m_isGoing = TRUE;
  1518. if (__IsMainInstance())
  1519. __EnableSkipCollision();
  1521. m_kMovAfterFunc.eFunc = FUNC_EMOTION;
  1522. m_kMovAfterFunc.uArg = uArg;
  1523. m_kMovAfterFunc.uArgExpanded = uTargetVID;
  1524. m_kMovAfterFunc.kPosDst = kPPosDst;
  1526. if (!IsWalking())
  1527. StartWalking();
  1528. }
  1529. else
  1530. {
  1531. __ProcessFunctionEmotion(uArg, uTargetVID, kPPosDst);
  1532. }
  1533. break;
  1534. }
  1536. default:
  1537. {
  1538. if (eFunc & FUNC_SKILL)
  1539. {
  1540. if (fDirLen >= 50.0f)
  1541. {
  1542. //NEW_GetSrcPixelPositionRef() = kPPosCur;
  1543. //NEW_GetDstPixelPositionRef() = kPPosDst;
  1544. NEW_SetSrcPixelPosition(kPPosCur);
  1545. NEW_SetDstPixelPosition(kPPosDst);
  1546. m_fDstRot = fRotDst;
  1547. m_isGoing = TRUE;
  1548. //m_isSyncMov = TRUE;
  1549. __EnableSkipCollision();
  1551. m_kMovAfterFunc.eFunc = eFunc;
  1552. m_kMovAfterFunc.uArg = uArg;
  1554. if (!IsWalking())
  1555. StartWalking();
  1557. //Tracen("³Ê¹« ¸Ö¾î¼­ À̵¿ ÈÄ °ø°İ");
  1558. }
  1559. else
  1560. {
  1561. //Tracen("½ºÅ³ Á¤Áö");
  1563. m_isGoing = FALSE;
  1565. if (IsWalking())
  1566. EndWalking();
  1568. SCRIPT_SetPixelPosition(kPPosDst.x, kPPosDst.y);
  1569. SetAdvancingRotation(fRotDst);
  1570. SetRotation(fRotDst);
  1572. NEW_UseSkill(0, eFunc & 0x7f, uArg&0x0f, (uArg>>4) ? true : false);
  1573. //Tracen("°¡±õ±â ¶§¹®¿¡ ¿öÇÁ °ø°İ");
  1574. }
  1575. }
  1576. break;
  1577. }
  1578. }
  1579. }
  1580. }
  1583. void CInstanceBase::MovementProcess()
  1584. {
  1585. TPixelPosition kPPosCur;
  1586. NEW_GetPixelPosition(&kPPosCur);
  1588. // ·»´õ¸µ ÁÂÇ¥°èÀ̹ǷΠy¸¦ -È­Çؼ­ ´õÇÑ´Ù.
  1590. TPixelPosition kPPosNext;
  1591. {
  1592. const D3DXVECTOR3 & c_rkV3Mov = m_GraphicThingInstance.GetMovementVectorRef();
  1594. kPPosNext.x = kPPosCur.x + (+c_rkV3Mov.x);
  1595. kPPosNext.y = kPPosCur.y + (-c_rkV3Mov.y);
  1596. kPPosNext.z = kPPosCur.z + (+c_rkV3Mov.z);
  1597. }
  1599. TPixelPosition kPPosDeltaSC = kPPosCur - NEW_GetSrcPixelPositionRef();
  1600. TPixelPosition kPPosDeltaSN = kPPosNext - NEW_GetSrcPixelPositionRef();
  1601. TPixelPosition kPPosDeltaSD = NEW_GetDstPixelPositionRef() - NEW_GetSrcPixelPositionRef();
  1603. float fCurLen = sqrtf(kPPosDeltaSC.x * kPPosDeltaSC.x + kPPosDeltaSC.y * kPPosDeltaSC.y);
  1604. float fNextLen = sqrtf(kPPosDeltaSN.x * kPPosDeltaSN.x + kPPosDeltaSN.y * kPPosDeltaSN.y);
  1605. float fTotalLen = sqrtf(kPPosDeltaSD.x * kPPosDeltaSD.x + kPPosDeltaSD.y * kPPosDeltaSD.y);
  1606. float fRestLen = fTotalLen - fCurLen;
  1608. if (__IsMainInstance())
  1609. {
  1610. if (m_isGoing && IsWalking())
  1611. {
  1612. float fDstRot = NEW_GetAdvancingRotationFromPixelPosition(NEW_GetSrcPixelPositionRef(), NEW_GetDstPixelPositionRef());
  1614. SetAdvancingRotation(fDstRot);
  1616. if (fRestLen<=0.0)
  1617. {
  1618. if (IsWalking())
  1619. EndWalking();
  1621. //Tracen("¸ñÇ¥ µµ´Ş Á¤Áö");
  1623. m_isGoing = FALSE;
  1625. BlockMovement();
  1627. if (FUNC_EMOTION == m_kMovAfterFunc.eFunc)
  1628. {
  1629. DWORD dwMotionNumber = m_kMovAfterFunc.uArg;
  1630. DWORD dwTargetVID = m_kMovAfterFunc.uArgExpanded;
  1631. __ProcessFunctionEmotion(dwMotionNumber, dwTargetVID, m_kMovAfterFunc.kPosDst);
  1632. m_kMovAfterFunc.eFunc = FUNC_WAIT;
  1633. return;
  1634. }
  1635. }
  1636. }
  1637. }
  1638. else
  1639. {
  1640. if (m_isGoing && IsWalking())
  1641. {
  1642. float fDstRot = NEW_GetAdvancingRotationFromPixelPosition(NEW_GetSrcPixelPositionRef(), NEW_GetDstPixelPositionRef());
  1644. SetAdvancingRotation(fDstRot);
  1646. // ¸¸¾à ·»ÅϽð¡ ´Ê¾î ³Ê¹« ¸¹ÀÌ À̵¿Çß´Ù¸é..
  1647. if (fRestLen < -100.0f)
  1648. {
  1649. NEW_SetSrcPixelPosition(kPPosCur);
  1651. float fDstRot = NEW_GetAdvancingRotationFromPixelPosition(kPPosCur, NEW_GetDstPixelPositionRef());
  1652. SetAdvancingRotation(fDstRot);
  1653. //Tracenf("VID %d ¿À¹ö ¹æÇâ¼³Á¤ (%f, %f) %f rest %f", GetVirtualID(), kPPosCur.x, kPPosCur.y, fDstRot, fRestLen);
  1655. // À̵¿ÁßÀ̶ó¸é ´ÙÀ½¹ø¿¡ ¸ØÃß°Ô ÇÑ´Ù
  1656. if (FUNC_MOVE == m_kMovAfterFunc.eFunc)
  1657. {
  1658. m_kMovAfterFunc.eFunc = FUNC_WAIT;
  1659. }
  1660. }
  1661. // µµÂøÇß´Ù¸é...
  1662. else if (fCurLen <= fTotalLen && fTotalLen <= fNextLen)
  1663. {
  1664. if (m_GraphicThingInstance.IsDead() || m_GraphicThingInstance.IsKnockDown())
  1665. {
  1666. __DisableSkipCollision();
  1668. //Tracen("»ç¸Á »óÅÂ¶ó µ¿ÀÛ ½ºÅµ");
  1670. m_isGoing = FALSE;
  1672. //Tracen("Çൿ ºÒ´É »óŶó ÀÌÈÄ µ¿ÀÛ ½ºÅµ");
  1673. }
  1674. else
  1675. {
  1676. switch (m_kMovAfterFunc.eFunc)
  1677. {
  1678. case FUNC_ATTACK:
  1679. {
  1680. if (IsWalking())
  1681. EndWalking();
  1683. __DisableSkipCollision();
  1684. m_isGoing = FALSE;
  1686. BlockMovement();
  1687. SCRIPT_SetPixelPosition(NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y);
  1688. SetAdvancingRotation(m_fDstRot);
  1689. SetRotation(m_fDstRot);
  1691. RunNormalAttack(m_fDstRot);
  1692. break;
  1693. }
  1695. case FUNC_COMBO:
  1696. {
  1697. if (IsWalking())
  1698. EndWalking();
  1700. __DisableSkipCollision();
  1701. m_isGoing = FALSE;
  1703. BlockMovement();
  1704. SCRIPT_SetPixelPosition(NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y);
  1705. RunComboAttack(m_fDstRot, m_kMovAfterFunc.uArg);
  1706. break;
  1707. }
  1709. case FUNC_EMOTION:
  1710. {
  1711. m_isGoing = FALSE;
  1712. m_kMovAfterFunc.eFunc = FUNC_WAIT;
  1713. __DisableSkipCollision();
  1714. BlockMovement();
  1716. DWORD dwMotionNumber = m_kMovAfterFunc.uArg;
  1717. DWORD dwTargetVID = m_kMovAfterFunc.uArgExpanded;
  1718. __ProcessFunctionEmotion(dwMotionNumber, dwTargetVID, m_kMovAfterFunc.kPosDst);
  1719. break;
  1720. }
  1722. case FUNC_MOVE:
  1723. {
  1724. break;
  1725. }
  1727. case FUNC_MOB_SKILL:
  1728. {
  1729. if (IsWalking())
  1730. EndWalking();
  1732. __DisableSkipCollision();
  1733. m_isGoing = FALSE;
  1735. BlockMovement();
  1736. SCRIPT_SetPixelPosition(NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y);
  1737. SetAdvancingRotation(m_fDstRot);
  1738. SetRotation(m_fDstRot);
  1740. m_GraphicThingInstance.InterceptOnceMotion(CRaceMotionData::NAME_SPECIAL_1 + m_kMovAfterFunc.uArg);
  1741. break;
  1742. }
  1744. default:
  1745. {
  1746. if (m_kMovAfterFunc.eFunc & FUNC_SKILL)
  1747. {
  1748. SetAdvancingRotation(m_fDstRot);
  1749. BlendRotation(m_fDstRot);
  1750. NEW_UseSkill(0, m_kMovAfterFunc.eFunc & 0x7f, m_kMovAfterFunc.uArg&0x0f, (m_kMovAfterFunc.uArg>>4) ? true : false);
  1751. }
  1752. else
  1753. {
  1754. //Tracenf("VID %d ½ºÅ³ °ø°İ (%f, %f) rot %f", GetVirtualID(), NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y, m_fDstRot);
  1756. __DisableSkipCollision();
  1757. m_isGoing = FALSE;
  1759. BlockMovement();
  1760. SCRIPT_SetPixelPosition(NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y);
  1761. SetAdvancingRotation(m_fDstRot);
  1762. BlendRotation(m_fDstRot);
  1763. if (!IsWaiting())
  1764. {
  1765. EndWalking();
  1766. }
  1768. //Tracenf("VID %d Á¤Áö (%f, %f) rot %f IsWalking %d", GetVirtualID(), NEW_GetDstPixelPositionRef().x, NEW_GetDstPixelPositionRef().y, m_fDstRot, IsWalking());
  1769. }
  1770. break;
  1771. }
  1772. }
  1774. }
  1775. }
  1777. }
  1778. }
  1780. if (IsWalking() || m_GraphicThingInstance.IsUsingMovingSkill())
  1781. {
  1782. float fRotation = m_GraphicThingInstance.GetRotation();
  1783. float fAdvancingRotation = m_GraphicThingInstance.GetAdvancingRotation();
  1784. int iDirection = GetRotatingDirection(fRotation, fAdvancingRotation);
  1786. if (DEGREE_DIRECTION_SAME != m_iRotatingDirection)
  1787. {
  1788. if (DEGREE_DIRECTION_LEFT == iDirection)
  1789. {
  1790. fRotation = fmodf(fRotation + m_fRotSpd*m_GraphicThingInstance.GetSecondElapsed(), 360.0f);
  1791. }
  1792. else if (DEGREE_DIRECTION_RIGHT == iDirection)
  1793. {
  1794. fRotation = fmodf(fRotation - m_fRotSpd*m_GraphicThingInstance.GetSecondElapsed() + 360.0f, 360.0f);
  1795. }
  1797. if (m_iRotatingDirection != GetRotatingDirection(fRotation, fAdvancingRotation))
  1798. {
  1799. m_iRotatingDirection = DEGREE_DIRECTION_SAME;
  1800. fRotation = fAdvancingRotation;
  1801. }
  1803. m_GraphicThingInstance.SetRotation(fRotation);
  1804. }
  1806. if (__IsInDustRange())
  1807. {
  1808. float fDustDistance = NEW_GetDistanceFromDestPixelPosition(m_kPPosDust);
  1809. if (IsMountingHorse())
  1810. {
  1811. if (fDustDistance > ms_fHorseDustGap)
  1812. {
  1813. NEW_GetPixelPosition(&m_kPPosDust);
  1814. __AttachEffect(EFFECT_HORSE_DUST);
  1815. }
  1816. }
  1817. else
  1818. {
  1819. if (fDustDistance > ms_fDustGap)
  1820. {
  1821. NEW_GetPixelPosition(&m_kPPosDust);
  1822. __AttachEffect(EFFECT_DUST);
  1823. }
  1824. }
  1825. }
  1826. }
  1827. }
  1829. void CInstanceBase::__ProcessFunctionEmotion(DWORD dwMotionNumber, DWORD dwTargetVID, const TPixelPosition & c_rkPosDst)
  1830. {
  1831. if (IsWalking())
  1832. EndWalkingWithoutBlending();
  1834. __EnableChangingTCPState();
  1835. SCRIPT_SetPixelPosition(c_rkPosDst.x, c_rkPosDst.y);
  1837. CInstanceBase * pTargetInstance = CPythonCharacterManager::Instance().GetInstancePtr(dwTargetVID);
  1838. if (pTargetInstance)
  1839. {
  1840. pTargetInstance->__EnableChangingTCPState();
  1842. if (pTargetInstance->IsWalking())
  1843. pTargetInstance->EndWalkingWithoutBlending();
  1845. WORD wMotionNumber1 = HIWORD(dwMotionNumber);
  1846. WORD wMotionNumber2 = LOWORD(dwMotionNumber);
  1848. int src_job = RaceToJob(GetRace());
  1849. int dst_job = RaceToJob(pTargetInstance->GetRace());
  1851. NEW_LookAtDestInstance(*pTargetInstance);
  1852. m_GraphicThingInstance.InterceptOnceMotion(wMotionNumber1 + dst_job);
  1853. m_GraphicThingInstance.SetRotation(m_GraphicThingInstance.GetTargetRotation());
  1854. m_GraphicThingInstance.SetAdvancingRotation(m_GraphicThingInstance.GetTargetRotation());
  1856. pTargetInstance->NEW_LookAtDestInstance(*this);
  1857. pTargetInstance->m_GraphicThingInstance.InterceptOnceMotion(wMotionNumber2 + src_job);
  1858. pTargetInstance->m_GraphicThingInstance.SetRotation(pTargetInstance->m_GraphicThingInstance.GetTargetRotation());
  1859. pTargetInstance->m_GraphicThingInstance.SetAdvancingRotation(pTargetInstance->m_GraphicThingInstance.GetTargetRotation());
  1861. if (pTargetInstance->__IsMainInstance())
  1862. {
  1863. IAbstractPlayer & rPlayer=IAbstractPlayer::GetSingleton();
  1864. rPlayer.EndEmotionProcess();
  1865. }
  1866. }
  1868. if (__IsMainInstance())
  1869. {
  1870. IAbstractPlayer & rPlayer=IAbstractPlayer::GetSingleton();
  1871. rPlayer.EndEmotionProcess();
  1872. }
  1873. }
  1875. ///////////////////////////////////////////////////////////////////////////////////////////////////
  1876. // Update & Deform & Render
  1878. int g_iAccumulationTime = 0;
  1880. void CInstanceBase::Update()
  1881. {
  1882. ++ms_dwUpdateCounter;
  1884. StateProcess();
  1885. m_GraphicThingInstance.PhysicsProcess();
  1886. m_GraphicThingInstance.RotationProcess();
  1887. m_GraphicThingInstance.ComboProcess();
  1888. m_GraphicThingInstance.AccumulationMovement();
  1890. if (m_GraphicThingInstance.IsMovement())
  1891. {
  1892. TPixelPosition kPPosCur;
  1893. NEW_GetPixelPosition(&kPPosCur);
  1895. DWORD dwCurTime=ELTimer_GetFrameMSec();
  1896. //if (m_dwNextUpdateHeightTime<dwCurTime)
  1897. {
  1898. m_dwNextUpdateHeightTime=dwCurTime;
  1899. kPPosCur.z = __GetBackgroundHeight(kPPosCur.x, kPPosCur.y);
  1900. NEW_SetPixelPosition(kPPosCur);
  1901. }
  1903. // SetMaterialColor
  1904. {
  1905. DWORD dwMtrlColor=__GetShadowMapColor(kPPosCur.x, kPPosCur.y);
  1906. m_GraphicThingInstance.SetMaterialColor(dwMtrlColor);
  1907. }
  1908. }
  1910. m_GraphicThingInstance.UpdateAdvancingPointInstance();
  1912. AttackProcess();
  1913. MovementProcess();
  1915. m_GraphicThingInstance.MotionProcess(IsPC());
  1916. if (IsMountingHorse())
  1917. {
  1918. m_kHorse.m_pkActor->HORSE_MotionProcess(FALSE);
  1919. }
  1921. __ComboProcess();
  1923. ProcessDamage();
  1925. }
  1927. void CInstanceBase::Transform()
  1928. {
  1929. if (__IsSyncing())
  1930. {
  1931. //OnSyncing();
  1932. }
  1933. else
  1934. {
  1935. if (IsWalking() || m_GraphicThingInstance.IsUsingMovingSkill())
  1936. {
  1937. const D3DXVECTOR3& c_rv3Movment=m_GraphicThingInstance.GetMovementVectorRef();
  1939. float len=(c_rv3Movment.x*c_rv3Movment.x)+(c_rv3Movment.y*c_rv3Movment.y);
  1940. if (len>1.0f)
  1941. OnMoving();
  1942. else
  1943. OnWaiting();
  1944. }
  1945. }
  1947. m_GraphicThingInstance.INSTANCEBASE_Transform();
  1948. }
  1951. void CInstanceBase::Deform()
  1952. {
  1953. // 2004.07.17.levites.isShow¸¦ ViewFrustumCheck·Î º¯°æ
  1954. if (!__CanRender())
  1955. return;
  1957. ++ms_dwDeformCounter;
  1959. m_GraphicThingInstance.INSTANCEBASE_Deform();
  1961. m_kHorse.Deform();
  1962. }
  1964. void CInstanceBase::RenderTrace()
  1965. {
  1966. if (!__CanRender())
  1967. return;
  1969. m_GraphicThingInstance.RenderTrace();
  1970. }
  1975. void CInstanceBase::Render()
  1976. {
  1977. // 2004.07.17.levites.isShow¸¦ ViewFrustumCheck·Î º¯°æ
  1978. if (!__CanRender())
  1979. return;
  1981. ++ms_dwRenderCounter;
  1983. m_kHorse.Render();
  1984. m_GraphicThingInstance.Render();
  1986. if (CActorInstance::IsDirLine())
  1987. {
  1988. if (NEW_GetDstPixelPositionRef().x != 0.0f)
  1989. {
  1990. static CScreen s_kScreen;
  1992. STATEMANAGER.SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
  1993. STATEMANAGER.SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
  1994. STATEMANAGER.SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
  1995. STATEMANAGER.SaveRenderState(D3DRS_ZENABLE, FALSE);
  1996. STATEMANAGER.SetRenderState(D3DRS_FOGENABLE, FALSE);
  1997. STATEMANAGER.SetRenderState(D3DRS_LIGHTING, FALSE);
  1999. TPixelPosition px;
  2000. m_GraphicThingInstance.GetPixelPosition(&px);
  2001. D3DXVECTOR3 kD3DVt3Cur(px.x, px.y, px.z);
  2002. //D3DXVECTOR3 kD3DVt3Cur(NEW_GetSrcPixelPositionRef().x, -NEW_GetSrcPixelPositionRef().y, NEW_GetSrcPixelPositionRef().z);
  2003. D3DXVECTOR3 kD3DVt3Dest(NEW_GetDstPixelPositionRef().x, -NEW_GetDstPixelPositionRef().y, NEW_GetDstPixelPositionRef().z);
  2005. //printf("%s %f\n", GetNameString(), kD3DVt3Cur.y - kD3DVt3Dest.y);
  2006. //float fdx = NEW_GetDstPixelPositionRef().x - NEW_GetSrcPixelPositionRef().x;
  2007. //float fdy = NEW_GetDstPixelPositionRef().y - NEW_GetSrcPixelPositionRef().y;
  2009. s_kScreen.SetDiffuseColor(0.0f, 0.0f, 1.0f);
  2010. s_kScreen.RenderLine3d(kD3DVt3Cur.x, kD3DVt3Cur.y, px.z, kD3DVt3Dest.x, kD3DVt3Dest.y, px.z);
  2011. STATEMANAGER.RestoreRenderState(D3DRS_ZENABLE);
  2012. STATEMANAGER.SetRenderState(D3DRS_FOGENABLE, TRUE);
  2013. STATEMANAGER.SetRenderState(D3DRS_LIGHTING, TRUE);
  2014. }
  2015. }
  2016. }
  2018. void CInstanceBase::RenderToShadowMap()
  2019. {
  2020. if (IsDoor())
  2021. return;
  2023. if (IsBuilding())
  2024. return;
  2026. if (!__CanRender())
  2027. return;
  2029. if (!__IsExistMainInstance())
  2030. return;
  2032. CInstanceBase* pkInstMain=__GetMainInstancePtr();
  2034. const float SHADOW_APPLY_DISTANCE = 2500.0f;
  2036. float fDistance=NEW_GetDistanceFromDestInstance(*pkInstMain);
  2037. if (fDistance>=SHADOW_APPLY_DISTANCE)
  2038. return;
  2040. m_GraphicThingInstance.RenderToShadowMap();
  2041. }
  2043. void CInstanceBase::RenderCollision()
  2044. {
  2045. m_GraphicThingInstance.RenderCollisionData();
  2046. }
  2048. ///////////////////////////////////////////////////////////////////////////////////////////////////
  2049. // Setting & Getting Data
  2051. void CInstanceBase::SetVirtualID(DWORD dwVirtualID)
  2052. {
  2053. m_GraphicThingInstance.SetVirtualID(dwVirtualID);
  2054. }
  2056. void CInstanceBase::SetVirtualNumber(DWORD dwVirtualNumber)
  2057. {
  2058. m_dwVirtualNumber = dwVirtualNumber;
  2059. }
  2061. void CInstanceBase::SetInstanceType(int iInstanceType)
  2062. {
  2063. m_GraphicThingInstance.SetActorType(iInstanceType);
  2064. }
  2066. void CInstanceBase::SetAlignment(short sAlignment)
  2067. {
  2068. m_sAlignment = sAlignment;
  2069. RefreshTextTailTitle();
  2070. }
  2072. void CInstanceBase::SetPKMode(BYTE byPKMode)
  2073. {
  2074. if (m_byPKMode == byPKMode)
  2075. return;
  2077. m_byPKMode = byPKMode;
  2079. if (__IsMainInstance())
  2080. {
  2081. IAbstractPlayer& rPlayer=IAbstractPlayer::GetSingleton();
  2082. rPlayer.NotifyChangePKMode();
  2083. }
  2084. }
  2086. void CInstanceBase::SetKiller(bool bFlag)
  2087. {
  2088. if (m_isKiller == bFlag)
  2089. return;
  2091. m_isKiller = bFlag;
  2092. RefreshTextTail();
  2093. }
  2095. void CInstanceBase::SetPartyMemberFlag(bool bFlag)
  2096. {
  2097. m_isPartyMember = bFlag;
  2098. }
  2100. void CInstanceBase::SetStateFlags(DWORD dwStateFlags)
  2101. {
  2102. if (dwStateFlags & ADD_CHARACTER_STATE_KILLER)
  2103. SetKiller(TRUE);
  2104. else
  2105. SetKiller(FALSE);
  2107. if (dwStateFlags & ADD_CHARACTER_STATE_PARTY)
  2108. SetPartyMemberFlag(TRUE);
  2109. else
  2110. SetPartyMemberFlag(FALSE);
  2111. }
  2113. void CInstanceBase::SetComboType(UINT uComboType)
  2114. {
  2115. m_GraphicThingInstance.SetComboType(uComboType);
  2116. }
  2118. const char * CInstanceBase::GetNameString()
  2119. {
  2120. return m_stName.c_str();
  2121. }
  2123. DWORD CInstanceBase::GetRace()
  2124. {
  2125. return m_dwRace;
  2126. }
  2129. bool CInstanceBase::IsConflictAlignmentInstance(CInstanceBase& rkInstVictim)
  2130. {
  2131. if (PK_MODE_PROTECT == rkInstVictim.GetPKMode())
  2132. return false;
  2134. switch (GetAlignmentType())
  2135. {
  2136. case ALIGNMENT_TYPE_NORMAL:
  2137. case ALIGNMENT_TYPE_WHITE:
  2138. if (ALIGNMENT_TYPE_DARK == rkInstVictim.GetAlignmentType())
  2139. return true;
  2140. break;
  2141. case ALIGNMENT_TYPE_DARK:
  2142. if (GetAlignmentType() != rkInstVictim.GetAlignmentType())
  2143. return true;
  2144. break;
  2145. }
  2147. return false;
  2148. }
  2150. void CInstanceBase::SetDuelMode(DWORD type)
  2151. {
  2152. m_dwDuelMode = type;
  2153. }
  2155. DWORD CInstanceBase::GetDuelMode()
  2156. {
  2157. return m_dwDuelMode;
  2158. }
  2160. bool CInstanceBase::IsAttackableInstance(CInstanceBase& rkInstVictim)
  2161. {
  2162. #ifdef ENABLE_SUPPORT_SYSTEM
  2163. if (rkInstVictim.GetInstanceType() == CActorInstance::TYPE_NPC && rkInstVictim.GetRace() == 3)
  2164. {
  2165. return false;
  2166. }
  2167. #endif
  2168. if (__IsMainInstance())
  2169. {
  2170. CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
  2171. if(rkPlayer.IsObserverMode())
  2172. return false;
  2173. }
  2175. if (GetVirtualID() == rkInstVictim.GetVirtualID())
  2176. return false;
  2178. if (IsStone())
  2179. {
  2180. if (rkInstVictim.IsPC())
  2181. return true;
  2182. }
  2183. else if (IsPC())
  2184. {
  2185. if (rkInstVictim.IsStone())
  2186. return true;
  2188. if (rkInstVictim.IsPC())
  2189. {
  2190. if (GetDuelMode())
  2191. {
  2192. switch(GetDuelMode())
  2193. {
  2194. case DUEL_CANNOTATTACK:
  2195. return false;
  2196. case DUEL_START:
  2197. if(__FindDUELKey(GetVirtualID(),rkInstVictim.GetVirtualID()))
  2198. return true;
  2199. else
  2200. return false;
  2201. }
  2202. }
  2203. if (PK_MODE_GUILD == GetPKMode())
  2204. if (GetGuildID() == rkInstVictim.GetGuildID())
  2205. return false;
  2207. if (rkInstVictim.IsKiller())
  2208. if (!IAbstractPlayer::GetSingleton().IsSamePartyMember(GetVirtualID(), rkInstVictim.GetVirtualID()))
  2209. return true;
  2211. if (PK_MODE_PROTECT != GetPKMode())
  2212. {
  2213. if (PK_MODE_FREE == GetPKMode())
  2214. {
  2215. if (PK_MODE_PROTECT != rkInstVictim.GetPKMode())
  2216. if (!IAbstractPlayer::GetSingleton().IsSamePartyMember(GetVirtualID(), rkInstVictim.GetVirtualID()))
  2217. return true;
  2218. }
  2219. if (PK_MODE_GUILD == GetPKMode())
  2220. {
  2221. if (PK_MODE_PROTECT != rkInstVictim.GetPKMode())
  2222. if (!IAbstractPlayer::GetSingleton().IsSamePartyMember(GetVirtualID(), rkInstVictim.GetVirtualID()))
  2223. if (GetGuildID() != rkInstVictim.GetGuildID())
  2224. return true;
  2225. }
  2226. }
  2228. if (IsSameEmpire(rkInstVictim))
  2229. {
  2230. if (IsPVPInstance(rkInstVictim))
  2231. return true;
  2233. if (PK_MODE_REVENGE == GetPKMode())
  2234. if (!IAbstractPlayer::GetSingleton().IsSamePartyMember(GetVirtualID(), rkInstVictim.GetVirtualID()))
  2235. if (IsConflictAlignmentInstance(rkInstVictim))
  2236. return true;
  2237. }
  2238. else
  2239. {
  2240. return true;
  2241. }
  2242. }
  2244. if (rkInstVictim.IsEnemy())
  2245. return true;
  2247. if (rkInstVictim.IsWoodenDoor())
  2248. return true;
  2249. }
  2250. else if (IsEnemy())
  2251. {
  2252. if (rkInstVictim.IsPC())
  2253. return true;
  2255. if (rkInstVictim.IsBuilding())
  2256. return true;
  2258. }
  2259. else if (IsPoly())
  2260. {
  2261. if (rkInstVictim.IsPC())
  2262. return true;
  2264. if (rkInstVictim.IsEnemy())
  2265. return true;
  2266. }
  2267. return false;
  2268. }
  2270. bool CInstanceBase::IsTargetableInstance(CInstanceBase& rkInstVictim)
  2271. {
  2272. return rkInstVictim.CanPickInstance();
  2273. }
  2275. // 2004. 07. 07. [levites] - ½ºÅ³ »ç¿ëÁß Å¸°ÙÀÌ ¹Ù²î´Â ¹®Á¦ ÇØ°áÀ» À§ÇÑ ÄÚµå
  2276. bool CInstanceBase::CanChangeTarget()
  2277. {
  2278. return m_GraphicThingInstance.CanChangeTarget();
  2279. }
  2281. // 2004.07.17.levites.isShow¸¦ ViewFrustumCheck·Î º¯°æ
  2282. bool CInstanceBase::CanPickInstance()
  2283. {
  2284. if (!__IsInViewFrustum())
  2285. return false;
  2287. if (IsDoor())
  2288. {
  2289. if (IsDead())
  2290. return false;
  2291. }
  2293. if (IsPC())
  2294. {
  2295. if (IsAffect(AFFECT_EUNHYEONG))
  2296. {
  2297. if (!__MainCanSeeHiddenThing())
  2298. return false;
  2299. }
  2300. if (IsAffect(AFFECT_REVIVE_INVISIBILITY))
  2301. return false;
  2302. if (IsAffect(AFFECT_INVISIBILITY))
  2303. return false;
  2304. }
  2306. if (IsDead())
  2307. return false;
  2309. return true;
  2310. }
  2312. bool CInstanceBase::CanViewTargetHP(CInstanceBase& rkInstVictim)
  2313. {
  2314. if (rkInstVictim.IsStone())
  2315. return true;
  2316. if (rkInstVictim.IsWoodenDoor())
  2317. return true;
  2318. if (rkInstVictim.IsEnemy())
  2319. return true;
  2321. return false;
  2322. }
  2324. BOOL CInstanceBase::IsPoly()
  2325. {
  2326. return m_GraphicThingInstance.IsPoly();
  2327. }
  2329. BOOL CInstanceBase::IsPC()
  2330. {
  2331. return m_GraphicThingInstance.IsPC();
  2332. }
  2334. BOOL CInstanceBase::IsNPC()
  2335. {
  2336. return m_GraphicThingInstance.IsNPC();
  2337. }
  2339. BOOL CInstanceBase::IsEnemy()
  2340. {
  2341. return m_GraphicThingInstance.IsEnemy();
  2342. }
  2344. BOOL CInstanceBase::IsStone()
  2345. {
  2346. return m_GraphicThingInstance.IsStone();
  2347. }
  2350. BOOL CInstanceBase::IsGuildWall() //IsBuilding ±æµå°Ç¹°Àüü IsGuildWallÀº ´ãÀ庮¸¸(¹®Àº Á¦¿Ü)
  2351. {
  2352. return IsWall(m_dwRace);
  2353. }
  2356. BOOL CInstanceBase::IsResource()
  2357. {
  2358. switch (m_dwVirtualNumber)
  2359. {
  2360. case 20047:
  2361. case 20048:
  2362. case 20049:
  2363. case 20050:
  2364. case 20051:
  2365. case 20052:
  2366. case 20053:
  2367. case 20054:
  2368. case 20055:
  2369. case 20056:
  2370. case 20057:
  2371. case 20058:
  2372. case 20059:
  2373. case 30301:
  2374. case 30302:
  2375. case 30303:
  2376. case 30304:
  2377. case 30305:
  2378. return TRUE;
  2379. }
  2381. return FALSE;
  2382. }
  2384. BOOL CInstanceBase::IsWarp()
  2385. {
  2386. return m_GraphicThingInstance.IsWarp();
  2387. }
  2389. BOOL CInstanceBase::IsGoto()
  2390. {
  2391. return m_GraphicThingInstance.IsGoto();
  2392. }
  2394. BOOL CInstanceBase::IsObject()
  2395. {
  2396. return m_GraphicThingInstance.IsObject();
  2397. }
  2399. BOOL CInstanceBase::IsBuilding()
  2400. {
  2401. return m_GraphicThingInstance.IsBuilding();
  2402. }
  2404. BOOL CInstanceBase::IsDoor()
  2405. {
  2406. return m_GraphicThingInstance.IsDoor();
  2407. }
  2409. BOOL CInstanceBase::IsWoodenDoor()
  2410. {
  2411. if (m_GraphicThingInstance.IsDoor())
  2412. {
  2413. int vnum = GetVirtualNumber();
  2414. if (vnum == 13000) // ³ª¹«¹®
  2415. return true;
  2416. else if (vnum >= 30111 && vnum <= 30119) // »ç±Í¹®
  2417. return true;
  2418. else
  2419. return false;
  2420. }
  2421. else
  2422. {
  2423. return false;
  2424. }
  2425. }
  2427. BOOL CInstanceBase::IsStoneDoor()
  2428. {
  2429. return m_GraphicThingInstance.IsDoor() && 13001 == GetVirtualNumber();
  2430. }
  2432. BOOL CInstanceBase::IsFlag()
  2433. {
  2434. if (GetRace() == 20035)
  2435. return TRUE;
  2436. if (GetRace() == 20036)
  2437. return TRUE;
  2438. if (GetRace() == 20037)
  2439. return TRUE;
  2441. return FALSE;
  2442. }
  2444. BOOL CInstanceBase::IsForceVisible()
  2445. {
  2446. if (IsAffect(AFFECT_SHOW_ALWAYS))
  2447. return TRUE;
  2449. if (IsObject() || IsBuilding() || IsDoor() )
  2450. return TRUE;
  2452. return FALSE;
  2453. }
  2455. int CInstanceBase::GetInstanceType()
  2456. {
  2457. return m_GraphicThingInstance.GetActorType();
  2458. }
  2460. DWORD CInstanceBase::GetVirtualID()
  2461. {
  2462. return m_GraphicThingInstance.GetVirtualID();
  2463. }
  2465. DWORD CInstanceBase::GetVirtualNumber()
  2466. {
  2467. return m_dwVirtualNumber;
  2468. }
  2470. // 2004.07.17.levites.isShow¸¦ ViewFrustumCheck·Î º¯°æ
  2471. bool CInstanceBase::__IsInViewFrustum()
  2472. {
  2473. return m_GraphicThingInstance.isShow();
  2474. }
  2476. bool CInstanceBase::__CanRender()
  2477. {
  2478. if (!__IsInViewFrustum())
  2479. return false;
  2480. if (IsAffect(AFFECT_INVISIBILITY))
  2481. return false;
  2483. return true;
  2484. }
  2487. ///////////////////////////////////////////////////////////////////////////////////////////////////
  2488. // Graphic Control
  2490. bool CInstanceBase::IntersectBoundingBox()
  2491. {
  2492. float u, v, t;
  2493. return m_GraphicThingInstance.Intersect(&u, &v, &t);
  2494. }
  2496. bool CInstanceBase::IntersectDefendingSphere()
  2497. {
  2498. return m_GraphicThingInstance.IntersectDefendingSphere();
  2499. }
  2501. float CInstanceBase::GetDistance(CInstanceBase * pkTargetInst)
  2502. {
  2503. TPixelPosition TargetPixelPosition;
  2504. pkTargetInst->m_GraphicThingInstance.GetPixelPosition(&TargetPixelPosition);
  2505. return GetDistance(TargetPixelPosition);
  2506. }
  2508. float CInstanceBase::GetDistance(const TPixelPosition & c_rPixelPosition)
  2509. {
  2510. TPixelPosition PixelPosition;
  2511. m_GraphicThingInstance.GetPixelPosition(&PixelPosition);
  2513. float fdx = PixelPosition.x - c_rPixelPosition.x;
  2514. float fdy = PixelPosition.y - c_rPixelPosition.y;
  2516. return sqrtf((fdx*fdx) + (fdy*fdy));
  2517. }
  2519. CActorInstance& CInstanceBase::GetGraphicThingInstanceRef()
  2520. {
  2521. return m_GraphicThingInstance;
  2522. }
  2524. CActorInstance* CInstanceBase::GetGraphicThingInstancePtr()
  2525. {
  2526. return &m_GraphicThingInstance;
  2527. }
  2529. void CInstanceBase::RefreshActorInstance()
  2530. {
  2531. m_GraphicThingInstance.RefreshActorInstance();
  2532. }
  2534. void CInstanceBase::Refresh(DWORD dwMotIndex, bool isLoop)
  2535. {
  2536. RefreshState(dwMotIndex, isLoop);
  2537. }
  2539. void CInstanceBase::RestoreRenderMode()
  2540. {
  2541. m_GraphicThingInstance.RestoreRenderMode();
  2542. }
  2544. void CInstanceBase::SetAddRenderMode()
  2545. {
  2546. m_GraphicThingInstance.SetAddRenderMode();
  2547. }
  2549. void CInstanceBase::SetModulateRenderMode()
  2550. {
  2551. m_GraphicThingInstance.SetModulateRenderMode();
  2552. }
  2554. void CInstanceBase::SetRenderMode(int iRenderMode)
  2555. {
  2556. m_GraphicThingInstance.SetRenderMode(iRenderMode);
  2557. }
  2559. void CInstanceBase::SetAddColor(const D3DXCOLOR & c_rColor)
  2560. {
  2561. m_GraphicThingInstance.SetAddColor(c_rColor);
  2562. }
  2564. void CInstanceBase::__SetBlendRenderingMode()
  2565. {
  2566. m_GraphicThingInstance.SetBlendRenderMode();
  2567. }
  2569. void CInstanceBase::__SetAlphaValue(float fAlpha)
  2570. {
  2571. m_GraphicThingInstance.SetAlphaValue(fAlpha);
  2572. }
  2574. float CInstanceBase::__GetAlphaValue()
  2575. {
  2576. return m_GraphicThingInstance.GetAlphaValue();
  2577. }
  2579. ///////////////////////////////////////////////////////////////////////////////////////////////////
  2580. // Part
  2582. void CInstanceBase::SetHair(DWORD eHair)
  2583. {
  2584. if (!HAIR_COLOR_ENABLE)
  2585. return;
  2587. if (IsPC()==false)
  2588. return;
  2589. m_awPart[CRaceData::PART_HAIR] = eHair;
  2590. m_GraphicThingInstance.SetHair(eHair);
  2591. }
  2593. void CInstanceBase::ChangeHair(DWORD eHair)
  2594. {
  2595. if (!HAIR_COLOR_ENABLE)
  2596. return;
  2598. if (IsPC()==false)
  2599. return;
  2601. if (GetPart(CRaceData::PART_HAIR)==eHair)
  2602. return;
  2604. SetHair(eHair);
  2606. //int type = m_GraphicThingInstance.GetMotionMode();
  2608. RefreshState(CRaceMotionData::NAME_WAIT, true);
  2609. //RefreshState(type, true);
  2610. }
  2612. void CInstanceBase::SetArmor(DWORD dwArmor)
  2613. {
  2614. DWORD dwShape;
  2615. if (__ArmorVnumToShape(dwArmor, &dwShape))
  2616. {
  2617. CItemData * pItemData;
  2618. if (CItemManager::Instance().GetItemDataPointer(dwArmor, &pItemData))
  2619. {
  2620. float fSpecularPower=pItemData->GetSpecularPowerf();
  2621. SetShape(dwShape, fSpecularPower);
  2622. __GetRefinedEffect(pItemData);
  2623. return;
  2624. }
  2625. else
  2626. __ClearArmorRefineEffect();
  2627. }
  2629. SetShape(dwArmor);
  2630. }
  2632. void CInstanceBase::SetShape(DWORD eShape, float fSpecular)
  2633. {
  2634. if (IsPoly())
  2635. {
  2636. m_GraphicThingInstance.SetShape(0);
  2637. }
  2638. else
  2639. {
  2640. m_GraphicThingInstance.SetShape(eShape, fSpecular);
  2641. }
  2643. m_eShape = eShape;
  2644. }
  2648. DWORD CInstanceBase::GetWeaponType()
  2649. {
  2650. DWORD dwWeapon = GetPart(CRaceData::PART_WEAPON);
  2651. CItemData * pItemData;
  2652. if (!CItemManager::Instance().GetItemDataPointer(dwWeapon, &pItemData))
  2653. return CItemData::WEAPON_NONE;
  2655. return pItemData->GetWeaponType();
  2656. }
  2658. /*
  2659. void CInstanceBase::SetParts(const WORD * c_pParts)
  2660. {
  2661. if (IsPoly())
  2662. return;
  2664. if (__IsShapeAnimalWear())
  2665. return;
  2667. UINT eWeapon=c_pParts[CRaceData::PART_WEAPON];
  2669. if (__IsChangableWeapon(eWeapon) == false)
  2670. eWeapon = 0;
  2672. if (eWeapon != m_GraphicThingInstance.GetPartItemID(CRaceData::PART_WEAPON))
  2673. {
  2674. m_GraphicThingInstance.AttachPart(CRaceData::PART_MAIN, CRaceData::PART_WEAPON, eWeapon);
  2675. m_awPart[CRaceData::PART_WEAPON] = eWeapon;
  2676. }
  2678. __AttachHorseSaddle();
  2679. }
  2680. */
  2682. void CInstanceBase::__ClearWeaponRefineEffect()
  2683. {
  2684. if (m_swordRefineEffectRight)
  2685. {
  2686. __DetachEffect(m_swordRefineEffectRight);
  2687. m_swordRefineEffectRight = 0;
  2688. }
  2689. if (m_swordRefineEffectLeft)
  2690. {
  2691. __DetachEffect(m_swordRefineEffectLeft);
  2692. m_swordRefineEffectLeft = 0;
  2693. }
  2694. }
  2696. void CInstanceBase::__ClearArmorRefineEffect()
  2697. {
  2698. if (m_armorRefineEffect)
  2699. {
  2700. __DetachEffect(m_armorRefineEffect);
  2701. m_armorRefineEffect = 0;
  2702. }
  2703. }
  2705. UINT CInstanceBase::__GetRefinedEffect(CItemData* pItem)
  2706. {
  2707. DWORD refine = max(pItem->GetRefine() + pItem->GetSocketCount(),CItemData::ITEM_SOCKET_MAX_NUM) - CItemData::ITEM_SOCKET_MAX_NUM;
  2708. switch (pItem->GetType())
  2709. {
  2710. case CItemData::ITEM_TYPE_WEAPON:
  2711. __ClearWeaponRefineEffect();
  2712. if (refine < 7) //ÇöÀç Á¦·Ãµµ 7 ÀÌ»ó¸¸ ÀÌÆåÆ®°¡ ÀÖ½À´Ï´Ù.
  2713. return 0;
  2714. switch(pItem->GetSubType())
  2715. {
  2716. case CItemData::WEAPON_DAGGER:
  2717. m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7+refine-7;
  2718. m_swordRefineEffectLeft = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7_LEFT+refine-7;
  2719. break;
  2720. case CItemData::WEAPON_FAN:
  2721. m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_FANBELL_REFINED7+refine-7;
  2722. break;
  2723. case CItemData::WEAPON_ARROW:
  2724. case CItemData::WEAPON_BELL:
  2725. m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_SMALLSWORD_REFINED7+refine-7;
  2726. break;
  2727. case CItemData::WEAPON_BOW:
  2728. m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_BOW_REFINED7+refine-7;
  2729. break;
  2730. default:
  2731. m_swordRefineEffectRight = EFFECT_REFINED+EFFECT_SWORD_REFINED7+refine-7;
  2732. }
  2733. if (m_swordRefineEffectRight)
  2734. m_swordRefineEffectRight = __AttachEffect(m_swordRefineEffectRight);
  2735. if (m_swordRefineEffectLeft)
  2736. m_swordRefineEffectLeft = __AttachEffect(m_swordRefineEffectLeft);
  2737. break;
  2738. case CItemData::ITEM_TYPE_ARMOR:
  2739. __ClearArmorRefineEffect();
  2741. // °©¿Ê Ưȭ ÀÌÆåÆ®
  2742. if (pItem->GetSubType() == CItemData::ARMOR_BODY)
  2743. {
  2744. DWORD vnum = pItem->GetIndex();
  2746. if (12010 <= vnum && vnum <= 12049)
  2747. {
  2748. __AttachEffect(EFFECT_REFINED+EFFECT_BODYARMOR_SPECIAL);
  2749. __AttachEffect(EFFECT_REFINED+EFFECT_BODYARMOR_SPECIAL2);
  2750. }
  2751. }
  2753. if (refine < 7) //ÇöÀç Á¦·Ãµµ 7 ÀÌ»ó¸¸ ÀÌÆåÆ®°¡ ÀÖ½À´Ï´Ù.
  2754. return 0;
  2756. if (pItem->GetSubType() == CItemData::ARMOR_BODY)
  2757. {
  2758. m_armorRefineEffect = EFFECT_REFINED+EFFECT_BODYARMOR_REFINED7+refine-7;
  2759. __AttachEffect(m_armorRefineEffect);
  2760. }
  2761. break;
  2762. }
  2763. return 0;
  2764. }
  2766. bool CInstanceBase::SetWeapon(DWORD eWeapon)
  2767. {
  2768. if (IsPoly())
  2769. return false;
  2771. if (__IsShapeAnimalWear())
  2772. return false;
  2774. if (__IsChangableWeapon(eWeapon) == false)
  2775. eWeapon = 0;
  2777. m_GraphicThingInstance.AttachWeapon(eWeapon);
  2778. m_awPart[CRaceData::PART_WEAPON] = eWeapon;
  2780. //Weapon Effect
  2781. CItemData * pItemData;
  2782. if (CItemManager::Instance().GetItemDataPointer(eWeapon, &pItemData))
  2783. __GetRefinedEffect(pItemData);
  2784. else
  2785. __ClearWeaponRefineEffect();
  2787. return true;
  2788. }
  2790. void CInstanceBase::ChangeWeapon(DWORD eWeapon)
  2791. {
  2792. if (eWeapon == m_GraphicThingInstance.GetPartItemID(CRaceData::PART_WEAPON))
  2793. return;
  2795. if (SetWeapon(eWeapon))
  2796. RefreshState(CRaceMotionData::NAME_WAIT, true);
  2797. }
  2799. bool CInstanceBase::ChangeArmor(DWORD dwArmor)
  2800. {
  2801. DWORD eShape;
  2802. __ArmorVnumToShape(dwArmor, &eShape);
  2804. if (GetShape()==eShape)
  2805. return false;
  2807. CAffectFlagContainer kAffectFlagContainer;
  2808. kAffectFlagContainer.CopyInstance(m_kAffectFlagContainer);
  2810. DWORD dwVID = GetVirtualID();
  2811. DWORD dwRace = GetRace();
  2812. DWORD eHair = GetPart(CRaceData::PART_HAIR);
  2813. DWORD eWeapon = GetPart(CRaceData::PART_WEAPON);
  2814. float fRot = GetRotation();
  2815. float fAdvRot = GetAdvancingRotation();
  2817. if (IsWalking())
  2818. EndWalking();
  2820. // 2004.07.25.myevan.ÀÌÆåÆ® ¾È ºÙ´Â ¹®Á¦
  2821. //////////////////////////////////////////////////////
  2822. __ClearAffects();
  2823. //////////////////////////////////////////////////////
  2825. if (!SetRace(dwRace))
  2826. {
  2827. TraceError("CPythonCharacterManager::ChangeArmor - SetRace VID[%d] Race[%d] ERROR", dwVID, dwRace);
  2828. return false;
  2829. }
  2831. SetArmor(dwArmor);
  2832. SetHair(eHair);
  2833. SetWeapon(eWeapon);
  2835. SetRotation(fRot);
  2836. SetAdvancingRotation(fAdvRot);
  2838. __AttachHorseSaddle();
  2840. RefreshState(CRaceMotionData::NAME_WAIT, TRUE);
  2842. // 2004.07.25.myevan.ÀÌÆåÆ® ¾È ºÙ´Â ¹®Á¦
  2843. /////////////////////////////////////////////////
  2844. SetAffectFlagContainer(kAffectFlagContainer);
  2845. /////////////////////////////////////////////////
  2847. CActorInstance::IEventHandler& rkEventHandler=GetEventHandlerRef();
  2848. rkEventHandler.OnChangeShape();
  2850. return true;
  2851. }
  2853. bool CInstanceBase::__IsShapeAnimalWear()
  2854. {
  2855. if (100 == GetShape() ||
  2856. 101 == GetShape() ||
  2857. 102 == GetShape() ||
  2858. 103 == GetShape())
  2859. return true;
  2861. return false;
  2862. }
  2864. DWORD CInstanceBase::__GetRaceType()
  2865. {
  2866. return m_eRaceType;
  2867. }
  2870. void CInstanceBase::RefreshState(DWORD dwMotIndex, bool isLoop)
  2871. {
  2872. DWORD dwPartItemID = m_GraphicThingInstance.GetPartItemID(CRaceData::PART_WEAPON);
  2874. BYTE byItemType = 0xff;
  2875. BYTE bySubType = 0xff;
  2877. CItemManager & rkItemMgr = CItemManager::Instance();
  2878. CItemData * pItemData;
  2880. if (rkItemMgr.GetItemDataPointer(dwPartItemID, &pItemData))
  2881. {
  2882. byItemType = pItemData->GetType();
  2883. bySubType = pItemData->GetWeaponType();
  2884. }
  2886. if (IsPoly())
  2887. {
  2888. SetMotionMode(CRaceMotionData::MODE_GENERAL);
  2889. }
  2890. else if (IsWearingDress())
  2891. {
  2892. SetMotionMode(CRaceMotionData::MODE_WEDDING_DRESS);
  2893. }
  2894. else if (IsHoldingPickAxe())
  2895. {
  2896. if (m_kHorse.IsMounting())
  2897. {
  2898. SetMotionMode(CRaceMotionData::MODE_HORSE);
  2899. }
  2900. else
  2901. {
  2902. SetMotionMode(CRaceMotionData::MODE_GENERAL);
  2903. }
  2904. }
  2905. else if (CItemData::ITEM_TYPE_ROD == byItemType)
  2906. {
  2907. if (m_kHorse.IsMounting())
  2908. {
  2909. SetMotionMode(CRaceMotionData::MODE_HORSE);
  2910. }
  2911. else
  2912. {
  2913. SetMotionMode(CRaceMotionData::MODE_FISHING);
  2914. }
  2915. }
  2916. else if (m_kHorse.IsMounting())
  2917. {
  2918. switch (bySubType)
  2919. {
  2920. case CItemData::WEAPON_SWORD:
  2921. SetMotionMode(CRaceMotionData::MODE_HORSE_ONEHAND_SWORD);
  2922. break;
  2924. case CItemData::WEAPON_TWO_HANDED:
  2925. SetMotionMode(CRaceMotionData::MODE_HORSE_TWOHAND_SWORD); // Only Warrior
  2926. break;
  2928. case CItemData::WEAPON_DAGGER:
  2929. SetMotionMode(CRaceMotionData::MODE_HORSE_DUALHAND_SWORD); // Only Assassin
  2930. break;
  2932. case CItemData::WEAPON_FAN:
  2933. SetMotionMode(CRaceMotionData::MODE_HORSE_FAN); // Only Shaman
  2934. break;
  2936. case CItemData::WEAPON_BELL:
  2937. SetMotionMode(CRaceMotionData::MODE_HORSE_BELL); // Only Shaman
  2938. break;
  2940. case CItemData::WEAPON_BOW:
  2941. SetMotionMode(CRaceMotionData::MODE_HORSE_BOW); // Only Shaman
  2942. break;
  2944. default:
  2945. SetMotionMode(CRaceMotionData::MODE_HORSE);
  2946. break;
  2947. }
  2948. }
  2949. else
  2950. {
  2951. switch (bySubType)
  2952. {
  2953. case CItemData::WEAPON_SWORD:
  2954. SetMotionMode(CRaceMotionData::MODE_ONEHAND_SWORD);
  2955. break;
  2957. case CItemData::WEAPON_TWO_HANDED:
  2958. SetMotionMode(CRaceMotionData::MODE_TWOHAND_SWORD); // Only Warrior
  2959. break;
  2961. case CItemData::WEAPON_DAGGER:
  2962. SetMotionMode(CRaceMotionData::MODE_DUALHAND_SWORD); // Only Assassin
  2963. break;
  2965. case CItemData::WEAPON_BOW:
  2966. SetMotionMode(CRaceMotionData::MODE_BOW); // Only Assassin
  2967. break;
  2969. case CItemData::WEAPON_FAN:
  2970. SetMotionMode(CRaceMotionData::MODE_FAN); // Only Shaman
  2971. break;
  2973. case CItemData::WEAPON_BELL:
  2974. SetMotionMode(CRaceMotionData::MODE_BELL); // Only Shaman
  2975. break;
  2977. case CItemData::WEAPON_ARROW:
  2978. default:
  2979. SetMotionMode(CRaceMotionData::MODE_GENERAL);
  2980. break;
  2981. }
  2982. }
  2984. if (isLoop)
  2985. m_GraphicThingInstance.InterceptLoopMotion(dwMotIndex);
  2986. else
  2987. m_GraphicThingInstance.InterceptOnceMotion(dwMotIndex);
  2989. RefreshActorInstance();
  2990. }
  2992. ///////////////////////////////////////////////////////////////////////////////////////////////////
  2993. // Device
  2995. void CInstanceBase::RegisterBoundingSphere()
  2996. {
  2997. // Stone ÀÏ °æ¿ì DeforomNoSkin À» Çϸé
  2998. // ³«ÇÏÇÏ´Â ¾Ö´Ï¸ŞÀÌ¼Ç °°Àº °æ¿ì ¾Ö´Ï¸ŞÀ̼ÇÀÌ
  2999. // ¹Ù¿îµå ¹Ú½º¿¡ ¿µÇâÀ» ¹ÌÃÄ ÄøµÀÌ Á¦´ë·Î ÀÌ·ç¾îÁöÁö ¾Ê´Â´Ù.
  3000. if (!IsStone())
  3001. {
  3002. m_GraphicThingInstance.DeformNoSkin();
  3003. }
  3005. m_GraphicThingInstance.RegisterBoundingSphere();
  3006. }
  3008. bool CInstanceBase::CreateDeviceObjects()
  3009. {
  3010. return m_GraphicThingInstance.CreateDeviceObjects();
  3011. }
  3013. void CInstanceBase::DestroyDeviceObjects()
  3014. {
  3015. m_GraphicThingInstance.DestroyDeviceObjects();
  3016. }
  3018. void CInstanceBase::Destroy()
  3019. {
  3020. DetachTextTail();
  3022. DismountHorse();
  3024. m_kQue_kCmdNew.clear();
  3026. __EffectContainer_Destroy();
  3027. __StoneSmoke_Destroy();
  3029. if (__IsMainInstance())
  3030. __ClearMainInstance();
  3032. m_GraphicThingInstance.Destroy();
  3034. __Initialize();
  3035. }
  3037. void CInstanceBase::__InitializeRotationSpeed()
  3038. {
  3039. SetRotationSpeed(c_fDefaultRotationSpeed);
  3040. }
  3042. void CInstanceBase::__Warrior_Initialize()
  3043. {
  3044. m_kWarrior.m_dwGeomgyeongEffect=0;
  3045. }
  3047. void CInstanceBase::__Initialize()
  3048. {
  3049. __Warrior_Initialize();
  3050. __StoneSmoke_Inialize();
  3051. __EffectContainer_Initialize();
  3052. __InitializeRotationSpeed();
  3054. SetEventHandler(CActorInstance::IEventHandler::GetEmptyPtr());
  3056. m_kAffectFlagContainer.Clear();
  3058. m_dwLevel = 0;
  3059. m_dwGuildID = 0;
  3060. m_dwEmpireID = 0;
  3062. m_eType = 0;
  3063. m_eRaceType = 0;
  3064. m_eShape = 0;
  3065. m_dwRace = 0;
  3066. m_dwVirtualNumber = 0;
  3068. m_dwBaseCmdTime=0;
  3069. m_dwBaseChkTime=0;
  3070. m_dwSkipTime=0;
  3072. m_GraphicThingInstance.Initialize();
  3074. m_dwAdvActorVID=0;
  3075. m_dwLastDmgActorVID=0;
  3077. m_nAverageNetworkGap=0;
  3078. m_dwNextUpdateHeightTime=0;
  3080. // Moving by keyboard
  3081. m_iRotatingDirection = DEGREE_DIRECTION_SAME;
  3083. // Moving by mouse
  3084. m_isTextTail = FALSE;
  3085. m_isGoing = FALSE;
  3086. NEW_SetSrcPixelPosition(TPixelPosition(0, 0, 0));
  3087. NEW_SetDstPixelPosition(TPixelPosition(0, 0, 0));
  3089. m_kPPosDust = TPixelPosition(0, 0, 0);
  3092. m_kQue_kCmdNew.clear();
  3094. m_dwLastComboIndex = 0;
  3096. m_swordRefineEffectRight = 0;
  3097. m_swordRefineEffectLeft = 0;
  3098. m_armorRefineEffect = 0;
  3100. m_sAlignment = 0;
  3101. m_byPKMode = 0;
  3102. m_isKiller = false;
  3103. m_isPartyMember = false;
  3105. m_bEnableTCPState = TRUE;
  3107. m_stName = "";
  3109. memset(m_awPart, 0, sizeof(m_awPart));
  3110. memset(m_adwCRCAffectEffect, 0, sizeof(m_adwCRCAffectEffect));
  3111. //memset(m_adwCRCEmoticonEffect, 0, sizeof(m_adwCRCEmoticonEffect));
  3112. memset(&m_kMovAfterFunc, 0, sizeof(m_kMovAfterFunc));
  3114. m_bDamageEffectType = false;
  3115. m_dwDuelMode = DUEL_NONE;
  3116. m_dwEmoticonTime = 0;
  3117. }
  3119. CInstanceBase::CInstanceBase()
  3120. {
  3121. __Initialize();
  3122. }
  3124. CInstanceBase::~CInstanceBase()
  3125. {
  3126. Destroy();
  3127. }
  3130. void CInstanceBase::GetBoundBox(D3DXVECTOR3 * vtMin, D3DXVECTOR3 * vtMax)
  3131. {
  3132. m_GraphicThingInstance.GetBoundBox(vtMin, vtMax);
  3133. }